diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp
index a7c5bf161d..df55ce1800 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp
+++ b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.cpp
@@ -1,1338 +1,1295 @@
/*============================================================================
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 "QmitkLabelSetWidget.h"
// mitk
#include <mitkAutoCropImageFilter.h>
#include <mitkCoreObjectFactory.h>
#include <mitkIOUtil.h>
#include <mitkLabelSetImage.h>
#include <mitkLabelSetImageToSurfaceThreadedFilter.h>
#include <mitkRenderingManager.h>
#include <mitkShowSegmentationAsSurface.h>
#include <mitkSliceBasedInterpolationController.h>
#include <mitkStatusBar.h>
#include <mitkSurfaceBasedInterpolationController.h>
#include <mitkToolManagerProvider.h>
// Qmitk
#include <QmitkDataStorageComboBox.h>
#include <QmitkNewSegmentationDialog.h>
#include <QmitkStyleManager.h>
-#include <QmitkSearchLabelDialog.h>
// Qt
#include <QColorDialog>
#include <QCompleter>
#include <QDateTime>
#include <QFileDialog>
#include <QMenu>
#include <QMessageBox>
#include <QPushButton>
#include <QStringListModel>
#include <QWidgetAction>
// itk
#include <itksys/SystemTools.hxx>
// todo:
// berry
//#include <berryIPreferencesService.h>
QmitkLabelSetWidget::QmitkLabelSetWidget(QWidget *parent)
- : QWidget(parent), m_DataStorage(nullptr), m_Completer(nullptr), m_ToolManager(nullptr)
+ : QWidget(parent), m_DataStorage(nullptr), m_Completer(nullptr), m_ToolManager(nullptr), m_ProcessingManualSelection(false)
{
m_Controls.setupUi(this);
m_ColorSequenceRainbow.GoToBegin();
m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
m_Controls.m_LabelSearchBox->setAlwaysShowClearIcon(true);
m_Controls.m_LabelSearchBox->setShowSearchIcon(true);
QStringList completionList;
completionList << "";
m_Completer = new QCompleter(completionList, this);
m_Completer->setCaseSensitivity(Qt::CaseInsensitive);
m_Controls.m_LabelSearchBox->setCompleter(m_Completer);
connect(m_Controls.m_LabelSearchBox, SIGNAL(returnPressed()), this, SLOT(OnSearchLabel()));
- // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(labelListModified(const QStringList&)), this, SLOT(
- // OnLabelListModified(const QStringList&)) );
- // connect( m_Controls.m_LabelSetTableWidget, SIGNAL(mergeLabel(int)), this, SLOT( OnMergeLabel(int)) );
QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
completeModel->setStringList(GetLabelStringList());
m_Controls.m_LabelSearchBox->setEnabled(false);
m_Controls.m_lblCaption->setText("");
InitializeTableWidget();
}
QmitkLabelSetWidget::~QmitkLabelSetWidget() {}
void QmitkLabelSetWidget::OnTableViewContextMenuRequested(const QPoint & /*pos*/)
{
int pixelValue = GetPixelValueOfSelectedItem();
if (-1 == pixelValue)
return;
QMenu *menu = new QMenu(m_Controls.m_LabelSetTableWidget);
if (m_Controls.m_LabelSetTableWidget->selectedItems().size() > 1)
{
QAction *mergeAction = new QAction(QIcon(":/Qmitk/MergeLabels.png"), "Merge selection on current label", this);
mergeAction->setEnabled(true);
QObject::connect(mergeAction, SIGNAL(triggered(bool)), this, SLOT(OnMergeLabels(bool)));
menu->addAction(mergeAction);
QAction *removeLabelsAction = new QAction(QIcon(":/Qmitk/RemoveLabel.png"), "Remove selected labels", this);
removeLabelsAction->setEnabled(true);
QObject::connect(removeLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnRemoveLabels(bool)));
menu->addAction(removeLabelsAction);
QAction *eraseLabelsAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "Erase selected labels", this);
eraseLabelsAction->setEnabled(true);
QObject::connect(eraseLabelsAction, SIGNAL(triggered(bool)), this, SLOT(OnEraseLabels(bool)));
menu->addAction(eraseLabelsAction);
- QAction *combineAndCreateSurfaceAction =
+ /*QAction* combineAndCreateSurfaceAction =
new QAction(QIcon(":/Qmitk/CreateSurface.png"), "Combine and create a surface", this);
combineAndCreateSurfaceAction->setEnabled(true);
QObject::connect(
- combineAndCreateSurfaceAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateSurface(bool)));
+ combineAndCreateSurfaceAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateSurface(bool)));*/
// menu->addAction(combineAndCreateSurfaceAction); Not implemented
- QAction *createMasksAction =
+ /*QAction* createMasksAction =
new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create a mask for each selected label", this);
createMasksAction->setEnabled(true);
- QObject::connect(createMasksAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateMasks(bool)));
+ QObject::connect(createMasksAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateMasks(bool)));*/
// menu->addAction(createMasksAction); Not implemented
- QAction *combineAndCreateMaskAction =
+ /*QAction* combineAndCreateMaskAction =
new QAction(QIcon(":/Qmitk/CreateMask.png"), "Combine and create a mask", this);
combineAndCreateMaskAction->setEnabled(true);
- QObject::connect(combineAndCreateMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateMask(bool)));
+ QObject::connect(combineAndCreateMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCombineAndCreateMask(bool)));*/
// menu->addAction(combineAndCreateMaskAction); Not implemented
}
else
{
QAction *renameAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "Rename...", this);
renameAction->setEnabled(true);
QObject::connect(renameAction, SIGNAL(triggered(bool)), this, SLOT(OnRenameLabel(bool)));
menu->addAction(renameAction);
QAction *removeAction = new QAction(QIcon(":/Qmitk/RemoveLabel.png"), "Remove...", this);
removeAction->setEnabled(true);
QObject::connect(removeAction, SIGNAL(triggered(bool)), this, SLOT(OnRemoveLabel(bool)));
menu->addAction(removeAction);
QAction *eraseAction = new QAction(QIcon(":/Qmitk/EraseLabel.png"), "Erase...", this);
eraseAction->setEnabled(true);
QObject::connect(eraseAction, SIGNAL(triggered(bool)), this, SLOT(OnEraseLabel(bool)));
menu->addAction(eraseAction);
- QAction *mergeAction = new QAction(QIcon(":/Qmitk/MergeLabels.png"), "Merge...", this);
- mergeAction->setEnabled(true);
- QObject::connect(mergeAction, SIGNAL(triggered(bool)), this, SLOT(OnMergeLabel(bool)));
- menu->addAction(mergeAction);
-
QAction *randomColorAction = new QAction(QIcon(":/Qmitk/RandomColor.png"), "Random color", this);
randomColorAction->setEnabled(true);
QObject::connect(randomColorAction, SIGNAL(triggered(bool)), this, SLOT(OnRandomColor(bool)));
menu->addAction(randomColorAction);
QAction *viewOnlyAction = new QAction(QIcon(":/Qmitk/visible.png"), "View only", this);
viewOnlyAction->setEnabled(true);
QObject::connect(viewOnlyAction, SIGNAL(triggered(bool)), this, SLOT(OnSetOnlyActiveLabelVisible(bool)));
menu->addAction(viewOnlyAction);
QAction *viewAllAction = new QAction(QIcon(":/Qmitk/visible.png"), "View all", this);
viewAllAction->setEnabled(true);
QObject::connect(viewAllAction, SIGNAL(triggered(bool)), this, SLOT(OnSetAllLabelsVisible(bool)));
menu->addAction(viewAllAction);
QAction *hideAllAction = new QAction(QIcon(":/Qmitk/invisible.png"), "Hide all", this);
hideAllAction->setEnabled(true);
QObject::connect(hideAllAction, SIGNAL(triggered(bool)), this, SLOT(OnSetAllLabelsInvisible(bool)));
menu->addAction(hideAllAction);
QAction *lockAllAction = new QAction(QIcon(":/Qmitk/lock.png"), "Lock all", this);
lockAllAction->setEnabled(true);
QObject::connect(lockAllAction, SIGNAL(triggered(bool)), this, SLOT(OnLockAllLabels(bool)));
menu->addAction(lockAllAction);
QAction *unlockAllAction = new QAction(QIcon(":/Qmitk/unlock.png"), "Unlock all", this);
unlockAllAction->setEnabled(true);
QObject::connect(unlockAllAction, SIGNAL(triggered(bool)), this, SLOT(OnUnlockAllLabels(bool)));
menu->addAction(unlockAllAction);
QAction *createSurfaceAction = new QAction(QIcon(":/Qmitk/CreateSurface.png"), "Create surface", this);
createSurfaceAction->setEnabled(true);
createSurfaceAction->setMenu(new QMenu());
QAction *tmp1 = createSurfaceAction->menu()->addAction(QString("Detailed"));
QAction *tmp2 = createSurfaceAction->menu()->addAction(QString("Smoothed"));
QObject::connect(tmp1, SIGNAL(triggered(bool)), this, SLOT(OnCreateDetailedSurface(bool)));
QObject::connect(tmp2, SIGNAL(triggered(bool)), this, SLOT(OnCreateSmoothedSurface(bool)));
menu->addAction(createSurfaceAction);
QAction *createMaskAction = new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create mask", this);
createMaskAction->setEnabled(true);
QObject::connect(createMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateMask(bool)));
menu->addAction(createMaskAction);
QAction *createCroppedMaskAction = new QAction(QIcon(":/Qmitk/CreateMask.png"), "Create cropped mask", this);
createCroppedMaskAction->setEnabled(true);
QObject::connect(createCroppedMaskAction, SIGNAL(triggered(bool)), this, SLOT(OnCreateCroppedMask(bool)));
// QAction* importAction = new QAction(QIcon(":/Qmitk/RenameLabel.png"), "Import...", this );
// importAction->setEnabled(true);
// QObject::connect( importAction, SIGNAL( triggered(bool) ), this, SLOT( OnImportSegmentationSession(bool) ) );
// menu->addAction(importAction);
menu->addAction(createCroppedMaskAction);
QSlider *opacitySlider = new QSlider;
opacitySlider->setMinimum(0);
opacitySlider->setMaximum(100);
opacitySlider->setOrientation(Qt::Horizontal);
QObject::connect(opacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OnOpacityChanged(int)));
QLabel *_OpacityLabel = new QLabel("Opacity: ");
QVBoxLayout *_OpacityWidgetLayout = new QVBoxLayout;
_OpacityWidgetLayout->setContentsMargins(4, 4, 4, 4);
_OpacityWidgetLayout->addWidget(_OpacityLabel);
_OpacityWidgetLayout->addWidget(opacitySlider);
QWidget *_OpacityWidget = new QWidget;
_OpacityWidget->setLayout(_OpacityWidgetLayout);
QWidgetAction *OpacityAction = new QWidgetAction(this);
OpacityAction->setDefaultWidget(_OpacityWidget);
// QObject::connect( m_OpacityAction, SIGNAL( changed() ), this, SLOT( OpacityActionChanged() ) );
auto workingImage = this->GetWorkingImage();
auto activeLayer = workingImage->GetActiveLayer();
auto label = workingImage->GetLabel(pixelValue, activeLayer);
if (nullptr != label)
{
auto opacity = label->GetOpacity();
opacitySlider->setValue(static_cast<int>(opacity * 100));
}
menu->addAction(OpacityAction);
}
menu->popup(QCursor::pos());
}
void QmitkLabelSetWidget::OnUnlockAllLabels(bool /*value*/)
{
GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsLocked(false);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkLabelSetWidget::OnLockAllLabels(bool /*value*/)
{
GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsLocked(true);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkLabelSetWidget::OnSetAllLabelsVisible(bool /*value*/)
{
GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsVisible(true);
UpdateAllTableWidgetItems();
}
void QmitkLabelSetWidget::OnSetAllLabelsInvisible(bool /*value*/)
{
GetWorkingImage()->GetActiveLabelSet()->SetAllLabelsVisible(false);
UpdateAllTableWidgetItems();
}
void QmitkLabelSetWidget::OnSetOnlyActiveLabelVisible(bool /*value*/)
{
mitk::LabelSetImage *workingImage = GetWorkingImage();
int pixelValue = GetPixelValueOfSelectedItem();
workingImage->GetActiveLabelSet()->SetAllLabelsVisible(false);
workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->SetVisible(true);
workingImage->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
this->WaitCursorOn();
const mitk::Point3D &pos =
workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetCenterOfMassCoordinates();
this->WaitCursorOff();
if (pos.GetVnlVector().max_value() > 0.0)
{
emit goToLabel(pos);
}
UpdateAllTableWidgetItems();
}
-void QmitkLabelSetWidget::OnMergeLabel(bool /*value*/)
-{
- QmitkSearchLabelDialog dialog(this);
- dialog.setWindowTitle("Select a second label..");
- dialog.SetLabelSuggestionList(GetLabelStringList());
- int dialogReturnValue = dialog.exec();
- if (dialogReturnValue == QDialog::Rejected)
- return;
-
- int sourcePixelValue = -1;
- for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); i++)
- {
- if (dialog.GetLabelSetWidgetTableCompleteWord() == QString(m_Controls.m_LabelSetTableWidget->item(i, 0)->text()))
- sourcePixelValue = m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt();
- }
-
- if (sourcePixelValue == -1)
- {
- MITK_INFO << "unknown label";
- return;
- }
-
- int pixelValue = GetPixelValueOfSelectedItem();
- GetWorkingImage()->MergeLabel(pixelValue, sourcePixelValue, GetWorkingImage()->GetActiveLayer());
-
- UpdateAllTableWidgetItems();
-}
-
void QmitkLabelSetWidget::OnEraseLabel(bool /*value*/)
{
int pixelValue = GetPixelValueOfSelectedItem();
QString question = "Do you really want to erase the contents of label \"";
question.append(
QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
question.append("\"?");
QMessageBox::StandardButton answerButton =
QMessageBox::question(this, "Erase label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
this->WaitCursorOn();
GetWorkingImage()->EraseLabel(pixelValue);
this->WaitCursorOff();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkLabelSetWidget::OnRemoveLabel(bool /*value*/)
{
int pixelValue = GetPixelValueOfSelectedItem();
QString question = "Do you really want to remove label \"";
question.append(
QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
question.append("\"?");
QMessageBox::StandardButton answerButton =
QMessageBox::question(this, "Remove label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
this->WaitCursorOn();
GetWorkingImage()->GetActiveLabelSet()->RemoveLabel(pixelValue);
GetWorkingImage()->EraseLabel(pixelValue);
this->WaitCursorOff();
}
ResetAllTableWidgetItems();
}
void QmitkLabelSetWidget::OnRenameLabel(bool /*value*/)
{
int pixelValue = GetPixelValueOfSelectedItem();
QmitkNewSegmentationDialog dialog(this);
dialog.setWindowTitle("Rename Label");
dialog.SetSuggestionList(m_OrganColors);
dialog.SetColor(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetColor());
dialog.SetSegmentationName(
QString::fromStdString(GetWorkingImage()->GetActiveLabelSet()->GetLabel(pixelValue)->GetName()));
if (dialog.exec() == QDialog::Rejected)
{
return;
}
QString segmentationName = dialog.GetSegmentationName();
if (segmentationName.isEmpty())
{
segmentationName = "Unnamed";
}
GetWorkingImage()->GetActiveLabelSet()->RenameLabel(pixelValue, segmentationName.toStdString(), dialog.GetColor());
GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
UpdateAllTableWidgetItems();
}
void QmitkLabelSetWidget::OnCombineAndCreateMask(bool /*value*/)
{
m_Controls.m_LabelSetTableWidget->selectedRanges();
// ...to do... //
}
void QmitkLabelSetWidget::OnCreateMasks(bool /*value*/)
{
m_Controls.m_LabelSetTableWidget->selectedRanges();
// ..to do.. //
}
void QmitkLabelSetWidget::OnCombineAndCreateSurface(bool /*value*/)
{
m_Controls.m_LabelSetTableWidget->selectedRanges();
// ..to do.. //
}
void QmitkLabelSetWidget::OnEraseLabels(bool /*value*/)
{
QString question = "Do you really want to erase the selected labels?";
QMessageBox::StandardButton answerButton = QMessageBox::question(
this, "Erase selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
if (ranges.isEmpty())
return;
std::vector<mitk::Label::PixelType> VectorOfLablePixelValues;
foreach (QTableWidgetSelectionRange a, ranges)
for (int i = a.topRow(); i <= a.bottomRow(); i++)
VectorOfLablePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
this->WaitCursorOn();
GetWorkingImage()->EraseLabels(VectorOfLablePixelValues, GetWorkingImage()->GetActiveLayer());
this->WaitCursorOff();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkLabelSetWidget::OnRemoveLabels(bool /*value*/)
{
QString question = "Do you really want to remove selected labels?";
QMessageBox::StandardButton answerButton = QMessageBox::question(
this, "Remove selected labels", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
if (ranges.isEmpty())
{
return;
}
std::vector<mitk::Label::PixelType> VectorOfLablePixelValues;
foreach (QTableWidgetSelectionRange a, ranges)
{
for (int i = a.topRow(); i <= a.bottomRow(); ++i)
{
VectorOfLablePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
}
}
this->WaitCursorOn();
GetWorkingImage()->RemoveLabels(VectorOfLablePixelValues, GetWorkingImage()->GetActiveLayer());
this->WaitCursorOff();
}
ResetAllTableWidgetItems();
}
void QmitkLabelSetWidget::OnMergeLabels(bool /*value*/)
{
int pixelValue = GetPixelValueOfSelectedItem();
QString question = "Do you really want to merge selected labels into \"";
question.append(
QString::fromStdString(GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetName()));
question.append("\"?");
QMessageBox::StandardButton answerButton = QMessageBox::question(
this, "Merge selected label", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
if (answerButton == QMessageBox::Yes)
{
QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
if (ranges.isEmpty())
{
return;
}
std::vector<mitk::Label::PixelType> vectorOfSourcePixelValues;
foreach (QTableWidgetSelectionRange a, ranges)
{
for (int i = a.topRow(); i <= a.bottomRow(); ++i)
{
vectorOfSourcePixelValues.push_back(m_Controls.m_LabelSetTableWidget->item(i, 0)->data(Qt::UserRole).toInt());
}
}
this->WaitCursorOn();
GetWorkingImage()->MergeLabels(pixelValue, vectorOfSourcePixelValues, GetWorkingImage()->GetActiveLayer());
this->WaitCursorOff();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkLabelSetWidget::OnLockedButtonClicked()
{
int row = -1;
for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
{
if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, LOCKED_COL))
{
row = i;
}
}
if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
{
int pixelValue = m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt();
GetWorkingImage()
->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
->SetLocked(!GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetLocked());
}
}
void QmitkLabelSetWidget::OnVisibleButtonClicked()
{
int row = -1;
for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
{
if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, VISIBLE_COL))
{
row = i;
break;
}
}
if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
{
QTableWidgetItem *item = m_Controls.m_LabelSetTableWidget->item(row, 0);
int pixelValue = item->data(Qt::UserRole).toInt();
GetWorkingImage()
->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
->SetVisible(!GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetVisible());
GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkLabelSetWidget::OnColorButtonClicked()
{
int row = -1;
for (int i = 0; i < m_Controls.m_LabelSetTableWidget->rowCount(); ++i)
{
if (sender() == m_Controls.m_LabelSetTableWidget->cellWidget(i, COLOR_COL))
{
row = i;
}
}
if (row >= 0 && row < m_Controls.m_LabelSetTableWidget->rowCount())
{
int pixelValue = m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt();
const mitk::Color &color = GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->GetColor();
QColor initial(color.GetRed() * 255, color.GetGreen() * 255, color.GetBlue() * 255);
QColor qcolor = QColorDialog::getColor(initial, nullptr, QString("Change color"));
if (!qcolor.isValid())
{
return;
}
QPushButton *button = static_cast<QPushButton *>(m_Controls.m_LabelSetTableWidget->cellWidget(row, COLOR_COL));
if (!button)
{
return;
}
button->setAutoFillBackground(true);
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(qcolor.red()));
styleSheet.append(",");
styleSheet.append(QString::number(qcolor.green()));
styleSheet.append(",");
styleSheet.append(QString::number(qcolor.blue()));
styleSheet.append("); border: 0;");
button->setStyleSheet(styleSheet);
mitk::Color newColor;
newColor.SetRed(qcolor.red() / 255.0);
newColor.SetGreen(qcolor.green() / 255.0);
newColor.SetBlue(qcolor.blue() / 255.0);
GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->SetColor(newColor);
GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
}
}
void QmitkLabelSetWidget::OnRandomColor(bool /*value*/)
{
int pixelValue = GetPixelValueOfSelectedItem();
GetWorkingImage()
->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())
->SetColor(m_ColorSequenceRainbow.GetNextColor());
GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
UpdateAllTableWidgetItems();
}
void QmitkLabelSetWidget::SetOrganColors(const QStringList &organColors)
{
m_OrganColors = organColors;
}
void QmitkLabelSetWidget::OnActiveLabelChanged(int pixelValue)
{
mitk::LabelSetImage *workingImage = GetWorkingImage();
assert(workingImage);
workingImage->GetActiveLabelSet()->SetActiveLabel(pixelValue);
// MITK_INFO << "Active Label set to << " << pixelValue;
mitk::SurfaceBasedInterpolationController *interpolator = mitk::SurfaceBasedInterpolationController::GetInstance();
if (interpolator)
{
interpolator->SetActiveLabel(pixelValue);
}
workingImage->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkLabelSetWidget::OnItemClicked(QTableWidgetItem *item)
{
if (!item)
return;
int pixelValue = item->data(Qt::UserRole).toInt();
QList<QTableWidgetSelectionRange> ranges = m_Controls.m_LabelSetTableWidget->selectedRanges();
if (!ranges.empty() && ranges.back().rowCount() == 1)
{
- SelectLabelByPixelValue(pixelValue);
+ m_ProcessingManualSelection = true;
OnActiveLabelChanged(pixelValue);
+ m_ProcessingManualSelection = false;
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkLabelSetWidget::OnItemDoubleClicked(QTableWidgetItem *item)
{
if (!item)
return;
int pixelValue = item->data(Qt::UserRole).toInt();
// OnItemClicked(item); <<-- Double click first call OnItemClicked
WaitCursorOn();
mitk::LabelSetImage *workingImage = GetWorkingImage();
workingImage->UpdateCenterOfMass(pixelValue, workingImage->GetActiveLayer());
const mitk::Point3D &pos =
workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetCenterOfMassCoordinates();
WaitCursorOff();
if (pos.GetVnlVector().max_value() > 0.0)
{
emit goToLabel(pos);
}
workingImage->Modified();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkLabelSetWidget::SelectLabelByPixelValue(mitk::Label::PixelType pixelValue)
{
- // MITK_INFO << "QmitkLabelSetWidget::SelectLabelByPixelValue " << pixelValue;
-
- if (!GetWorkingImage()->ExistLabel(pixelValue))
+ if (m_ProcessingManualSelection || !GetWorkingImage()->ExistLabel(pixelValue))
return;
+
for (int row = 0; row < m_Controls.m_LabelSetTableWidget->rowCount(); row++)
{
if (m_Controls.m_LabelSetTableWidget->item(row, 0)->data(Qt::UserRole).toInt() == pixelValue)
{
m_Controls.m_LabelSetTableWidget->clearSelection();
- m_Controls.m_LabelSetTableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
m_Controls.m_LabelSetTableWidget->selectRow(row);
m_Controls.m_LabelSetTableWidget->scrollToItem(m_Controls.m_LabelSetTableWidget->item(row, 0));
- m_Controls.m_LabelSetTableWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
return;
}
}
}
void QmitkLabelSetWidget::InsertTableWidgetItem(mitk::Label *label)
{
const mitk::Color &color = label->GetColor();
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0] * 255));
styleSheet.append(",");
styleSheet.append(QString::number(color[1] * 255));
styleSheet.append(",");
styleSheet.append(QString::number(color[2] * 255));
styleSheet.append("); border: 0;");
QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
int colWidth = (tableWidget->columnWidth(NAME_COL) < 180) ? 180 : tableWidget->columnWidth(NAME_COL) - 2;
QString text = fontMetrics().elidedText(label->GetName().c_str(), Qt::ElideMiddle, colWidth);
QTableWidgetItem *nameItem = new QTableWidgetItem(text);
nameItem->setTextAlignment(Qt::AlignCenter | Qt::AlignLeft);
// ---!---
// IMPORTANT: ADD PIXELVALUE TO TABLEWIDGETITEM.DATA
nameItem->setData(Qt::UserRole, QVariant(label->GetValue()));
// ---!---
QPushButton *pbColor = new QPushButton(tableWidget);
pbColor->setFixedSize(24, 24);
pbColor->setCheckable(false);
pbColor->setAutoFillBackground(true);
pbColor->setToolTip("Change label color");
pbColor->setStyleSheet(styleSheet);
connect(pbColor, SIGNAL(clicked()), this, SLOT(OnColorButtonClicked()));
QString transparentStyleSheet = QLatin1String("background-color: transparent; border: 0;");
QPushButton *pbLocked = new QPushButton(tableWidget);
pbLocked->setFixedSize(24, 24);
QIcon *iconLocked = new QIcon();
auto lockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg"));
auto unlockIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg"));
iconLocked->addPixmap(lockIcon.pixmap(64), QIcon::Normal, QIcon::Off);
iconLocked->addPixmap(unlockIcon.pixmap(64), QIcon::Normal, QIcon::On);
pbLocked->setIcon(*iconLocked);
pbLocked->setIconSize(QSize(24, 24));
pbLocked->setCheckable(true);
pbLocked->setToolTip("Lock/unlock label");
pbLocked->setChecked(!label->GetLocked());
pbLocked->setStyleSheet(transparentStyleSheet);
connect(pbLocked, SIGNAL(clicked()), this, SLOT(OnLockedButtonClicked()));
QPushButton *pbVisible = new QPushButton(tableWidget);
pbVisible->setFixedSize(24, 24);
pbVisible->setAutoRepeat(false);
QIcon *iconVisible = new QIcon();
auto visibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/visible.svg"));
auto invisibleIcon = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/invisible.svg"));
iconVisible->addPixmap(visibleIcon.pixmap(64), QIcon::Normal, QIcon::Off);
iconVisible->addPixmap(invisibleIcon.pixmap(64), QIcon::Normal, QIcon::On);
pbVisible->setIcon(*iconVisible);
pbVisible->setIconSize(QSize(24, 24));
pbVisible->setCheckable(true);
pbVisible->setToolTip("Show/hide label");
pbVisible->setChecked(!label->GetVisible());
pbVisible->setStyleSheet(transparentStyleSheet);
connect(pbVisible, SIGNAL(clicked()), this, SLOT(OnVisibleButtonClicked()));
int row = tableWidget->rowCount();
tableWidget->insertRow(row);
tableWidget->setRowHeight(row, 24);
tableWidget->setItem(row, 0, nameItem);
tableWidget->setCellWidget(row, 1, pbLocked);
tableWidget->setCellWidget(row, 2, pbColor);
tableWidget->setCellWidget(row, 3, pbVisible);
tableWidget->selectRow(row);
// m_LabelSetImage->SetActiveLabel(label->GetPixelValue());
// m_ToolManager->WorkingDataModified.Send();
// emit activeLabelChanged(label->GetPixelValue());
if (row == 0)
{
tableWidget->hideRow(row); // hide exterior label
}
}
void QmitkLabelSetWidget::UpdateAllTableWidgetItems()
{
mitk::LabelSetImage *workingImage = GetWorkingImage();
if (!workingImage)
return;
// add all labels
QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
m_LabelStringList.clear();
for (int i = 0; i < tableWidget->rowCount(); ++i)
{
UpdateTableWidgetItem(tableWidget->item(i, 0));
m_LabelStringList.append(tableWidget->item(i, 0)->text());
}
OnLabelListModified(m_LabelStringList);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkLabelSetWidget::UpdateTableWidgetItem(QTableWidgetItem *item)
{
mitk::LabelSetImage *workingImage = GetWorkingImage();
mitk::Label *label = workingImage->GetLabel(item->data(Qt::UserRole).toInt(), workingImage->GetActiveLayer());
const mitk::Color &color = label->GetColor();
QString styleSheet = "background-color:rgb(";
styleSheet.append(QString::number(color[0] * 255));
styleSheet.append(",");
styleSheet.append(QString::number(color[1] * 255));
styleSheet.append(",");
styleSheet.append(QString::number(color[2] * 255));
styleSheet.append("); border: 0;");
QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
int colWidth = (tableWidget->columnWidth(NAME_COL) < 180) ? 180 : tableWidget->columnWidth(NAME_COL) - 2;
QString text = fontMetrics().elidedText(label->GetName().c_str(), Qt::ElideMiddle, colWidth);
item->setText(text);
QPushButton *pbLocked = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 1));
pbLocked->setChecked(!label->GetLocked());
QPushButton *pbColor = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 2));
pbColor->setStyleSheet(styleSheet);
QPushButton *pbVisible = dynamic_cast<QPushButton *>(tableWidget->cellWidget(item->row(), 3));
pbVisible->setChecked(!label->GetVisible());
if (item->row() == 0)
{
tableWidget->hideRow(item->row()); // hide exterior label
}
}
void QmitkLabelSetWidget::ResetAllTableWidgetItems()
{
QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
// remove all rows
while (tableWidget->rowCount())
{
tableWidget->removeRow(0);
}
mitk::DataNode * workingNode = GetWorkingNode();
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
if (nullptr == workingImage)
{
return;
}
// add all labels
m_LabelStringList.clear();
mitk::LabelSet::LabelContainerConstIteratorType it = workingImage->GetActiveLabelSet()->IteratorConstBegin();
mitk::LabelSet::LabelContainerConstIteratorType end = workingImage->GetActiveLabelSet()->IteratorConstEnd();
int pixelValue = -1;
while (it != end)
{
InsertTableWidgetItem(it->second);
if (workingImage->GetActiveLabel() == it->second) // get active
pixelValue = it->first;
m_LabelStringList.append(QString(it->second->GetName().c_str()));
it++;
}
SelectLabelByPixelValue(pixelValue);
OnLabelListModified(m_LabelStringList);
std::stringstream captionText;
captionText << "Number of labels: " << workingImage->GetNumberOfLabels(workingImage->GetActiveLayer()) - 1;
m_Controls.m_lblCaption->setText(captionText.str().c_str());
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
emit LabelSetWidgetReset();
}
int QmitkLabelSetWidget::GetPixelValueOfSelectedItem()
{
if (m_Controls.m_LabelSetTableWidget->currentItem())
{
return m_Controls.m_LabelSetTableWidget->currentItem()->data(Qt::UserRole).toInt();
}
return -1;
}
QStringList &QmitkLabelSetWidget::GetLabelStringList()
{
return m_LabelStringList;
}
void QmitkLabelSetWidget::InitializeTableWidget()
{
- QTableWidget *tableWidged = m_Controls.m_LabelSetTableWidget;
-
- tableWidged->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
- tableWidged->setTabKeyNavigation(false);
- tableWidged->setAlternatingRowColors(false);
- tableWidged->setFocusPolicy(Qt::NoFocus);
- tableWidged->setColumnCount(4);
- tableWidged->resizeColumnToContents(NAME_COL);
- tableWidged->setColumnWidth(LOCKED_COL, 25);
- tableWidged->setColumnWidth(COLOR_COL, 25);
- tableWidged->setColumnWidth(VISIBLE_COL, 25);
- tableWidged->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
- tableWidged->setContextMenuPolicy(Qt::CustomContextMenu);
- tableWidged->horizontalHeader()->hide();
- tableWidged->setSortingEnabled(false);
- tableWidged->verticalHeader()->hide();
- tableWidged->setEditTriggers(QAbstractItemView::NoEditTriggers);
- tableWidged->setSelectionMode(QAbstractItemView::ExtendedSelection);
- tableWidged->setSelectionBehavior(QAbstractItemView::SelectRows);
-
- connect(tableWidged, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(OnItemClicked(QTableWidgetItem *)));
+ QTableWidget *tableWidget = m_Controls.m_LabelSetTableWidget;
+
+ tableWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
+ tableWidget->setTabKeyNavigation(false);
+ tableWidget->setAlternatingRowColors(false);
+ tableWidget->setFocusPolicy(Qt::NoFocus);
+ tableWidget->setColumnCount(4);
+ tableWidget->resizeColumnToContents(NAME_COL);
+ tableWidget->setColumnWidth(LOCKED_COL, 25);
+ tableWidget->setColumnWidth(COLOR_COL, 25);
+ tableWidget->setColumnWidth(VISIBLE_COL, 25);
+ tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
+ tableWidget->setContextMenuPolicy(Qt::CustomContextMenu);
+ tableWidget->horizontalHeader()->hide();
+ tableWidget->setSortingEnabled(false);
+ tableWidget->verticalHeader()->hide();
+ tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
+
+ connect(tableWidget, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(OnItemClicked(QTableWidgetItem *)));
connect(
- tableWidged, SIGNAL(itemDoubleClicked(QTableWidgetItem *)), this, SLOT(OnItemDoubleClicked(QTableWidgetItem *)));
- connect(tableWidged,
+ tableWidget, SIGNAL(itemDoubleClicked(QTableWidgetItem *)), this, SLOT(OnItemDoubleClicked(QTableWidgetItem *)));
+ connect(tableWidget,
SIGNAL(customContextMenuRequested(const QPoint &)),
this,
SLOT(OnTableViewContextMenuRequested(const QPoint &)));
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(activeLabelChanged(int)), this, SLOT(OnActiveLabelChanged(int))
// );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(importSegmentation()), this, SLOT( OnImportSegmentation()) );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(importLabeledImage()), this, SLOT( OnImportLabeledImage()) );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(renameLabel(int, const mitk::Color&, const std::string&)), this,
// SLOT(OnRenameLabel(int, const mitk::Color&, const std::string&)) );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createSurface(int, bool)), this, SLOT(OnCreateSurface(int, bool))
// );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(toggleOutline(bool)), this, SLOT(OnToggleOutline(bool)) );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(goToLabel(const mitk::Point3D&)), this, SIGNAL(goToLabel(const
// mitk::Point3D&)) );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(combineAndCreateSurface( const QList<QTableWidgetSelectionRange>&
// )),
// this, SLOT(OnCombineAndCreateSurface( const QList<QTableWidgetSelectionRange>&)) );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createMask(int)), this, SLOT(OnCreateMask(int)) );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(createCroppedMask(int)), this, SLOT(OnCreateCroppedMask(int)) );
// connect( m_Controls.m_LabelSetTableWidget, SIGNAL(combineAndCreateMask( const QList<QTableWidgetSelectionRange>&
// )),
// this, SLOT(OnCombineAndCreateMask( const QList<QTableWidgetSelectionRange>&)) );
}
void QmitkLabelSetWidget::OnOpacityChanged(int value)
{
int pixelValue = GetPixelValueOfSelectedItem();
float opacity = static_cast<float>(value) / 100.0f;
GetWorkingImage()->GetLabel(pixelValue, GetWorkingImage()->GetActiveLayer())->SetOpacity(opacity);
GetWorkingImage()->GetActiveLabelSet()->UpdateLookupTable(pixelValue);
}
void QmitkLabelSetWidget::setEnabled(bool enabled)
{
QWidget::setEnabled(enabled);
UpdateControls();
}
void QmitkLabelSetWidget::SetDataStorage(mitk::DataStorage *storage)
{
m_DataStorage = storage;
}
void QmitkLabelSetWidget::OnSearchLabel()
{
std::string text = m_Controls.m_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->setSelectionMode(QAbstractItemView::SingleSelection);
m_Controls.m_LabelSetTableWidget->selectRow(row);
m_Controls.m_LabelSetTableWidget->scrollToItem(nameItem);
- m_Controls.m_LabelSetTableWidget->setSelectionMode(QAbstractItemView::ExtendedSelection);
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 QmitkLabelSetWidget::OnLabelListModified(const QStringList &list)
{
QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
completeModel->setStringList(list);
}
mitk::LabelSetImage *QmitkLabelSetWidget::GetWorkingImage()
{
mitk::DataNode *workingNode = GetWorkingNode();
mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
assert(workingImage);
return workingImage;
}
mitk::DataNode *QmitkLabelSetWidget::GetWorkingNode()
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
return workingNode;
}
void QmitkLabelSetWidget::UpdateControls()
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
bool hasWorkingData = (workingNode != nullptr);
m_Controls.m_LabelSetTableWidget->setEnabled(hasWorkingData);
m_Controls.m_LabelSearchBox->setEnabled(hasWorkingData);
if (!hasWorkingData)
return;
QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
completeModel->setStringList(GetLabelStringList());
}
void QmitkLabelSetWidget::OnCreateCroppedMask(bool)
{
m_ToolManager->ActivateTool(-1);
mitk::LabelSetImage *workingImage = GetWorkingImage();
mitk::Image::Pointer maskImage;
int pixelValue = GetPixelValueOfSelectedItem();
try
{
this->WaitCursorOn();
mitk::AutoCropImageFilter::Pointer cropFilter = mitk::AutoCropImageFilter::New();
cropFilter->SetInput(workingImage->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 = workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->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(workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetColor());
maskNode->SetOpacity(1.0);
m_DataStorage->Add(maskNode, GetWorkingNode());
}
void QmitkLabelSetWidget::OnCreateMask(bool /*triggered*/)
{
m_ToolManager->ActivateTool(-1);
mitk::LabelSetImage *workingImage = GetWorkingImage();
mitk::Image::Pointer maskImage;
int pixelValue = GetPixelValueOfSelectedItem();
try
{
this->WaitCursorOn();
maskImage = workingImage->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 = workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->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(workingImage->GetLabel(pixelValue, workingImage->GetActiveLayer())->GetColor());
maskNode->SetOpacity(1.0);
m_DataStorage->Add(maskNode, GetWorkingNode());
}
void QmitkLabelSetWidget::OnToggleOutline(bool value)
{
mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
workingNode->SetBoolProperty("labelset.contour.active", value);
workingNode->GetData()->Modified(); // fixme: workaround to force data-type rendering (and not only property-type)
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkLabelSetWidget::OnCreateSmoothedSurface(bool /*triggered*/)
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode::Pointer workingNode = GetWorkingNode();
mitk::LabelSetImage *workingImage = GetWorkingImage();
int pixelValue = GetPixelValueOfSelectedItem();
mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer successCommand =
itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
successCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer errorCommand =
itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
errorCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
mitk::DataNode::Pointer groupNode = workingNode;
surfaceFilter->SetPointerParameter("Group node", groupNode);
surfaceFilter->SetPointerParameter("Input", workingImage);
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 QmitkLabelSetWidget::OnCreateDetailedSurface(bool /*triggered*/)
{
m_ToolManager->ActivateTool(-1);
mitk::DataNode::Pointer workingNode = GetWorkingNode();
mitk::LabelSetImage *workingImage = GetWorkingImage();
int pixelValue = GetPixelValueOfSelectedItem();
mitk::LabelSetImageToSurfaceThreadedFilter::Pointer surfaceFilter = mitk::LabelSetImageToSurfaceThreadedFilter::New();
itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer successCommand =
itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
successCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
surfaceFilter->AddObserver(mitk::ResultAvailable(), successCommand);
itk::SimpleMemberCommand<QmitkLabelSetWidget>::Pointer errorCommand =
itk::SimpleMemberCommand<QmitkLabelSetWidget>::New();
errorCommand->SetCallbackFunction(this, &QmitkLabelSetWidget::OnThreadedCalculationDone);
surfaceFilter->AddObserver(mitk::ProcessingError(), errorCommand);
mitk::DataNode::Pointer groupNode = workingNode;
surfaceFilter->SetPointerParameter("Group node", groupNode);
surfaceFilter->SetPointerParameter("Input", workingImage);
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 QmitkLabelSetWidget::OnImportLabeledImage()
{
/*
m_ToolManager->ActivateTool(-1);
mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
assert(referenceNode);
// Ask the user for a list of files to open
QStringList fileNames = QFileDialog::getOpenFileNames( this, "Open Image", m_LastFileOpenPath,
mitk::CoreObjectFactory::GetInstance()->GetFileExtensions());
if (fileNames.empty())
return;
try
{
this->WaitCursorOn();
mitk::Image::Pointer image = mitk::IOUtil::Load<mitk::Image>( fileNames.front().toStdString() );
if (image.IsNull())
{
this->WaitCursorOff();
QMessageBox::information(this, "Import Labeled Image", "Could not load the selected segmentation.\n");
return;
}
mitk::LabelSetImage::Pointer newImage = mitk::LabelSetImage::New();
newImage->InitializeByLabeledImage(image);
this->WaitCursorOff();
mitk::DataNode::Pointer newNode = mitk::DataNode::New();
std::string newName = referenceNode->GetName();
newName += "-labels";
newNode->SetName(newName);
newNode->SetData(newImage);
m_DataStorage->Add(newNode, referenceNode);
}
catch (mitk::Exception & e)
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(this, "Import Labeled Image", "Could not load the selected segmentation. See error log
for details.\n");
return;
}
this->UpdateControls();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
*/
}
void QmitkLabelSetWidget::OnImportSegmentation()
{
/*
m_ToolManager->ActivateTool(-1);
mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
assert(workingNode);
mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>( workingNode->GetData() );
assert(workingImage);
std::string fileExtensions("Segmentation files (*.lset);;");
QString qfileName = QFileDialog::getOpenFileName(this, "Import Segmentation", m_LastFileOpenPath,
fileExtensions.c_str() );
if (qfileName.isEmpty() ) return;
mitk::NrrdLabelSetImageReader::Pointer reader = mitk::NrrdLabelSetImageReader::New();
reader->SetFileName(qfileName.toLatin1());
try
{
this->WaitCursorOn();
reader->Update();
mitk::LabelSetImage::Pointer newImage = reader->GetOutput();
workingImage->Concatenate(newImage);
this->WaitCursorOff();
}
catch ( mitk::Exception& e )
{
this->WaitCursorOff();
MITK_ERROR << "Exception caught: " << e.GetDescription();
QMessageBox::information(this, "Import Segmentation", "Could not import the selected segmentation session.\n See
error log for details.\n");
}
*/
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkLabelSetWidget::WaitCursorOn()
{
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
}
void QmitkLabelSetWidget::WaitCursorOff()
{
this->RestoreOverrideCursor();
}
void QmitkLabelSetWidget::RestoreOverrideCursor()
{
QApplication::restoreOverrideCursor();
}
void QmitkLabelSetWidget::OnThreadedCalculationDone()
{
mitk::StatusBar::GetInstance()->Clear();
}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h
index 690186d7c8..12978f8022 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h
+++ b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidget.h
@@ -1,171 +1,171 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkLabelSetWidget_h
#define QmitkLabelSetWidget_h
#include "MitkSegmentationUIExports.h"
#include "mitkColorSequenceRainbow.h"
#include "mitkLabel.h"
#include "mitkNumericTypes.h"
#include <ui_QmitkLabelSetWidgetControls.h>
class QmitkDataStorageComboBox;
class QCompleter;
namespace mitk
{
class LabelSetImage;
class LabelSet;
class Label;
class DataStorage;
class ToolManager;
class DataNode;
}
class MITKSEGMENTATIONUI_EXPORT QmitkLabelSetWidget : public QWidget
{
Q_OBJECT
public:
explicit QmitkLabelSetWidget(QWidget *parent = nullptr);
~QmitkLabelSetWidget() override;
void SetDataStorage(mitk::DataStorage *storage);
void SetOrganColors(const QStringList &organColors);
void UpdateControls();
virtual void setEnabled(bool enabled);
QStringList &GetLabelStringList();
signals:
/// \brief Send a signal when it was requested to go to a label.
void goToLabel(const mitk::Point3D &);
void LabelSetWidgetReset();
public slots:
/**
* @brief Updates the current labels in the label set widget table. For each label (widget item) the 'UpdateTableWidgetItem' is called.
*
* Updating means setting the color box of the table, setting the column with and fill it with the label name.
* Furthermore the two push buttons for locking and showing/hiding the layer are checked/unchecked.
* This functions only changes the appearance of the table widget and no render window update is necessary.
*/
void UpdateAllTableWidgetItems();
/**
* @brief Resets the current labels in the label set widget table. For each label a widget item is inserted into the table.
*
* Resetting means removing all rows of the widget table and inserting new rows (labels) from the active label set (= layer) of the current working node.
* The currently active label is selected and 'Number of labels' is set.
* As this function is typically used after one label has been removed or the reference node has been changed (e.g.) the render windows have to be updated.
*/
void ResetAllTableWidgetItems();
void SelectLabelByPixelValue(mitk::Label::PixelType pixelValue);
private slots:
// LabelSet dependent
void OnOpacityChanged(int);
void OnUnlockAllLabels(bool);
void OnLockAllLabels(bool);
void OnSetAllLabelsVisible(bool);
void OnSetAllLabelsInvisible(bool);
void OnSetOnlyActiveLabelVisible(bool);
void OnRandomColor(bool);
void OnRemoveLabel(bool);
void OnRemoveLabels(bool);
void OnRenameLabel(bool);
void OnLockedButtonClicked();
void OnVisibleButtonClicked();
void OnColorButtonClicked();
void OnItemClicked(QTableWidgetItem *item);
void OnItemDoubleClicked(QTableWidgetItem *item);
void OnTableViewContextMenuRequested(const QPoint &);
void InsertTableWidgetItem(mitk::Label *label);
void UpdateTableWidgetItem(QTableWidgetItem *item);
// reaction to "returnPressed" signal from ...
void OnSearchLabel();
// reaction to the button "Change Label"
void OnActiveLabelChanged(int pixelValue);
// LabelSetImage Dependet
void OnCreateDetailedSurface(bool);
void OnCreateSmoothedSurface(bool);
// reaction to the signal "createMask" from QmitkLabelSetTableWidget
void OnCreateMask(bool);
void OnCreateMasks(bool);
// reaction to the signal "createCroppedMask" from QmitkLabelSetTableWidget
void OnCreateCroppedMask(bool);
void OnCombineAndCreateMask(bool);
void OnCombineAndCreateSurface(bool);
void OnEraseLabel(bool);
void OnEraseLabels(bool);
- // reaction to signal "mergeLabel" from QmitkLabelSetTableWidget
- void OnMergeLabel(bool);
void OnMergeLabels(bool);
// reaction to the button "Import Segmentation"
void OnImportSegmentation();
// reaction to the button "Import Labeled Image"
void OnImportLabeledImage();
// reaction to signal "labelListModified" from QmitkLabelSetTableWidget
void OnLabelListModified(const QStringList &list);
// reaction to the signal "toggleOutline" from QmitkLabelSetTableWidget
void OnToggleOutline(bool);
private:
enum TableColumns
{
NAME_COL = 0,
LOCKED_COL,
COLOR_COL,
VISIBLE_COL
};
void WaitCursorOn();
void WaitCursorOff();
void RestoreOverrideCursor();
void OnThreadedCalculationDone();
void InitializeTableWidget();
int GetPixelValueOfSelectedItem();
mitk::LabelSetImage *GetWorkingImage();
mitk::DataNode *GetWorkingNode();
Ui::QmitkLabelSetWidgetControls m_Controls;
mitk::ColorSequenceRainbow m_ColorSequenceRainbow;
mitk::DataStorage *m_DataStorage;
QCompleter *m_Completer;
mitk::ToolManager *m_ToolManager;
QStringList m_OrganColors;
QStringList m_LabelStringList;
+
+ bool m_ProcessingManualSelection;
};
#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui
index a9b4c069a3..0f28e488f2 100644
--- a/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui
+++ b/Modules/SegmentationUI/Qmitk/QmitkLabelSetWidgetControls.ui
@@ -1,66 +1,70 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkLabelSetWidgetControls</class>
<widget class="QWidget" name="QmitkLabelSetWidgetControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>312</width>
<height>366</height>
</rect>
</property>
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="MinimumExpanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="styleSheet">
<string notr="true"/>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="leftMargin">
<number>6</number>
</property>
<property name="topMargin">
<number>6</number>
</property>
<property name="rightMargin">
<number>6</number>
</property>
<property name="bottomMargin">
<number>6</number>
</property>
<item>
<widget class="QLabel" name="m_lblCaption">
<property name="text">
<string>Caption</string>
</property>
</widget>
</item>
<item>
- <widget class="QTableWidget" name="m_LabelSetTableWidget"/>
+ <widget class="QTableWidget" name="m_LabelSetTableWidget">
+ <property name="selectionBehavior">
+ <enum>QAbstractItemView::SelectRows</enum>
+ </property>
+ </widget>
</item>
<item>
<widget class="ctkSearchBox" name="m_LabelSearchBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Fixed">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
</widget>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>ctkSearchBox</class>
<extends>QLineEdit</extends>
<header location="global">ctkSearchBox.h</header>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.cpp b/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.cpp
deleted file mode 100644
index 0b94020314..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*============================================================================
-
-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 "QmitkSearchLabelDialog.h"
-
-#include <itkRGBPixel.h>
-
-#include <QAbstractItemModel>
-#include <QColorDialog>
-#include <QStringListModel>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qlineedit.h>
-#include <qpushbutton.h>
-
-QmitkSearchLabelDialog::QmitkSearchLabelDialog(QWidget *parent, Qt::WindowFlags f) : QDialog(parent, f)
-{
- m_Controls = new Ui::QmitkSearchLabelDialogGUI();
- m_Controls->setupUi(this);
-
- m_LabelIndex = -1;
-
- QStringList completionList;
- completionList << "";
- m_Completer = new QCompleter(completionList);
- m_Completer->setCaseSensitivity(Qt::CaseInsensitive);
- m_Controls->m_LabelName->setCompleter(m_Completer);
-
- connect(m_Completer, SIGNAL(activated(const QString &)), this, SLOT(OnLabelCompleterChanged(const QString &)));
- connect(m_Controls->m_pbCancel, SIGNAL(clicked()), this, SLOT(reject()));
- connect(m_Controls->m_pbAccept, SIGNAL(clicked()), this, SLOT(accept()));
-
- m_Controls->m_LabelName->setFocus();
-}
-
-QmitkSearchLabelDialog::~QmitkSearchLabelDialog()
-{
-}
-
-int QmitkSearchLabelDialog::GetLabelSetWidgetTableIndex()
-{
- return m_LabelIndex;
-}
-
-QString QmitkSearchLabelDialog::GetLabelSetWidgetTableCompleteWord()
-{
- return m_CompleteWord;
-}
-
-void QmitkSearchLabelDialog::SetLabelSuggestionList(QStringList stringList)
-{
- m_LabelList = stringList;
- QStringListModel *completeModel = static_cast<QStringListModel *>(m_Completer->model());
- completeModel->setStringList(m_LabelList);
-}
-
-void QmitkSearchLabelDialog::OnLabelCompleterChanged(const QString &completedWord)
-{
- if (m_LabelList.contains(completedWord))
- {
- m_LabelIndex = m_LabelList.indexOf(completedWord);
- m_CompleteWord = completedWord;
- // emit(goToLabel(m_LabelIndex));
- }
-}
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.h b/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.h
deleted file mode 100644
index 670a319b96..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialog.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*============================================================================
-
-The Medical Imaging Interaction Toolkit (MITK)
-
-Copyright (c) German Cancer Research Center (DKFZ)
-All rights reserved.
-
-Use of this source code is governed by a 3-clause BSD license that can be
-found in the LICENSE file.
-
-============================================================================*/
-
-#ifndef QmitkSearchLabelDialog_h_Included
-#define QmitkSearchLabelDialog_h_Included
-
-#include "MitkSegmentationUIExports.h"
-
-#include <ui_QmitkSearchLabelDialogGUI.h>
-
-#include <QCompleter>
-#include <QDialog>
-
-class MITKSEGMENTATIONUI_EXPORT QmitkSearchLabelDialog : public QDialog
-{
- Q_OBJECT
-
-public:
- QmitkSearchLabelDialog(QWidget *parent = nullptr, Qt::WindowFlags f = nullptr);
- ~QmitkSearchLabelDialog() override;
-
- int GetLabelSetWidgetTableIndex();
-
- QString GetLabelSetWidgetTableCompleteWord();
-
- void SetLabelSuggestionList(QStringList stringList);
-
-signals:
-
- void goToLabel(int);
-
-public slots:
-
-protected slots:
-
- void OnLabelCompleterChanged(const QString &completedWord);
-
-protected:
- Ui::QmitkSearchLabelDialogGUI *m_Controls;
-
- QCompleter *m_Completer;
-
- QStringList m_LabelList;
-
- int m_LabelIndex;
-
- QString m_CompleteWord;
-};
-
-#endif
diff --git a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialogGUI.ui b/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialogGUI.ui
deleted file mode 100644
index f665e53128..0000000000
--- a/Modules/SegmentationUI/Qmitk/QmitkSearchLabelDialogGUI.ui
+++ /dev/null
@@ -1,70 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>QmitkSearchLabelDialogGUI</class>
- <widget class="QDialog" name="QmitkSearchLabelDialogGUI">
- <property name="geometry">
- <rect>
- <x>0</x>
- <y>0</y>
- <width>259</width>
- <height>71</height>
- </rect>
- </property>
- <property name="sizePolicy">
- <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="windowTitle">
- <string>Search Label</string>
- </property>
- <property name="autoFillBackground">
- <bool>false</bool>
- </property>
- <property name="sizeGripEnabled">
- <bool>false</bool>
- </property>
- <property name="modal">
- <bool>true</bool>
- </property>
- <layout class="QVBoxLayout" name="verticalLayout">
- <item>
- <widget class="QLineEdit" name="m_LabelName"/>
- </item>
- <item>
- <layout class="QHBoxLayout" name="horizontalLayout_4">
- <item>
- <spacer name="horizontalSpacer_2">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QPushButton" name="m_pbAccept">
- <property name="text">
- <string>Accept</string>
- </property>
- </widget>
- </item>
- <item>
- <widget class="QPushButton" name="m_pbCancel">
- <property name="text">
- <string>Cancel</string>
- </property>
- </widget>
- </item>
- </layout>
- </item>
- </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>
diff --git a/Modules/SegmentationUI/files.cmake b/Modules/SegmentationUI/files.cmake
index 63a50b2923..b3693314f8 100644
--- a/Modules/SegmentationUI/files.cmake
+++ b/Modules/SegmentationUI/files.cmake
@@ -1,97 +1,94 @@
set( CPP_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUI.cpp
Qmitk/QmitkAutoSegmentationToolGUIBase.cpp
Qmitk/QmitkAutoMLSegmentationToolGUIBase.cpp
Qmitk/QmitkBinaryThresholdToolGUIBase.cpp
Qmitk/QmitkBinaryThresholdToolGUI.cpp
Qmitk/QmitkBinaryThresholdULToolGUI.cpp
Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.cpp
Qmitk/QmitkConfirmSegmentationDialog.cpp
Qmitk/QmitkCopyToClipBoardDialog.cpp
Qmitk/QmitkDrawPaintbrushToolGUI.cpp
Qmitk/QmitkErasePaintbrushToolGUI.cpp
Qmitk/QmitkFastMarchingToolGUIBase.cpp
Qmitk/QmitkFastMarchingTool3DGUI.cpp
Qmitk/QmitkFastMarchingToolGUI.cpp
Qmitk/QmitkLiveWireTool2DGUI.cpp
Qmitk/QmitkNewSegmentationDialog.cpp
Qmitk/QmitkOtsuTool3DGUI.cpp
Qmitk/QmitkPaintbrushToolGUI.cpp
Qmitk/QmitkPickingToolGUI.cpp
Qmitk/QmitkPixelManipulationToolGUI.cpp
Qmitk/QmitkSlicesInterpolator.cpp
Qmitk/QmitkToolGUI.cpp
Qmitk/QmitkToolGUIArea.cpp
Qmitk/QmitkToolSelectionBox.cpp
Qmitk/QmitkWatershedToolGUI.cpp
Qmitk/QmitknnUNetToolGUI.cpp
Qmitk/QmitknnUNetToolSlots.cpp
#Added from ML
Qmitk/QmitkLabelSetWidget.cpp
Qmitk/QmitkSurfaceStampWidget.cpp
Qmitk/QmitkMaskStampWidget.cpp
Qmitk/QmitkSliceBasedInterpolatorWidget.cpp
Qmitk/QmitkSurfaceBasedInterpolatorWidget.cpp
-Qmitk/QmitkSearchLabelDialog.cpp
Qmitk/QmitkSimpleLabelSetListWidget.cpp
)
set(MOC_H_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUI.h
Qmitk/QmitkAutoSegmentationToolGUIBase.h
Qmitk/QmitkAutoMLSegmentationToolGUIBase.h
Qmitk/QmitkBinaryThresholdToolGUIBase.h
Qmitk/QmitkBinaryThresholdToolGUI.h
Qmitk/QmitkBinaryThresholdULToolGUI.h
Qmitk/QmitkCalculateGrayValueStatisticsToolGUI.h
Qmitk/QmitkConfirmSegmentationDialog.h
Qmitk/QmitkCopyToClipBoardDialog.h
Qmitk/QmitkDrawPaintbrushToolGUI.h
Qmitk/QmitkErasePaintbrushToolGUI.h
Qmitk/QmitkFastMarchingToolGUIBase.h
Qmitk/QmitkFastMarchingTool3DGUI.h
Qmitk/QmitkFastMarchingToolGUI.h
Qmitk/QmitkLiveWireTool2DGUI.h
Qmitk/QmitkNewSegmentationDialog.h
Qmitk/QmitkOtsuTool3DGUI.h
Qmitk/QmitkPaintbrushToolGUI.h
Qmitk/QmitkPickingToolGUI.h
Qmitk/QmitkPixelManipulationToolGUI.h
Qmitk/QmitkSlicesInterpolator.h
Qmitk/QmitkToolGUI.h
Qmitk/QmitkToolGUIArea.h
Qmitk/QmitkToolSelectionBox.h
Qmitk/QmitkWatershedToolGUI.h
Qmitk/QmitknnUNetToolGUI.h
Qmitk/QmitknnUNetGPU.h
Qmitk/QmitknnUNetEnsembleLayout.h
Qmitk/QmitknnUNetFolderParser.h
#Added from ML
Qmitk/QmitkLabelSetWidget.h
Qmitk/QmitkSurfaceStampWidget.h
Qmitk/QmitkMaskStampWidget.h
Qmitk/QmitkSliceBasedInterpolatorWidget.h
Qmitk/QmitkSurfaceBasedInterpolatorWidget.h
-Qmitk/QmitkSearchLabelDialog.h
Qmitk/QmitkSimpleLabelSetListWidget.h
)
set(UI_FILES
Qmitk/QmitkAdaptiveRegionGrowingToolGUIControls.ui
Qmitk/QmitkConfirmSegmentationDialog.ui
Qmitk/QmitkOtsuToolWidgetControls.ui
Qmitk/QmitkLiveWireTool2DGUIControls.ui
Qmitk/QmitkWatershedToolGUIControls.ui
#Added from ML
Qmitk/QmitkLabelSetWidgetControls.ui
Qmitk/QmitkSurfaceStampWidgetGUIControls.ui
Qmitk/QmitkMaskStampWidgetGUIControls.ui
Qmitk/QmitkSliceBasedInterpolatorWidgetGUIControls.ui
Qmitk/QmitkSurfaceBasedInterpolatorWidgetGUIControls.ui
-Qmitk/QmitkSearchLabelDialogGUI.ui
Qmitk/QmitknnUNetToolGUIControls.ui
)
set(QRC_FILES
resources/SegmentationUI.qrc
)
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 05ffb06d01..ba0e40eef3 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,983 +1,987 @@
/*============================================================================
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 <mitkCameraController.h>
#include <mitkImageTimeSelector.h>
#include <mitkLabelSetImage.h>
#include <mitkLabelSetImageHelper.h>
#include <mitkNodePredicateSubGeometry.h>
#include <mitkSegmentationObjectFactory.h>
#include <mitkSegTool2D.h>
#include <mitkStatusBar.h>
#include <mitkToolManagerProvider.h>
#include <mitkVtkResliceInterpolationProperty.h>
#include <mitkWorkbenchUtil.h>
// Qmitk
#include <QmitkRenderWindow.h>
#include <QmitkSegmentationOrganNamesHandling.cpp>
// us
#include <usModuleResource.h>
#include <usModuleResourceStream.h>
// Qt
#include <QMessageBox>
#include <QShortcut>
#include <regex>
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)
{
auto isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
auto isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
auto isDti = mitk::NodePredicateDataType::New("TensorImage");
auto isOdf = mitk::NodePredicateDataType::New("OdfImage");
auto isSegment = mitk::NodePredicateDataType::New("Segment");
auto validImages = mitk::NodePredicateOr::New();
validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
validImages->AddPredicate(isDwi);
validImages->AddPredicate(isDti);
validImages->AddPredicate(isOdf);
auto isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
auto isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
auto validSegmentations = mitk::NodePredicateOr::New();
validSegmentations->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
validSegmentations->AddPredicate(isMask);
m_SegmentationPredicate = mitk::NodePredicateAnd::New();
m_SegmentationPredicate->AddPredicate(validSegmentations);
m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
m_ReferencePredicate = mitk::NodePredicateAnd::New();
m_ReferencePredicate->AddPredicate(validImages);
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
}
QmitkSegmentationView::~QmitkSegmentationView()
{
if (nullptr != m_Controls)
{
OnLooseLabelSetConnection();
// deactivate all tools
m_ToolManager->ActivateTool(-1);
// removing all observers
for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
{
(*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
}
m_WorkingDataObserverTags.clear();
mitk::RenderingManager::GetInstance()->RemoveObserver(m_RenderingManagerObserverTag);
ctkPluginContext* context = mitk::PluginActivator::getContext();
ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
service->RemoveAllPlanePositions();
context->ungetService(ppmRef);
m_ToolManager->SetReferenceData(nullptr);
m_ToolManager->SetWorkingData(nullptr);
}
delete m_Controls;
}
/**********************************************************************/
/* private Q_SLOTS */
/**********************************************************************/
void QmitkSegmentationView::OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
{
m_ToolManager->ActivateTool(-1);
if (nodes.empty())
{
m_Controls->workingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
m_ReferenceNode = nullptr;
m_ToolManager->SetReferenceData(m_ReferenceNode);
this->UpdateGUI();
return;
}
m_ReferenceNode = nodes.first();
m_ToolManager->SetReferenceData(m_ReferenceNode);
if (m_ReferenceNode.IsNotNull())
{
// set a predicate such that a segmentation fits the selected reference image geometry
auto segPredicate = mitk::NodePredicateAnd::New(m_SegmentationPredicate.GetPointer(),
mitk::NodePredicateSubGeometry::New(m_ReferenceNode->GetData()->GetGeometry()));
m_Controls->workingNodeSelector->SetNodePredicate(segPredicate);
if (m_SelectionMode)
{
// hide all image nodes to later show only the automatically selected ones
mitk::DataStorage::SetOfObjects::ConstPointer imageNodes =
this->GetDataStorage()->GetSubset(m_ReferencePredicate);
for (mitk::DataStorage::SetOfObjects::const_iterator iter = imageNodes->begin(); iter != imageNodes->end(); ++iter)
{
(*iter)->SetVisibility(false);
}
}
m_ReferenceNode->SetVisibility(true);
}
this->UpdateGUI();
}
void QmitkSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
{
m_ToolManager->ActivateTool(-1);
// Remove observer if one was registered
auto finding = m_WorkingDataObserverTags.find(m_WorkingNode);
if (finding != m_WorkingDataObserverTags.end())
{
m_WorkingNode->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[m_WorkingNode]);
m_WorkingDataObserverTags.erase(m_WorkingNode);
}
if (nodes.empty())
{
m_WorkingNode = nullptr;
m_ToolManager->SetWorkingData(m_WorkingNode);
this->UpdateGUI();
return;
}
if (m_ReferenceNode.IsNull())
{
this->UpdateGUI();
return;
}
mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image*>(m_ReferenceNode->GetData());
if (referenceImage.IsNull())
{
this->UpdateGUI();
return;
}
m_WorkingNode = nodes.first();
m_ToolManager->SetWorkingData(m_WorkingNode);
if (m_WorkingNode.IsNotNull())
{
if (m_SelectionMode)
{
// hide all segmentation nodes to later show only the selected ones
mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes =
this->GetDataStorage()->GetSubset(m_SegmentationPredicate);
for (mitk::DataStorage::SetOfObjects::const_iterator iter = segmentationNodes->begin(); iter != segmentationNodes->end(); ++iter)
{
(*iter)->SetVisibility(false);
}
}
m_WorkingNode->SetVisibility(true);
this->OnEstablishLabelSetConnection();
m_Controls->labelSetWidget->ResetAllTableWidgetItems();
auto command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
command->SetCallbackFunction(this, &QmitkSegmentationView::ValidateSelectionInput);
m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(m_WorkingNode,
m_WorkingNode->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
this->InitializeRenderWindows(referenceImage->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, false);
}
this->UpdateGUI();
}
void 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;
}
const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
unsigned int imageTimeStep = 0;
if (referenceImage->GetTimeGeometry()->IsValidTimePoint(currentTimePoint))
{
imageTimeStep = referenceImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
}
auto segTemplateImage = referenceImage;
if (referenceImage->GetDimension() > 3)
{
auto result = QMessageBox::question(m_Parent,
tr("Create a static or dynamic segmentation?"),
tr("The selected image has multiple time steps.\n\nDo you want to create a static "
"segmentation that is identical for all time steps or do you want to create a "
"dynamic segmentation to segment individual time steps?"),
tr("Create static segmentation"), tr("Create dynamic segmentation"),
QString(), 0, 0);
if (result == 0)
{
auto selector = mitk::ImageTimeSelector::New();
selector->SetInput(referenceImage);
selector->SetTimeNr(0);
selector->Update();
const auto refTimeGeometry = referenceImage->GetTimeGeometry();
auto newTimeGeometry = mitk::ProportionalTimeGeometry::New();
newTimeGeometry->SetFirstTimePoint(refTimeGeometry->GetMinimumTimePoint());
newTimeGeometry->SetStepDuration(refTimeGeometry->GetMaximumTimePoint() - refTimeGeometry->GetMinimumTimePoint());
mitk::Image::Pointer newImage = selector->GetOutput();
newTimeGeometry->SetTimeStepGeometry(referenceImage->GetGeometry(imageTimeStep), 0);
newImage->SetTimeGeometry(newTimeGeometry);
segTemplateImage = newImage;
}
}
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;
}
mitk::Label::Pointer newLabel = mitk::LabelSetImageHelper::CreateNewLabel(newLabelSetImage);
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);
}
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::OnLayersChanged()
{
m_Controls->labelSetWidget->ResetAllTableWidgetItems();
}
void QmitkSegmentationView::OnLabelsChanged()
{
m_Controls->labelSetWidget->ResetAllTableWidgetItems();
}
void QmitkSegmentationView::OnShowLabelTable(bool value)
{
m_Controls->labelSetWidget->setVisible(value);
}
void QmitkSegmentationView::OnGoToLabel(const mitk::Point3D& pos)
{
if (m_RenderWindowPart)
{
m_RenderWindowPart->SetSelectedPosition(pos);
}
}
void QmitkSegmentationView::OnLabelSetWidgetReset()
{
this->UpdateInterpolatorWidget();
}
/**********************************************************************/
/* private */
/**********************************************************************/
void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
{
m_Parent = parent;
m_Controls = new Ui::QmitkSegmentationViewControls;
m_Controls->setupUi(parent);
// *------------------------
// * SHORTCUTS
// *------------------------
QShortcut* visibilityShortcut = new QShortcut(QKeySequence("CTRL+H"), parent);
connect(visibilityShortcut, &QShortcut::activated, this, &QmitkSegmentationView::OnVisibilityShortcutActivated);
QShortcut* labelToggleShortcut = new QShortcut(QKeySequence("CTRL+L"), 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 Fill Erase Paint Wipe 'Region Growing' 'Live Wire'");
QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Region Growing 3D' Picking");
#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);
m_Controls->toolSelectionBox2D->SetEnabledMode(
QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
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);
m_Controls->toolSelectionBox3D->SetEnabledMode(
QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
m_Controls->slicesInterpolator->SetDataStorage(this->GetDataStorage());
// create general signal / slot connections
connect(m_Controls->newSegmentationButton, &QToolButton::clicked, this, &QmitkSegmentationView::OnNewSegmentation);
connect(m_Controls->slicesInterpolator, &QmitkSlicesInterpolator::SignalShowMarkerNodes, this, &QmitkSegmentationView::OnShowMarkerNodes);
connect(m_Controls->layersWidget, &QmitkLayersWidget::LayersChanged, this, &QmitkSegmentationView::OnLayersChanged);
connect(m_Controls->labelsWidget, &QmitkLabelsWidget::LabelsChanged, this, &QmitkSegmentationView::OnLabelsChanged);
connect(m_Controls->labelsWidget, &QmitkLabelsWidget::ShowLabelTable, this, &QmitkSegmentationView::OnShowLabelTable);
// *------------------------
// * LABELSETWIDGET
// *------------------------
connect(m_Controls->labelSetWidget, &QmitkLabelSetWidget::goToLabel, this, &QmitkSegmentationView::OnGoToLabel);
connect(m_Controls->labelSetWidget, &QmitkLabelSetWidget::LabelSetWidgetReset, this, &QmitkSegmentationView::OnLabelSetWidgetReset);
m_Controls->labelSetWidget->SetDataStorage(this->GetDataStorage());
m_Controls->labelSetWidget->SetOrganColors(mitk::OrganNamesHandling::GetDefaultOrganColorString());
m_Controls->labelSetWidget->hide();
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::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
{
if (m_RenderWindowPart != renderWindowPart)
{
m_RenderWindowPart = renderWindowPart;
}
if (nullptr != m_Parent)
{
m_Parent->setEnabled(true);
}
if (nullptr == m_Controls)
{
return;
}
// tell the interpolation about tool manager, data storage and render window part
if (nullptr != m_RenderWindowPart)
{
QList<mitk::SliceNavigationController*> controllers;
controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
controllers.push_back(m_RenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
m_Controls->slicesInterpolator->Initialize(m_ToolManager, controllers);
}
}
void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
{
m_RenderWindowPart = nullptr;
if (nullptr != m_Parent)
{
m_Parent->setEnabled(false);
}
}
void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
{
if (nullptr != m_Controls)
{
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);
this->ApplyDisplayOptions();
}
void QmitkSegmentationView::NodeAdded(const mitk::DataNode* node)
{
if (m_SegmentationPredicate->CheckNode(node))
{
this->ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
}
}
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;
mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
}
void QmitkSegmentationView::OnEstablishLabelSetConnection()
{
if (m_WorkingNode.IsNull())
{
return;
}
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
if (nullptr == workingImage)
{
return;
}
workingImage->GetActiveLabelSet()->AddLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->RemoveLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ModifyLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ActiveLabelEvent += mitk::MessageDelegate1<QmitkLabelSetWidget,
mitk::Label::PixelType>(m_Controls->labelSetWidget, &QmitkLabelSetWidget::SelectLabelByPixelValue);
// Removed in T27851 to have a chance to react to AfterChangeLayerEvent. Did it brake something?
// workingImage->BeforeChangeLayerEvent += mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
// this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
workingImage->AfterChangeLayerEvent += mitk::MessageDelegate<QmitkSegmentationView>(
this, &QmitkSegmentationView::UpdateGUI);
}
void QmitkSegmentationView::OnLooseLabelSetConnection()
{
if (m_WorkingNode.IsNull())
{
return;
}
auto workingImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
if (nullptr == workingImage)
{
return;
}
// Reset LabelSetWidget Events
workingImage->GetActiveLabelSet()->AddLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->RemoveLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls->labelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ModifyLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
m_Controls->labelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
workingImage->GetActiveLabelSet()->ActiveLabelEvent -= mitk::MessageDelegate1<QmitkLabelSetWidget,
mitk::Label::PixelType>(m_Controls->labelSetWidget, &QmitkLabelSetWidget::SelectLabelByPixelValue);
// Removed in T27851 to have a chance to react to AfterChangeLayerEvent. Did it brake something?
// workingImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
// this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
workingImage->AfterChangeLayerEvent -= mitk::MessageDelegate<QmitkSegmentationView>(
this, &QmitkSegmentationView::UpdateGUI);
}
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)
{
// node is a multi label segmentation
// its 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
node->GetData()->Modified();
}
else if (nullptr != node->GetData())
{
// node is a legacy binary segmentation
bool isBinary = false;
node->GetBoolProperty("binary", isBinary);
if (isBinary)
{
node->SetProperty("outline binary", mitk::BoolProperty::New(m_DrawOutline));
node->SetProperty("outline width", mitk::FloatProperty::New(2.0));
// force render window update to show outline
node->GetData()->Modified();
}
}
}
void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode* node)
{
QmitkRenderWindow* selectedRenderWindow = nullptr;
auto* renderWindowPart = this->GetRenderWindowPart(mitk::WorkbenchUtil::OPEN);
auto* axialRenderWindow = renderWindowPart->GetQmitkRenderWindow("axial");
auto* sagittalRenderWindow = renderWindowPart->GetQmitkRenderWindow("sagittal");
auto* coronalRenderWindow = renderWindowPart->GetQmitkRenderWindow("coronal");
auto* 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->UpdateInterpolatorWidget();
m_Controls->layersWidget->UpdateGUI();
m_Controls->labelsWidget->UpdateGUI();
this->ValidateSelectionInput();
}
void QmitkSegmentationView::UpdateInterpolatorWidget()
{
m_Controls->slicesInterpolator->setEnabled(false);
if (m_WorkingNode.IsNull())
{
return;
}
auto labelSetImage = dynamic_cast<mitk::LabelSetImage*>(m_WorkingNode->GetData());
if (nullptr == labelSetImage)
{
return;
}
int numberOfLabels = labelSetImage->GetNumberOfLabels(labelSetImage->GetActiveLayer());
if (2 == numberOfLabels) // fix for T27319: exterior is label 0, first label is label 1
{
m_Controls->interpolatorWarningLabel->hide();
m_Controls->slicesInterpolator->setEnabled(true);
}
else
{
m_Controls->interpolatorWarningLabel->show();
m_Controls->interpolatorWarningLabel->setText("<font color=\"red\">Interpolation only works for single label segmentations.</font>");
}
}
void QmitkSegmentationView::ValidateSelectionInput()
{
this->UpdateWarningLabel("");
+ m_Controls->layersWidget->setEnabled(false);
+ m_Controls->labelsWidget->setEnabled(false);
m_Controls->labelSetWidget->setEnabled(false);
// the argument is actually not used
// enable status depends on the tool manager selection
m_Controls->toolSelectionBox2D->setEnabled(false);
m_Controls->toolSelectionBox3D->setEnabled(false);
mitk::DataNode* referenceNode = m_Controls->referenceNodeSelector->GetSelectedNode();
mitk::DataNode* workingNode = m_Controls->workingNodeSelector->GetSelectedNode();
if (nullptr == referenceNode)
{
return;
}
if (nullptr == workingNode)
{
return;
}
mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
auto workingNodeIsVisible = renderWindowPart &&
workingNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer());
if (!workingNodeIsVisible)
{
this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
return;
}
/*
* Here we check whether the geometry of the selected segmentation image is aligned with the worldgeometry.
* At the moment it is not supported to use a geometry different from the selected image for reslicing.
* For further information see Bug 16063
*/
const mitk::BaseGeometry* workingNodeGeo = workingNode->GetData()->GetGeometry();
const mitk::BaseGeometry* worldGeo =
renderWindowPart->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
if (nullptr != workingNodeGeo && nullptr != worldGeo)
{
if (mitk::Equal(*workingNodeGeo->GetBoundingBox(), *worldGeo->GetBoundingBox(), mitk::eps, true))
{
m_ToolManager->SetReferenceData(referenceNode);
m_ToolManager->SetWorkingData(workingNode);
+ m_Controls->layersWidget->setEnabled(true);
+ m_Controls->labelsWidget->setEnabled(true);
m_Controls->labelSetWidget->setEnabled(true);
m_Controls->toolSelectionBox2D->setEnabled(true);
m_Controls->toolSelectionBox3D->setEnabled(true);
return;
}
}
m_ToolManager->SetReferenceData(referenceNode);
m_ToolManager->SetWorkingData(nullptr);
this->UpdateWarningLabel(tr("Please perform a reinit on the segmentation image!"));
}
void QmitkSegmentationView::UpdateWarningLabel(QString text)
{
if (text.size() == 0)
{
m_Controls->selectionWarningLabel->hide();
}
else
{
m_Controls->selectionWarningLabel->show();
m_Controls->selectionWarningLabel->setText("<font color=\"red\">" + text + "</font>");
}
}