diff --git a/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss b/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
index 3f436c08cc..f2b1f818d3 100644
--- a/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
+++ b/Plugins/org.blueberry.ui.qt/resources/darkstyle.qss
@@ -1,610 +1,614 @@
/*============================================================================
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.
============================================================================*/
/*
iconColor = #c7c7c7 <- This line is parsed by MITK
iconAccentColor = #d4821e <- This line is parsed by MITK
*/
font.warning {
color: #ff5c33;
font-weight: bold;
}
font.normal {
color: #f1f1f1;
}
font.highlight {
color: #d4821e;
}
+font.disabled {
+ color: #656565;
+}
+
QWidget {
background-color: #2d2d30;
border: none;
color: #f1f1f1;
}
QWidget:disabled {
background-color: #2d2d30;
border-color: #434346;
color: #656565;
}
QStackedWidget {
background-color: transparent;
}
QAbstractButton:hover, QComboBox:hover, QLineEdit:hover, QAbstractSpinBox:hover {
background-color: #3f3f46;
}
QAbstractButton:pressed, QAbstractButton:checked {
background-color: #434346;
}
QPushButton {
border: 1px solid #3f3f46;
padding: 4px 8px;
}
QPushButton:pressed {
border: 1px solid #434346;
}
QPushButton:checked, QToolButton:checked {
border: 1px solid #007acc;
}
QToolButton {
padding: 2px;
}
QToolBar QToolButton {
padding: 4px;
}
QToolButton#qt_toolbar_ext_button {
background-color: transparent;
border: none;
min-width: 12px;
max-width: 12px;
padding: 0;
qproperty-icon: url(:/org.blueberry.ui.qt/dark/tight-right-arrow-textcolor.svg);
}
QToolBox::tab {
border: 1px solid #3f3f46;
}
QToolBox::tab:hover {
background-color: #434346;
}
QToolBox::tab:selected {
background-color: #1c97ea;
border: 1px solid #1c97ea;
}
QAbstractItemView {
alternate-background-color: #1b1b1c;
background-color: #252526;
}
QAbstractItemView::item {
color: #f1f1f1;
}
QAbstractItemView::item:selected {
background-color: #1c97ea;
}
QHeaderView::section {
background-color: #2d2d30;
border: 1px solid transparent;
}
QHeaderView::section:horizontal {
border-right: 1px solid #3f3f46;
}
QHeaderView::section:vertical {
border-bottom: 1px solid #3f3f46;
}
QHeaderView::section:vertical:checked {
background-color: #1c97ea;
}
QHeaderView::section:vertical:pressed {
background-color: #1c97ea;
font-weight: bold;
}
QHeaderView::down-arrow {
image: url(:/org.blueberry.ui.qt/dark/down-arrow.svg);
height: 16px;
width: 16px;
}
QHeaderView::down-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/down-arrow-hover.svg);
}
QHeaderView::down-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/down-arrow-pressed.svg);
}
QHeaderView::up-arrow {
image: url(:/org.blueberry.ui.qt/dark/up-arrow.svg);
height: 16px;
width: 16px;
}
QHeaderView::up-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/up-arrow-hover.svg);
}
QHeaderView::up-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/up-arrow-pressed.svg);
}
QGroupBox {
border: 1px solid #434346;
margin-top: 8px;
padding-top: 8px;
}
QGroupBox, QGroupBox:disabled {
background-color: #252526;
}
QGroupBox::title {
padding: 0 4px;
subcontrol-origin: margin;
subcontrol-position: top center;
}
QComboBox, QLineEdit, QAbstractSpinBox {
background-color: #333337;
border: 1px solid #434346;
}
QComboBox QAbstractItemView {
border: 1px solid #333337;
selection-background-color: #3f3f46;
}
QComboBox::drop-down {
image: url(:/org.blueberry.ui.qt/dark/down-arrow.svg);
subcontrol-origin: margin;
subcontrol-position: right;
width: 12px;
}
QComboBox::drop-down:hover {
background-color: #1f1f20;
border-left: 1px solid #007acc;
image: url(:/org.blueberry.ui.qt/dark/down-arrow-pressed.svg);
}
QAbstractSpinBox::up-button, QAbstractSpinBox::down-button {
background-color: transparent;
border: none;
height: 9px;
}
QAbstractSpinBox::up-button:hover, QAbstractSpinBox::down-button:hover {
background-color: #1f1f20;
}
QAbstractSpinBox::up-arrow {
image: url(:/org.blueberry.ui.qt/dark/tight-up-arrow.svg);
}
QAbstractSpinBox::up-arrow:disabled, QAbstractSpinBox::up-arrow:off {
image: url(:/org.blueberry.ui.qt/dark/tight-up-arrow-disabled.svg);
}
QAbstractSpinBox::up-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/tight-up-arrow-hover.svg);
}
QAbstractSpinBox::up-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/tight-up-arrow-pressed.svg);
}
QAbstractSpinBox::down-arrow {
image: url(:/org.blueberry.ui.qt/dark/tight-down-arrow.svg);
}
QAbstractSpinBox::down-arrow:disabled, QAbstractSpinBox::down-arrow:off {
image: url(:/org.blueberry.ui.qt/dark/tight-down-arrow-disabled.svg);
}
QAbstractSpinBox::down-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/tight-down-arrow-hover.svg);
}
QAbstractSpinBox::down-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/tight-down-arrow-pressed.svg);
}
QCheckBox, QCheckBox:hover, QCheckBox:disabled, QCheckBox:checked, QRadioButton, QRadioButton:hover, QRadioButton:disabled, QRadioButton:checked {
background-color: none;
}
QCheckBox::indicator, QRadioButton::indicator {
height: 13px;
width: 13px;
}
QCheckBox::indicator:unchecked {
image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked.svg);
}
QCheckBox::indicator:unchecked:hover {
image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked-hover.svg);
}
QCheckBox::indicator:unchecked:disabled {
image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked-disabled.svg);
}
QCheckBox::indicator:checked {
image: url(:/org.blueberry.ui.qt/dark/checkbox-checked.svg);
}
QCheckBox::indicator:checked:hover {
image: url(:/org.blueberry.ui.qt/dark/checkbox-checked-hover.svg);
}
QCheckBox::indicator:checked:disabled {
image: url(:/org.blueberry.ui.qt/dark/checkbox-checked-disabled.svg);
}
QRadioButton::indicator:unchecked {
image: url(:/org.blueberry.ui.qt/dark/radiobutton-unchecked.svg);
}
QRadioButton::indicator:unchecked:hover {
image: url(:/org.blueberry.ui.qt/dark/radiobutton-unchecked-hover.svg);
}
QRadioButton::indicator:unchecked:disabled {
image: url(:/org.blueberry.ui.qt/dark/radiobutton-unchecked-disabled.svg);
}
QRadioButton::indicator:checked {
image: url(:/org.blueberry.ui.qt/dark/radiobutton-checked.svg);
}
QRadioButton::indicator:checked:hover {
image: url(:/org.blueberry.ui.qt/dark/radiobutton-checked-hover.svg);
}
QRadioButton::indicator:checked:disabled {
image: url(:/org.blueberry.ui.qt/dark/radiobutton-checked-disabled.svg);
}
QSlider::groove {
background-color: #686868;
}
QSlider::groove:hover {
background-color: #9e9e9e;
}
QSlider::groove:horizontal {
height: 3px;
}
QSlider::groove:vertical {
width: 3px;
}
QSlider::handle {
background-color: #686868;
}
QSlider::handle:hover {
background-color: #1c97ea;
}
QSlider::handle:pressed {
background-color: #007acc;
}
QSlider::handle:horizontal {
margin: -8px 0;
width: 8px;
}
QSlider::handle::vertical {
margin: 0 -8px;
height: 8px;
}
QLineEdit:hover {
border: 1px solid #2b7de1;
}
QLabel, QLabel:disabled {
background-color: none;
}
QMenu {
border: 1px solid #3e3e40;
}
QMenu QWidget {
background-color: #1b1b1c;
}
QMenu::item {
background-color: #1b1b1c;
}
QMenu::item:selected {
background-color: #333334;
}
QMenu::separator {
height: 1px;
background-color: #3e3e40;
}
QMenuBar::item:selected {
background-color: #3e3e40;
}
QScrollBar {
background-color: #3e3e42;
}
QScrollBar:horizontal {
height: 18px;
margin: 0 18px 0 18px;
}
QScrollBar:vertical {
width: 18px;
margin: 18px 0 18px 0;
}
QScrollBar::handle {
background-color: #686868;
}
QScrollBar::handle:hover {
background-color: #9e9e9e;
}
QScrollBar::handle:pressed {
background-color: #efebef;
}
QScrollBar::handle:horizontal {
min-width: 18px;
margin: 4px 0 5px 0;
}
QScrollBar::handle:vertical {
min-height: 18px;
margin: 0 5px 0 4px;
}
QScrollBar::add-page, QScrollBar::sub-page {
background-color: none;
}
QScrollBar::add-line, QScrollBar::sub-line {
background-color: #3e3e42;
subcontrol-origin: margin;
}
QScrollBar::add-line:horizontal {
subcontrol-position: right;
width: 18px;
}
QScrollBar::sub-line:horizontal {
subcontrol-position: left;
width: 18px;
}
QScrollBar::add-line:vertical {
subcontrol-position: bottom;
height: 18px;
}
QScrollBar::sub-line:vertical {
subcontrol-position: top;
height: 18px;
}
QScrollBar::up-arrow, QScrollBar::right-arrow, QScrollBar:down-arrow, QScrollBar:left-arrow {
width: 18px;
height: 18px;
}
QScrollBar::down-arrow {
image: url(:/org.blueberry.ui.qt/dark/down-arrow.svg);
}
QScrollBar::down-arrow:disabled {
image: url(:/org.blueberry.ui.qt/dark/down-arrow-disabled.svg);
}
QScrollBar::down-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/down-arrow-hover.svg);
}
QScrollBar::down-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/down-arrow-pressed.svg);
}
QScrollBar::left-arrow {
image: url(:/org.blueberry.ui.qt/dark/left-arrow.svg);
}
QScrollBar::left-arrow:disabled {
image: url(:/org.blueberry.ui.qt/dark/left-arrow-disabled.svg);
}
QScrollBar::left-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/left-arrow-hover.svg);
}
QScrollBar::left-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/left-arrow-pressed.svg);
}
QScrollBar::right-arrow {
image: url(:/org.blueberry.ui.qt/dark/right-arrow.svg);
}
QScrollBar::right-arrow:disabled {
image: url(:/org.blueberry.ui.qt/dark/right-arrow-disabled.svg);
}
QScrollBar::right-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/right-arrow-hover.svg);
}
QScrollBar::right-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/right-arrow-pressed.svg);
}
QScrollBar::up-arrow {
image: url(:/org.blueberry.ui.qt/dark/up-arrow.svg);
}
QScrollBar::up-arrow:disabled {
image: url(:/org.blueberry.ui.qt/dark/up-arrow-disabled.svg);
}
QScrollBar::up-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/up-arrow-hover.svg);
}
QScrollBar::up-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/up-arrow-pressed.svg);
}
QTabWidget::pane {
border: 1px solid #434346;
}
QTabBar::tab {
background-color: #434346;
border: 1px solid #434346;
border-bottom: none;
padding: 4px;
}
QTabBar::tab:middle {
border-left: none;
}
QTabBar::tab:last {
border-left: none;
}
QTabBar::tab:next-selected {
border-right: none;
}
QTabBar::tab:selected {
border: 1px solid #434346;
border-bottom: none;
}
QTabBar::tab:!selected {
background-color: #2d2d30;
}
QTabBar::tab:!selected:hover {
background-color: #434346;
}
#TabCloseButton {
background-color: none;
}
QTabBar QToolButton::left-arrow {
image: url(:/org.blueberry.ui.qt/dark/tight-left-arrow.svg);
}
QTabBar QToolButton::left-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/tight-left-arrow-hover.svg);
}
QTabBar QToolButton::left-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/tight-left-arrow-pressed.svg);
}
QTabBar QToolButton::left-arrow:disabled {
image: url(:/org.blueberry.ui.qt/dark/tight-left-arrow-disabled.svg);
}
QTabBar QToolButton::right-arrow {
image: url(:/org.blueberry.ui.qt/dark/tight-right-arrow.svg);
}
QTabBar QToolButton::right-arrow:hover {
image: url(:/org.blueberry.ui.qt/dark/tight-right-arrow-hover.svg);
}
QTabBar QToolButton::right-arrow:pressed {
image: url(:/org.blueberry.ui.qt/dark/tight-right-arrow-pressed.svg);
}
QTabBar QToolButton::right-arrow:disabled {
image: url(:/org.blueberry.ui.qt/dark/tight-right-arrow-disabled.svg);
}
QTreeView::branch:closed:has-children:has-siblings,
QTreeView::branch:closed:has-children:!has-siblings {
image: url(:/org.blueberry.ui.qt/dark/right-arrow.svg);
}
QTreeView::branch:closed:has-children:has-siblings:hover,
QTreeView::branch:closed:has-children:!has-siblings:hover {
image: url(:/org.blueberry.ui.qt/dark/right-arrow-hover.svg);
}
QTreeView::branch:open:has-children:has-siblings,
QTreeView::branch:open:has-children:!has-siblings {
image: url(:/org.blueberry.ui.qt/dark/down-arrow.svg);
}
QTreeView::branch:open:has-children:has-siblings:hover,
QTreeView::branch:open:has-children:!has-siblings:hover {
image: url(:/org.blueberry.ui.qt/dark/down-arrow-hover.svg);
}
QTreeView::indicator:unchecked {
image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked.svg);
}
QTreeView::indicator:unchecked:selected {
image: url(:/org.blueberry.ui.qt/dark/checkbox-unchecked-selected.svg);
}
QTreeView::indicator:checked, QTreeView::indicator:indeterminate {
image: url(:/org.blueberry.ui.qt/dark/checkbox-checked.svg);
}
QTreeView::indicator:checked:selected, QTreeView::indicator:indeterminate:selected {
image: url(:/org.blueberry.ui.qt/dark/checkbox-checked-selected.svg);
}
diff --git a/Plugins/org.blueberry.ui.qt/resources/lightstyle.qss b/Plugins/org.blueberry.ui.qt/resources/lightstyle.qss
index 3b42dbabf6..a188570487 100644
--- a/Plugins/org.blueberry.ui.qt/resources/lightstyle.qss
+++ b/Plugins/org.blueberry.ui.qt/resources/lightstyle.qss
@@ -1,89 +1,93 @@
/*
iconColor = #000000 <- This line is parsed by MITK
iconAccentColor = #2067bd <- This line is parsed by MITK
*/
font.warning {
color: red;
font-weight: bold;
}
font.normal {
color: #000000;
}
font.highlight {
color: #2067bd;
}
+font.disabled {
+ color: #808080;
+}
+
berry--QCTabBar::tab {
background: palette(window);
min-height: 24px;
border-top: 1px solid palette(mid);
border-left: 1px solid palette(mid);
border-bottom: 1px solid palette(mid);
margin-top: -1px;
padding-left: 5px
}
berry--QCTabBar::tab:only-one {
border-top-left-radius: 8px;
border-top-right-radius: 8px;
min-height: 25px;
margin-left: -1px
}
berry--QCTabBar::tab:first {
margin-left: -1px;
border-left: 0px;
border-top-left-radius: 8px;
}
berry--QCTabBar::tab:last {
border-right: 1px solid palette(mid);
border-top-right-radius: 8px
}
berry--QCTabBar::tab:previous-selected {
border-left: 0px
}
berry--QCTabBar::tab:selected {
border-right: 1px solid palette(Mid);
border-bottom: 0px;
border-top-left-radius: 8px;
border-top-right-radius: 8px;
}
berry--QCTabBar QToolButton {
border: 1px solid palette(window);
max-height: 22px;
background: palette(window);
}
berry--QCTabBar QToolButton#TabCloseButton
{
border: none;
background: none;
}
QWidget#TabTopRightControls {
border: 1px solid palette(mid);
border-left: 0px;
border-top: 0px;
border-right: 0px;
}
QWidget#ViewForm {
border: 1px solid palette(mid);
border-top-left-radius: 8px;
border-top-right-radius: 8px;
}
QWidget#StandaloneViewForm {
border: 1px solid palette(mid);
}
QWidget#PageCompositeControlWidget {
margin: 3px;
}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
index dd748cdc15..87daa45a43 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractNodeSelectionWidget.cpp
@@ -1,161 +1,161 @@
/*============================================================================
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 "QmitkAbstractNodeSelectionWidget.h"
-QmitkAbstractNodeSelectionWidget::QmitkAbstractNodeSelectionWidget(QWidget* parent) : QWidget(parent), m_InvalidInfo("<font class=\"warning\">Error. Select data.</font>"),
-m_EmptyInfo("<font class=\"normal\">Empty. Make a selection.</font>"), m_PopUpTitel("Select a data node"), m_PopUpHint(""),
+QmitkAbstractNodeSelectionWidget::QmitkAbstractNodeSelectionWidget(QWidget* parent) : QWidget(parent), m_InvalidInfo("Error. Select data."),
+m_EmptyInfo("Empty. Make a selection."), m_PopUpTitel("Select a data node"), m_PopUpHint(""),
m_IsOptional(false), m_SelectOnlyVisibleNodes(true)
{
}
QmitkAbstractNodeSelectionWidget::~QmitkAbstractNodeSelectionWidget()
{
if (!m_DataStorage.IsExpired())
{
auto dataStorage = m_DataStorage.Lock();
// remove Listener for the data storage itself
dataStorage->RemoveObserver(m_DataStorageDeletedTag);
// remove listener from data storage
dataStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
}
}
void QmitkAbstractNodeSelectionWidget::SetDataStorage(mitk::DataStorage* dataStorage)
{
if (m_DataStorage == dataStorage)
{
return;
}
if (!m_DataStorage.IsExpired())
{
auto oldStorage = m_DataStorage.Lock();
// remove Listener for the data storage itself
oldStorage->RemoveObserver(m_DataStorageDeletedTag);
// remove listener from old data storage
oldStorage->RemoveNodeEvent.RemoveListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
}
m_DataStorage = dataStorage;
if (!m_DataStorage.IsExpired())
{
auto newStorage = m_DataStorage.Lock();
// add Listener for the data storage itself
auto command = itk::SimpleMemberCommand<QmitkAbstractNodeSelectionWidget>::New();
command->SetCallbackFunction(this, &QmitkAbstractNodeSelectionWidget::SetDataStorageDeleted);
m_DataStorageDeletedTag = newStorage->AddObserver(itk::DeleteEvent(), command);
// add listener for new data storage
newStorage->RemoveNodeEvent.AddListener(
mitk::MessageDelegate1<QmitkAbstractNodeSelectionWidget, const mitk::DataNode*>(this, &QmitkAbstractNodeSelectionWidget::NodeRemovedFromStorage));
}
// update model if the data storage has been changed
m_DataStorage = dataStorage;
this->OnDataStorageChanged();
this->UpdateInfo();
}
void QmitkAbstractNodeSelectionWidget::SetNodePredicate(const mitk::NodePredicateBase* nodePredicate)
{
if (m_NodePredicate != nodePredicate)
{
m_NodePredicate = nodePredicate;
this->OnNodePredicateChanged(nodePredicate);
this->UpdateInfo();
}
}
const mitk::NodePredicateBase* QmitkAbstractNodeSelectionWidget::GetNodePredicate() const
{
return m_NodePredicate;
}
QString QmitkAbstractNodeSelectionWidget::GetInvalidInfo() const
{
return m_InvalidInfo;
}
QString QmitkAbstractNodeSelectionWidget::GetEmptyInfo() const
{
return m_EmptyInfo;
}
QString QmitkAbstractNodeSelectionWidget::GetPopUpTitel() const
{
return m_PopUpTitel;
}
QString QmitkAbstractNodeSelectionWidget::GetPopUpHint() const
{
return m_PopUpHint;
}
bool QmitkAbstractNodeSelectionWidget::GetSelectionIsOptional() const
{
return m_IsOptional;
}
bool QmitkAbstractNodeSelectionWidget::GetSelectOnlyVisibleNodes() const
{
return m_SelectOnlyVisibleNodes;
}
void QmitkAbstractNodeSelectionWidget::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
{
m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
}
void QmitkAbstractNodeSelectionWidget::SetInvalidInfo(QString info)
{
- m_InvalidInfo = QString("<font class=\"warning\">")+info+QString("</font>");
+ m_InvalidInfo = info;
this->UpdateInfo();
}
void QmitkAbstractNodeSelectionWidget::SetEmptyInfo(QString info)
{
- m_EmptyInfo = QString("<font class=\"normal\">")+info+QString("</font>");
+ m_EmptyInfo = info;
this->UpdateInfo();
}
void QmitkAbstractNodeSelectionWidget::SetPopUpTitel(QString info)
{
m_PopUpTitel = info;
}
void QmitkAbstractNodeSelectionWidget::SetPopUpHint(QString info)
{
m_PopUpHint = info;
}
void QmitkAbstractNodeSelectionWidget::SetSelectionIsOptional(bool isOptional)
{
m_IsOptional = isOptional;
this->UpdateInfo();
}
void QmitkAbstractNodeSelectionWidget::SetDataStorageDeleted()
{
this->SetDataStorage(nullptr);
}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
index 4a5f731d08..5700679abe 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
@@ -1,250 +1,273 @@
/*============================================================================
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 "QmitkMultiNodeSelectionWidget.h"
#include <algorithm>
#include "QmitkNodeSelectionDialog.h"
#include "QmitkCustomVariants.h"
#include "internal/QmitkNodeSelectionListItemWidget.h"
QmitkMultiNodeSelectionWidget::QmitkMultiNodeSelectionWidget(QWidget* parent) : QmitkAbstractNodeSelectionWidget(parent)
{
m_Controls.setupUi(this);
m_Overlay = new QmitkSimpleTextOverlayWidget(m_Controls.list);
m_Overlay->setVisible(false);
m_CheckFunction = [](const NodeList &) { return ""; };
this->UpdateList();
this->UpdateInfo();
connect(m_Controls.btnChange, SIGNAL(clicked(bool)), this, SLOT(OnEditSelection()));
}
QmitkMultiNodeSelectionWidget::NodeList QmitkMultiNodeSelectionWidget::CompileEmitSelection() const
{
NodeList result;
for (int i = 0; i < m_Controls.list->count(); ++i)
{
QListWidgetItem* item = m_Controls.list->item(i);
auto node = item->data(Qt::UserRole).value<mitk::DataNode::Pointer>();
result.append(node);
}
if (!m_SelectOnlyVisibleNodes)
{
for (auto node : m_CurrentSelection)
{
if (!result.contains(node))
{
result.append(node);
}
}
}
return result;
}
void QmitkMultiNodeSelectionWidget::OnNodePredicateChanged(const mitk::NodePredicateBase* /*newPredicate*/)
{
this->UpdateInfo();
this->UpdateList();
};
void QmitkMultiNodeSelectionWidget::OnDataStorageChanged()
{
this->UpdateInfo();
this->UpdateList();
};
QmitkMultiNodeSelectionWidget::NodeList QmitkMultiNodeSelectionWidget::GetSelectedNodes() const
{
return m_CurrentSelection;
};
void QmitkMultiNodeSelectionWidget::SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction)
{
m_CheckFunction = checkFunction;
auto newEmission = this->CompileEmitSelection();
auto newCheckResponse = m_CheckFunction(newEmission);
if (newCheckResponse.empty() && !m_CheckResponse.empty())
{
emit CurrentSelectionChanged(newEmission);
}
m_CheckResponse = newCheckResponse;
this->UpdateInfo();
};
void QmitkMultiNodeSelectionWidget::OnEditSelection()
{
QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(this, m_PopUpTitel, m_PopUpHint);
dialog->SetDataStorage(m_DataStorage.Lock());
dialog->SetNodePredicate(m_NodePredicate);
dialog->SetCurrentSelection(this->CompileEmitSelection());
dialog->SetSelectOnlyVisibleNodes(m_SelectOnlyVisibleNodes);
dialog->SetSelectionMode(QAbstractItemView::MultiSelection);
m_Controls.btnChange->setChecked(true);
if (dialog->exec())
{
auto lastEmission = this->CompileEmitSelection();
m_CurrentSelection = dialog->GetSelectedNodes();
this->UpdateList();
auto newEmission = this->CompileEmitSelection();
m_CheckResponse = m_CheckFunction(newEmission);
this->UpdateInfo();
if (!EqualNodeSelections(lastEmission, newEmission))
{
if (m_CheckResponse.empty())
{
emit CurrentSelectionChanged(newEmission);
}
}
}
m_Controls.btnChange->setChecked(false);
delete dialog;
};
void QmitkMultiNodeSelectionWidget::UpdateInfo()
{
if (!m_Controls.list->count())
{
if (m_IsOptional)
{
- m_Overlay->SetOverlayText(m_EmptyInfo);
+ if (this->isEnabled())
+ {
+ m_Overlay->SetOverlayText(QStringLiteral("<font class=\"normal\">") + m_EmptyInfo + QStringLiteral("</font>"));
+ }
+ else
+ {
+ m_Overlay->SetOverlayText(QStringLiteral("<font class=\"disabled\">") + m_EmptyInfo + QStringLiteral("</font>"));
+ }
}
else
{
- m_Overlay->SetOverlayText(m_InvalidInfo);
+ if (this->isEnabled())
+ {
+ m_Overlay->SetOverlayText(QStringLiteral("<font class=\"warning\">") + m_InvalidInfo + QStringLiteral("</font>"));
+ }
+ else
+ {
+ m_Overlay->SetOverlayText(QStringLiteral("<font class=\"disabled\">") + m_InvalidInfo + QStringLiteral("</font>"));
+ }
}
}
else
{
if (!m_CheckResponse.empty())
{
m_Overlay->SetOverlayText(QString::fromStdString(m_CheckResponse));
}
}
m_Overlay->setVisible(m_Controls.list->count() == 0 || !m_CheckResponse.empty());
for (auto i = 0; i < m_Controls.list->count(); ++i)
{
auto item = m_Controls.list->item(i);
auto widget = qobject_cast<QmitkNodeSelectionListItemWidget*>(m_Controls.list->itemWidget(item));
widget->SetClearAllowed(m_IsOptional || m_CurrentSelection.size() > 1);
}
};
void QmitkMultiNodeSelectionWidget::UpdateList()
{
m_Controls.list->clear();
for (auto node : m_CurrentSelection)
{
if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
{
QListWidgetItem *newItem = new QListWidgetItem;
newItem->setSizeHint(QSize(0, 40));
QmitkNodeSelectionListItemWidget* widget = new QmitkNodeSelectionListItemWidget;
widget->SetSelectedNode(node);
widget->SetClearAllowed(m_IsOptional || m_CurrentSelection.size() > 1);
connect(widget, &QmitkNodeSelectionListItemWidget::ClearSelection, this, &QmitkMultiNodeSelectionWidget::OnClearSelection);
newItem->setData(Qt::UserRole, QVariant::fromValue<mitk::DataNode::Pointer>(node));
m_Controls.list->addItem(newItem);
m_Controls.list->setItemWidget(newItem, widget);
}
}
};
void QmitkMultiNodeSelectionWidget::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
{
auto lastEmission = this->CompileEmitSelection();
m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
auto newEmission = this->CompileEmitSelection();
if (!EqualNodeSelections(lastEmission, newEmission))
{
m_CheckResponse = m_CheckFunction(newEmission);
if (m_CheckResponse.empty())
{
emit CurrentSelectionChanged(newEmission);
}
this->UpdateList();
this->UpdateInfo();
}
};
void QmitkMultiNodeSelectionWidget::SetCurrentSelection(NodeList selectedNodes)
{
auto lastEmission = this->CompileEmitSelection();
m_CurrentSelection = selectedNodes;
this->UpdateList();
auto newEmission = this->CompileEmitSelection();
if (!EqualNodeSelections(lastEmission, newEmission))
{
m_CheckResponse = m_CheckFunction(newEmission);
if (m_CheckResponse.empty())
{
emit CurrentSelectionChanged(newEmission);
}
this->UpdateInfo();
}
};
void QmitkMultiNodeSelectionWidget::OnClearSelection(const mitk::DataNode* node)
{
auto finding = std::find(std::begin(m_CurrentSelection), std::end(m_CurrentSelection), node);
m_CurrentSelection.erase(finding);
this->UpdateList();
auto newEmission = this->CompileEmitSelection();
m_CheckResponse = m_CheckFunction(newEmission);
if (m_CheckResponse.empty())
{
emit CurrentSelectionChanged(newEmission);
}
this->UpdateInfo();
};
void QmitkMultiNodeSelectionWidget::NodeRemovedFromStorage(const mitk::DataNode* node)
{
auto finding = std::find(std::begin(m_CurrentSelection), std::end(m_CurrentSelection), node);
if (finding != std::end(m_CurrentSelection))
{
this->OnClearSelection(node);
}
}
+
+void QmitkMultiNodeSelectionWidget::changeEvent(QEvent *event)
+{
+ if (event->type() == QEvent::EnabledChange)
+ {
+ this->UpdateInfo();
+ }
+ QmitkAbstractNodeSelectionWidget::changeEvent(event);
+}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.h b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.h
index bf759eb2c7..f4e411234a 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.h
@@ -1,85 +1,87 @@
/*============================================================================
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 QMITK_MULTI_NODE_SELECTION_WIDGET_H
#define QMITK_MULTI_NODE_SELECTION_WIDGET_H
#include <mitkDataStorage.h>
#include <mitkWeakPointer.h>
#include <mitkNodePredicateBase.h>
#include "QmitkSimpleTextOverlayWidget.h"
#include "org_mitk_gui_qt_common_Export.h"
#include "ui_QmitkMultiNodeSelectionWidget.h"
#include <QmitkAbstractNodeSelectionWidget.h>
class QmitkAbstractDataStorageModel;
class QAbstractItemVew;
/**
* \class QmitkMultiNodeSelectionWidget
* \brief Widget that allows to perform and represents a multiple node selection.
*/
class MITK_QT_COMMON QmitkMultiNodeSelectionWidget : public QmitkAbstractNodeSelectionWidget
{
Q_OBJECT
public:
explicit QmitkMultiNodeSelectionWidget(QWidget* parent = nullptr);
using NodeList = QmitkAbstractNodeSelectionWidget::NodeList;
NodeList GetSelectedNodes() const;
/**Helper function that is used to check the given selection for consistency.
Returning an empty string assumes that everything is alright and the selection
is valid. If the string is not empty, the content of the string will be used
as error message in the overlay to indicate the problem.*/
using SelectionCheckFunctionType = std::function<std::string(const NodeList &)>;
/**A selection check function can be set. If set the widget uses this function to
check the made/set selection. If the selection is valid, everything is fine.
If selection is indicated as invalid, it will not be communicated by the widget
(no signal emission.*/
void SetSelectionCheckFunction(const SelectionCheckFunctionType &checkFunction);
public Q_SLOTS:
void SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes) override;
void SetCurrentSelection(NodeList selectedNodes) override;
void OnEditSelection();
protected Q_SLOTS:
void OnClearSelection(const mitk::DataNode* node);
protected:
NodeList CompileEmitSelection() const;
+ void changeEvent(QEvent *event) override;
+
void UpdateInfo() override;
virtual void UpdateList();
void OnNodePredicateChanged(const mitk::NodePredicateBase* newPredicate) override;
void OnDataStorageChanged() override;
void NodeRemovedFromStorage(const mitk::DataNode* node) override;
NodeList m_CurrentSelection;
QmitkSimpleTextOverlayWidget* m_Overlay;
SelectionCheckFunctionType m_CheckFunction;
std::string m_CheckResponse;
Ui_QmitkMultiNodeSelectionWidget m_Controls;
};
#endif // QmitkMultiNodeSelectionWidget_H
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
index 9c9c9d88e9..9f927b0d47 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.cpp
@@ -1,177 +1,218 @@
/*============================================================================
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 "QmitkNodeSelectionButton.h"
// berry includes
#include <berryWorkbenchPlugin.h>
#include <berryQtStyleManager.h>
#include "QPainter"
#include "QTextDocument"
+#include "QEvent"
#include <mitkDataNode.h>
#include <QmitkNodeDescriptorManager.h>
// mitk core
#include <mitkBaseRenderer.h>
#include <mitkDataNode.h>
#include <mitkExtractSliceFilter.h>
#include <vtkMitkLevelWindowFilter.h>
#include <mitkPlanarFigure.h>
#include <mitkPropertyNameHelper.h>
// vtk
#include <vtkLookupTable.h>
QPixmap GetPixmapFromImageNode(const mitk::DataNode* dataNode, int height)
{
if (nullptr == dataNode)
{
return QPixmap();
}
const mitk::Image* image = dynamic_cast<const mitk::Image*>(dataNode->GetData());
if ((nullptr == image || !image->IsInitialized()) || // -> must be an image
(image->GetPixelType().GetNumberOfComponents() != 1)) // -> for now only single component are allowed
{
auto descManager = QmitkNodeDescriptorManager::GetInstance();
auto desc = descManager->GetDescriptor(dataNode);
auto icon = desc->GetIcon(dataNode);
auto fallBackMap = icon.pixmap(height, height);
return fallBackMap;
}
mitk::PlaneGeometry::Pointer planeGeometry = mitk::PlaneGeometry::New();
int sliceNumber = image->GetDimension(2) / 2;
planeGeometry->InitializeStandardPlane(image->GetGeometry(), mitk::PlaneGeometry::Axial, sliceNumber);
mitk::ExtractSliceFilter::Pointer extractSliceFilter = mitk::ExtractSliceFilter::New();
extractSliceFilter->SetInput(image);
extractSliceFilter->SetInterpolationMode(mitk::ExtractSliceFilter::RESLICE_CUBIC);
extractSliceFilter->SetResliceTransformByGeometry(image->GetGeometry());
extractSliceFilter->SetWorldGeometry(planeGeometry);
extractSliceFilter->SetOutputDimensionality(2);
extractSliceFilter->SetVtkOutputRequest(true);
extractSliceFilter->Update();
vtkImageData* imageData = extractSliceFilter->GetVtkOutput();
mitk::LevelWindow levelWindow;
dataNode->GetLevelWindow(levelWindow);
vtkSmartPointer<vtkLookupTable> lookupTable = vtkSmartPointer<vtkLookupTable>::New();
lookupTable->SetRange(levelWindow.GetLowerWindowBound(), levelWindow.GetUpperWindowBound());
lookupTable->SetSaturationRange(0.0, 0.0);
lookupTable->SetValueRange(0.0, 1.0);
lookupTable->SetHueRange(0.0, 0.0);
lookupTable->SetRampToLinear();
vtkSmartPointer<vtkMitkLevelWindowFilter> levelWindowFilter = vtkSmartPointer<vtkMitkLevelWindowFilter>::New();
levelWindowFilter->SetLookupTable(lookupTable);
levelWindowFilter->SetInputData(imageData);
levelWindowFilter->SetMinOpacity(0.0);
levelWindowFilter->SetMaxOpacity(1.0);
int dims[3];
imageData->GetDimensions(dims);
double clippingBounds[] = { 0.0, static_cast<double>(dims[0]), 0.0, static_cast<double>(dims[1]) };
levelWindowFilter->SetClippingBounds(clippingBounds);
levelWindowFilter->Update();
imageData = levelWindowFilter->GetOutput();
QImage thumbnailImage(reinterpret_cast<const unsigned char*>(imageData->GetScalarPointer()), dims[0], dims[1], QImage::Format_ARGB32);
thumbnailImage = thumbnailImage.scaledToHeight(height,Qt::SmoothTransformation).rgbSwapped();
return QPixmap::fromImage(thumbnailImage);
}
QmitkNodeSelectionButton::QmitkNodeSelectionButton(QWidget *parent)
- : QPushButton(parent), m_OutDatedThumpNail(true)
+ : QPushButton(parent), m_OutDatedThumpNail(true), m_IsOptional(true)
{ }
QmitkNodeSelectionButton::~QmitkNodeSelectionButton()
{
this->m_SelectedNode = nullptr;
}
const mitk::DataNode* QmitkNodeSelectionButton::GetSelectedNode() const
{
return m_SelectedNode;
}
void QmitkNodeSelectionButton::SetSelectedNode(const mitk::DataNode* node)
{
if (m_SelectedNode != node)
{
this->m_SelectedNode = node;
this->m_OutDatedThumpNail = true;
}
this->update();
}
void QmitkNodeSelectionButton::SetNodeInfo(QString info)
{
this->m_Info = info;
this->update();
}
void QmitkNodeSelectionButton::paintEvent(QPaintEvent *p)
{
QString stylesheet;
ctkPluginContext* context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
if (styleManagerRef)
{
auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
stylesheet = styleManager->GetStylesheet();
}
QPushButton::paintEvent(p);
QPainter painter(this);
QTextDocument td(this);
td.setDefaultStyleSheet(stylesheet);
auto widgetSize = this->size();
QPoint origin = QPoint(5, 5);
if (this->m_SelectedNode)
{
auto iconLength = widgetSize.height() - 10;
auto node = this->m_SelectedNode;
if (this->m_OutDatedThumpNail)
{
this->m_ThumpNail = GetPixmapFromImageNode(node, iconLength);
this->m_OutDatedThumpNail = false;
}
painter.drawPixmap(origin, m_ThumpNail);
origin.setX(origin.x() + iconLength + 5);
- td.setHtml(QString::fromStdString("<font class=\"normal\">"+node->GetName()+"</font>"));
+ if (this->isEnabled())
+ {
+ td.setHtml(QString::fromStdString("<font class=\"normal\">" + node->GetName() + "</font>"));
+ }
+ else
+ {
+ td.setHtml(QString::fromStdString("<font class=\"disabled\">" + node->GetName() + "</font>"));
+ }
}
else
{
- td.setHtml(m_Info);
+ if (this->isEnabled())
+ {
+ if (this->m_IsOptional)
+ {
+ td.setHtml(QString("<font class=\"normal\">") + m_Info + QString("</font>"));
+ }
+ else
+ {
+ td.setHtml(QString("<font class=\"warning\">") + m_Info + QString("</font>"));
+ }
+ }
+ else
+ {
+ td.setHtml(QString("<font class=\"disabled\">") + m_Info + QString("</font>"));
+ }
}
auto textSize = td.size();
origin.setY( (widgetSize.height() - textSize.height()) / 2.);
painter.translate(origin);
td.drawContents(&painter);
}
+
+void QmitkNodeSelectionButton::changeEvent(QEvent *event)
+{
+ if (event->type() == QEvent::EnabledChange)
+ {
+ this->repaint();
+ }
+}
+
+bool QmitkNodeSelectionButton::GetSelectionIsOptional() const
+{
+ return m_IsOptional;
+}
+
+void QmitkNodeSelectionButton::SetSelectionIsOptional(bool isOptional)
+{
+ m_IsOptional = isOptional;
+ this->repaint();
+}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
index 376877677d..98974a6b0c 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkNodeSelectionButton.h
@@ -1,54 +1,63 @@
/*============================================================================
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 QMITK_NODE_SELECTION_BUTTON_H
#define QMITK_NODE_SELECTION_BUTTON_H
#include <mitkWeakPointer.h>
#include <mitkDataNode.h>
#include "org_mitk_gui_qt_common_Export.h"
#include "QPushButton"
#include "QPixmap"
/** Button class that can be used to display informations about a passed node.
* If the passed node is a null ptr the node info text will be shown.
* In difference to the normal push button text property. The node info can
* be formated text (e.g. HTML code; like the tooltip text).*/
class MITK_QT_COMMON QmitkNodeSelectionButton : public QPushButton
{
Q_OBJECT
public:
explicit QmitkNodeSelectionButton(QWidget *parent = nullptr);
~QmitkNodeSelectionButton() override;
const mitk::DataNode* GetSelectedNode() const;
+ bool GetSelectionIsOptional() const;
public Q_SLOTS :
virtual void SetSelectedNode(const mitk::DataNode* node);
virtual void SetNodeInfo(QString info);
+ /** Set the widget into an optional mode. Optional means that the selection of no valid
+ node does not mean an invalid state. Thus no node is a valid "node" selection too.
+ The state influences if the info text is handled as an information (optional) or a
+ warning (optiona==false).*/
+ void SetSelectionIsOptional(bool isOptional);
+
protected:
void paintEvent(QPaintEvent *p) override;
+ void changeEvent(QEvent *event) override;
mitk::DataNode::ConstPointer m_SelectedNode;
QString m_Info;
bool m_OutDatedThumpNail;
QPixmap m_ThumpNail;
+ bool m_IsOptional;
};
#endif // QmitkSingleNodeSelectionWidget_H
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
index eb02d1f901..2689d07b5f 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkSingleNodeSelectionWidget.cpp
@@ -1,257 +1,258 @@
/*============================================================================
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 "QmitkSingleNodeSelectionWidget.h"
#include <berryQtStyleManager.h>
#include <QMouseEvent>
#include "QmitkNodeSelectionDialog.h"
#include "QmitkNodeDetailsDialog.h"
QmitkSingleNodeSelectionWidget::QmitkSingleNodeSelectionWidget(QWidget* parent) : QmitkAbstractNodeSelectionWidget(parent)
{
m_Controls.setupUi(this);
m_Controls.btnSelect->installEventFilter(this);
m_Controls.btnSelect->setVisible(true);
m_Controls.btnClear->setVisible(false);
m_Controls.btnClear->setIcon(berry::QtStyleManager::ThemeIcon(QStringLiteral(":/org.mitk.gui.qt.common/times.svg")));
this->UpdateInfo();
connect(m_Controls.btnClear, SIGNAL(clicked(bool)), this, SLOT(OnClearSelection()));
}
QmitkSingleNodeSelectionWidget::~QmitkSingleNodeSelectionWidget()
{
}
mitk::DataNode::Pointer QmitkSingleNodeSelectionWidget::ExtractCurrentValidSelection(const NodeList& nodes) const
{
mitk::DataNode::Pointer result = nullptr;
for (auto node : nodes)
{
bool valid = true;
if (m_NodePredicate.IsNotNull())
{
valid = m_NodePredicate->CheckNode(node);
}
if (valid)
{
result = node;
break;
}
}
return result;
}
QmitkSingleNodeSelectionWidget::NodeList QmitkSingleNodeSelectionWidget::CompileEmitSelection() const
{
NodeList result;
if (!m_SelectOnlyVisibleNodes)
{
result = m_ExternalSelection;
}
if (m_SelectedNode.IsNotNull() && !result.contains(m_SelectedNode))
{
result.append(m_SelectedNode);
}
return result;
}
void QmitkSingleNodeSelectionWidget::OnNodePredicateChanged(const mitk::NodePredicateBase* /*newPredicate*/)
{
if (m_NodePredicate.IsNotNull() && m_SelectedNode.IsNotNull() && !m_NodePredicate->CheckNode(m_SelectedNode))
{
m_SelectedNode = nullptr;
}
if (m_SelectedNode.IsNull())
{
m_SelectedNode = this->ExtractCurrentValidSelection(m_ExternalSelection);
}
};
void QmitkSingleNodeSelectionWidget::OnDataStorageChanged()
{
};
void QmitkSingleNodeSelectionWidget::OnClearSelection()
{
if (m_IsOptional)
{
NodeList emptyList;
this->SetCurrentSelection(emptyList);
}
this->UpdateInfo();
}
mitk::DataNode::Pointer QmitkSingleNodeSelectionWidget::GetSelectedNode() const
{
return m_SelectedNode;
};
bool QmitkSingleNodeSelectionWidget::eventFilter(QObject *obj, QEvent *ev)
{
if (obj == m_Controls.btnSelect)
{
if (ev->type() == QEvent::MouseButtonRelease)
{
auto mouseEv = dynamic_cast<QMouseEvent*>(ev);
if (!mouseEv)
{
return false;
}
if (mouseEv->button() == Qt::LeftButton)
{
if (this->isEnabled())
{
this->EditSelection();
return true;
}
}
else
{
auto selection = this->CompileEmitSelection();
if (!selection.empty())
{
QmitkNodeDetailsDialog infoDialog(selection, this);
infoDialog.exec();
return true;
}
}
}
}
return false;
}
void QmitkSingleNodeSelectionWidget::EditSelection()
{
QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(this, m_PopUpTitel, m_PopUpHint);
dialog->SetDataStorage(m_DataStorage.Lock());
dialog->SetNodePredicate(m_NodePredicate);
NodeList list;
if (m_SelectedNode.IsNotNull())
{
list.append(m_SelectedNode);
}
dialog->SetCurrentSelection(list);
dialog->SetSelectOnlyVisibleNodes(m_SelectOnlyVisibleNodes);
dialog->SetSelectionMode(QAbstractItemView::SingleSelection);
m_Controls.btnSelect->setChecked(true);
if (dialog->exec())
{
auto lastEmission = this->CompileEmitSelection();
auto nodes = dialog->GetSelectedNodes();
if (nodes.empty())
{
m_SelectedNode = nullptr;
}
else
{
m_SelectedNode = nodes.first();
}
auto newEmission = this->CompileEmitSelection();
if (!EqualNodeSelections(lastEmission, newEmission))
{
emit CurrentSelectionChanged(newEmission);
this->UpdateInfo();
}
}
m_Controls.btnSelect->setChecked(false);
delete dialog;
};
void QmitkSingleNodeSelectionWidget::UpdateInfo()
{
if (m_SelectedNode.IsNull())
{
if (m_IsOptional)
{
m_Controls.btnSelect->SetNodeInfo(m_EmptyInfo);
}
else
{
m_Controls.btnSelect->SetNodeInfo(m_InvalidInfo);
}
+ m_Controls.btnSelect->SetSelectionIsOptional(m_IsOptional);
m_Controls.btnClear->setVisible(false);
}
else
{
m_Controls.btnClear->setVisible(m_IsOptional);
}
m_Controls.btnSelect->SetSelectedNode(m_SelectedNode);
};
void QmitkSingleNodeSelectionWidget::SetSelectOnlyVisibleNodes(bool selectOnlyVisibleNodes)
{
auto lastEmission = this->CompileEmitSelection();
m_SelectOnlyVisibleNodes = selectOnlyVisibleNodes;
auto newEmission = this->CompileEmitSelection();
if (!EqualNodeSelections(lastEmission, newEmission))
{
emit CurrentSelectionChanged(newEmission);
this->UpdateInfo();
}
};
void QmitkSingleNodeSelectionWidget::SetCurrentSelection(NodeList selectedNodes)
{
auto lastEmission = this->CompileEmitSelection();
m_ExternalSelection = selectedNodes;
m_SelectedNode = this->ExtractCurrentValidSelection(selectedNodes);
auto newEmission = this->CompileEmitSelection();
if (!EqualNodeSelections(lastEmission, newEmission))
{
this->UpdateInfo();
emit CurrentSelectionChanged(newEmission);
}
};
void QmitkSingleNodeSelectionWidget::NodeRemovedFromStorage(const mitk::DataNode* node)
{
if (m_SelectedNode == node && node != nullptr)
{
m_SelectedNode = nullptr;
auto newEmission = this->CompileEmitSelection();
emit CurrentSelectionChanged(newEmission);
this->UpdateInfo();
}
}
diff --git a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestControls.ui b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestControls.ui
index 77f8edc873..f6e396042d 100644
--- a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestControls.ui
+++ b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestControls.ui
@@ -1,173 +1,193 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QmitkDataStorageViewerTestControls</class>
<widget class="QWidget" name="QmitkDataStorageViewerTestControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>945</width>
<height>456</height>
</rect>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>0</height>
</size>
</property>
<property name="windowTitle">
<string>Data storage viewer test</string>
</property>
<layout class="QGridLayout" name="gridLayout">
- <item row="1" column="0">
- <widget class="QCheckBox" name="selectionProviderCheckBox">
- <property name="text">
- <string>Set as selection provider</string>
- </property>
- </widget>
- </item>
- <item row="0" column="1">
- <widget class="QListView" name="selectionListView2"/>
- </item>
- <item row="1" column="1">
- <widget class="QCheckBox" name="selectionProviderCheckBox2">
+ <item row="7" column="1">
+ <widget class="QCheckBox" name="checkOnlyImages_2">
<property name="text">
- <string>Set as selection provider</string>
+ <string>Allow only images
+(using NodePredicate feature and general invalid message)</string>
</property>
</widget>
</item>
- <item row="0" column="0">
- <widget class="QListView" name="selectionListView"/>
- </item>
- <item row="7" column="0">
- <widget class="QCheckBox" name="checkOnlyImages">
+ <item row="5" column="0">
+ <widget class="QCheckBox" name="selectionListenerCheckBox3">
<property name="text">
- <string>Allow only images </string>
+ <string>Set as selection listner</string>
</property>
</widget>
</item>
- <item row="9" column="0">
- <widget class="QCheckBox" name="checkOptional">
+ <item row="2" column="0">
+ <widget class="QCheckBox" name="selectionListenerCheckBox">
<property name="text">
- <string>Is Optional</string>
+ <string>Set as selection listener</string>
</property>
</widget>
</item>
- <item row="4" column="1">
- <widget class="QCheckBox" name="selectionProviderCheckBox4">
+ <item row="5" column="1">
+ <widget class="QCheckBox" name="selectionListenerCheckBox4">
<property name="text">
- <string>Set as selection provider</string>
+ <string>Set as selection listner</string>
</property>
</widget>
</item>
<item row="6" column="1">
<widget class="QCheckBox" name="checkOnlyVisible_2">
<property name="text">
<string>Only valid nodes</string>
</property>
</widget>
</item>
- <item row="7" column="1">
- <widget class="QCheckBox" name="checkOnlyImages_2">
+ <item row="4" column="0">
+ <widget class="QCheckBox" name="selectionProviderCheckBox3">
<property name="text">
- <string>Allow only images
-(using NodePredicate feature and general invalid message)</string>
+ <string>Set as selection provider</string>
</property>
</widget>
</item>
- <item row="2" column="0">
- <widget class="QCheckBox" name="selectionListenerCheckBox">
+ <item row="0" column="0">
+ <widget class="QListView" name="selectionListView"/>
+ </item>
+ <item row="9" column="1">
+ <widget class="QCheckBox" name="checkOptional_2">
<property name="text">
- <string>Set as selection listener</string>
+ <string>Is Optional</string>
</property>
</widget>
</item>
+ <item row="0" column="1">
+ <widget class="QListView" name="selectionListView2"/>
+ </item>
<item row="2" column="1">
<widget class="QCheckBox" name="selectionListenerCheckBox2">
<property name="text">
<string>Set as selection listener</string>
</property>
</widget>
</item>
- <item row="6" column="0">
- <widget class="QCheckBox" name="checkOnlyVisible">
+ <item row="1" column="0">
+ <widget class="QCheckBox" name="selectionProviderCheckBox">
<property name="text">
- <string>Only valid nodes</string>
+ <string>Set as selection provider</string>
</property>
</widget>
</item>
- <item row="5" column="0">
- <widget class="QCheckBox" name="selectionListenerCheckBox3">
+ <item row="6" column="0">
+ <widget class="QCheckBox" name="checkOnlyVisible">
<property name="text">
- <string>Set as selection listner</string>
+ <string>Only valid nodes</string>
</property>
</widget>
</item>
- <item row="5" column="1">
- <widget class="QCheckBox" name="selectionListenerCheckBox4">
+ <item row="9" column="0">
+ <widget class="QCheckBox" name="checkOptional">
<property name="text">
- <string>Set as selection listner</string>
+ <string>Is Optional</string>
</property>
</widget>
</item>
- <item row="4" column="0">
- <widget class="QCheckBox" name="selectionProviderCheckBox3">
+ <item row="4" column="1">
+ <widget class="QCheckBox" name="selectionProviderCheckBox4">
<property name="text">
<string>Set as selection provider</string>
</property>
</widget>
</item>
- <item row="9" column="1">
- <widget class="QCheckBox" name="checkOptional_2">
+ <item row="7" column="0">
+ <widget class="QCheckBox" name="checkOnlyImages">
<property name="text">
- <string>Is Optional</string>
+ <string>Allow only images </string>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QmitkSingleNodeSelectionWidget" name="singleSlot" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>0</width>
<height>40</height>
</size>
</property>
</widget>
</item>
<item row="3" column="1">
<widget class="QmitkMultiNodeSelectionWidget" name="multiSlot" native="true"/>
</item>
<item row="8" column="1">
<widget class="QCheckBox" name="checkOnlyUneven">
<property name="text">
<string>Allow only uneven selection count
(using check funcktion feature)</string>
</property>
</widget>
</item>
+ <item row="1" column="1">
+ <widget class="QCheckBox" name="selectionProviderCheckBox2">
+ <property name="text">
+ <string>Set as selection provider</string>
+ </property>
+ </widget>
+ </item>
+ <item row="10" column="0">
+ <widget class="QCheckBox" name="checkEnabled">
+ <property name="text">
+ <string>Is Enabled</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
+ <item row="10" column="1">
+ <widget class="QCheckBox" name="checkEnabled_2">
+ <property name="text">
+ <string>Is Enabled</string>
+ </property>
+ <property name="checked">
+ <bool>true</bool>
+ </property>
+ </widget>
+ </item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>QmitkSingleNodeSelectionWidget</class>
<extends>QWidget</extends>
<header location="global">QmitkSingleNodeSelectionWidget.h</header>
<container>1</container>
</customwidget>
<customwidget>
<class>QmitkMultiNodeSelectionWidget</class>
<extends>QWidget</extends>
<header location="global">QmitkMultiNodeSelectionWidget.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
index 16c0783ef5..1501292067 100644
--- a/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
+++ b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
@@ -1,274 +1,276 @@
/*============================================================================
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.
============================================================================*/
// data storage viewer test plugin
#include "QmitkDataStorageViewerTestView.h"
#include "mitkNodePredicateDataType.h"
// berry
#include <berryIWorkbenchWindow.h>
// qt
#include <QHBoxLayout>
const std::string QmitkDataStorageViewerTestView::VIEW_ID = "org.mitk.views.datastorageviewertest";
void QmitkDataStorageViewerTestView::SetFocus()
{
// nothing here
}
void QmitkDataStorageViewerTestView::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets
m_Controls.setupUi(parent);
m_DataStorageDefaultListModel = new QmitkDataStorageDefaultListModel(this);
m_DataStorageDefaultListModel->SetDataStorage(GetDataStorage());
m_Controls.selectionListView->setSelectionMode(QAbstractItemView::ExtendedSelection);
m_Controls.selectionListView->setSelectionBehavior(QAbstractItemView::SelectRows);
m_Controls.selectionListView->setAlternatingRowColors(true);
m_Controls.selectionListView->setModel(m_DataStorageDefaultListModel);
m_DataStorageDefaultListModel2 = new QmitkDataStorageDefaultListModel(this);
m_DataStorageDefaultListModel2->SetDataStorage(GetDataStorage());
m_Controls.selectionListView2->setSelectionMode(QAbstractItemView::ExtendedSelection);
m_Controls.selectionListView2->setSelectionBehavior(QAbstractItemView::SelectRows);
m_Controls.selectionListView2->setAlternatingRowColors(true);
m_Controls.selectionListView2->setModel(m_DataStorageDefaultListModel2);
m_Controls.singleSlot->SetDataStorage(GetDataStorage());
- m_Controls.singleSlot->SetEmptyInfo(QString("EmptyInfo: Set this to display info in empty state"));
- m_Controls.singleSlot->SetInvalidInfo(QString("InvalidInfo: is displayed for invalid states"));
- m_Controls.singleSlot->SetPopUpTitel(QString("This is the definable caption. Choose your data now!"));
- m_Controls.singleSlot->SetPopUpHint(QString("I am an optional hint, that can be set by the developer<p/>If not set the widget is invisible."));
+ m_Controls.singleSlot->SetEmptyInfo(QStringLiteral("EmptyInfo: Set this to display info in empty state"));
+ m_Controls.singleSlot->SetInvalidInfo(QStringLiteral("InvalidInfo: is displayed for invalid states"));
+ m_Controls.singleSlot->SetPopUpTitel(QStringLiteral("This is the definable caption. Choose your data now!"));
+ m_Controls.singleSlot->SetPopUpHint(QStringLiteral("I am an optional hint, that can be set by the developer<p/>If not set the widget is invisible."));
m_Controls.multiSlot->SetDataStorage(GetDataStorage());
- m_Controls.multiSlot->SetEmptyInfo(QString("EmptyInfo: Set this to display info in empty state"));
- m_Controls.multiSlot->SetInvalidInfo(QString("InvalidInfo: is displayed for invalid states"));
- m_Controls.multiSlot->SetPopUpTitel(QString("This is the definable caption. Choose your data now!"));
- m_Controls.multiSlot->SetPopUpHint(QString("I am an optional hint, that can be set by the developer<p/>If not set the widget is invisible."));
+ m_Controls.multiSlot->SetEmptyInfo(QStringLiteral("EmptyInfo: Set this to display info in empty state"));
+ m_Controls.multiSlot->SetInvalidInfo(QStringLiteral("InvalidInfo: is displayed for invalid states"));
+ m_Controls.multiSlot->SetPopUpTitel(QStringLiteral("This is the definable caption. Choose your data now!"));
+ m_Controls.multiSlot->SetPopUpHint(QStringLiteral("I am an optional hint, that can be set by the developer<p/>If not set the widget is invisible."));
m_ModelViewSelectionConnector = std::make_unique<QmitkModelViewSelectionConnector>();
try
{
m_ModelViewSelectionConnector->SetView(m_Controls.selectionListView);
}
catch (mitk::Exception& e)
{
mitkReThrow(e) << "Cannot connect the model-view pair signals and slots.";
}
m_SelectionServiceConnector = std::make_unique<QmitkSelectionServiceConnector>();
m_ModelViewSelectionConnector2 = std::make_unique<QmitkModelViewSelectionConnector>();
try
{
m_ModelViewSelectionConnector2->SetView(m_Controls.selectionListView2);
}
catch (mitk::Exception& e)
{
mitkReThrow(e) << "Cannot connect the model-view pair signals and slots.";
}
m_SelectionServiceConnector2 = std::make_unique<QmitkSelectionServiceConnector>();
m_SelectionServiceConnector3 = std::make_unique<QmitkSelectionServiceConnector>();
m_SelectionServiceConnector4 = std::make_unique<QmitkSelectionServiceConnector>();
connect(m_Controls.selectionProviderCheckBox, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionProvider1(bool)));
connect(m_Controls.selectionProviderCheckBox2, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionProvider2(bool)));
connect(m_Controls.selectionListenerCheckBox, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionListener1(bool)));
connect(m_Controls.selectionListenerCheckBox2, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionListener2(bool)));
connect(m_Controls.selectionProviderCheckBox3, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionProvider3(bool)));
connect(m_Controls.selectionListenerCheckBox3, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionListener3(bool)));
connect(m_Controls.checkOnlyVisible, SIGNAL(toggled(bool)), m_Controls.singleSlot, SLOT(SetSelectOnlyVisibleNodes(bool)));
connect(m_Controls.checkOptional, SIGNAL(toggled(bool)), m_Controls.singleSlot, SLOT(SetSelectionIsOptional(bool)));
connect(m_Controls.checkOnlyImages, SIGNAL(toggled(bool)), this, SLOT(OnOnlyImages(bool)));
+ connect(m_Controls.checkEnabled, SIGNAL(toggled(bool)), m_Controls.singleSlot, SLOT(setEnabled(bool)));
connect(m_Controls.selectionProviderCheckBox4, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionProvider4(bool)));
connect(m_Controls.selectionListenerCheckBox4, SIGNAL(toggled(bool)), this, SLOT(SetAsSelectionListener4(bool)));
connect(m_Controls.checkOnlyVisible_2, SIGNAL(toggled(bool)), m_Controls.multiSlot, SLOT(SetSelectOnlyVisibleNodes(bool)));
connect(m_Controls.checkOptional_2, SIGNAL(toggled(bool)), m_Controls.multiSlot, SLOT(SetSelectionIsOptional(bool)));
connect(m_Controls.checkOnlyImages_2, SIGNAL(toggled(bool)), this, SLOT(OnOnlyImages2(bool)));
connect(m_Controls.checkOnlyUneven, SIGNAL(toggled(bool)), this, SLOT(OnOnlyUneven(bool)));
+ connect(m_Controls.checkEnabled_2, SIGNAL(toggled(bool)), m_Controls.multiSlot, SLOT(setEnabled(bool)));
}
void QmitkDataStorageViewerTestView::SetAsSelectionProvider1(bool checked)
{
if (checked)
{
m_SelectionServiceConnector->SetAsSelectionProvider(GetSite()->GetSelectionProvider().Cast<QmitkDataNodeSelectionProvider>().GetPointer());
connect(m_ModelViewSelectionConnector.get(), SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
}
else
{
m_SelectionServiceConnector->RemoveAsSelectionProvider();
disconnect(m_ModelViewSelectionConnector.get(), SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
}
}
void QmitkDataStorageViewerTestView::SetAsSelectionListener1(bool checked)
{
if (checked)
{
m_SelectionServiceConnector->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
connect(m_SelectionServiceConnector.get(), SIGNAL(ServiceSelectionChanged(QList<mitk::DataNode::Pointer>)), m_ModelViewSelectionConnector.get(), SLOT(SetCurrentSelection(QList<mitk::DataNode::Pointer>)));
}
else
{
m_SelectionServiceConnector->RemovePostSelectionListener();
disconnect(m_SelectionServiceConnector.get(), SIGNAL(ServiceSelectionChanged(QList<mitk::DataNode::Pointer>)), m_ModelViewSelectionConnector.get(), SLOT(SetCurrentSelection(QList<mitk::DataNode::Pointer>)));
}
}
void QmitkDataStorageViewerTestView::SetAsSelectionProvider2(bool checked)
{
if (checked)
{
m_SelectionServiceConnector2->SetAsSelectionProvider(GetSite()->GetSelectionProvider().Cast<QmitkDataNodeSelectionProvider>().GetPointer());
connect(m_ModelViewSelectionConnector2.get(), SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector2.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
}
else
{
m_SelectionServiceConnector2->RemoveAsSelectionProvider();
disconnect(m_ModelViewSelectionConnector2.get(), SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector2.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
}
}
void QmitkDataStorageViewerTestView::SetAsSelectionListener2(bool checked)
{
if (checked)
{
m_SelectionServiceConnector2->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
connect(m_SelectionServiceConnector2.get(), SIGNAL(ServiceSelectionChanged(QList<mitk::DataNode::Pointer>)), m_ModelViewSelectionConnector2.get(), SLOT(SetCurrentSelection(QList<mitk::DataNode::Pointer>)));
}
else
{
m_SelectionServiceConnector2->RemovePostSelectionListener();
disconnect(m_SelectionServiceConnector2.get(), SIGNAL(ServiceSelectionChanged(QList<mitk::DataNode::Pointer>)), m_ModelViewSelectionConnector2.get(), SLOT(SetCurrentSelection(QList<mitk::DataNode::Pointer>)));
}
}
void QmitkDataStorageViewerTestView::SetAsSelectionProvider3(bool checked)
{
if (checked)
{
m_SelectionServiceConnector3->SetAsSelectionProvider(GetSite()->GetSelectionProvider().Cast<QmitkDataNodeSelectionProvider>().GetPointer());
connect(m_Controls.singleSlot, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector3.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
}
else
{
m_SelectionServiceConnector3->RemoveAsSelectionProvider();
disconnect(m_Controls.singleSlot, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector3.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
}
}
void QmitkDataStorageViewerTestView::SetAsSelectionListener3(bool checked)
{
if (checked)
{
m_SelectionServiceConnector3->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
connect(m_SelectionServiceConnector3.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
}
else
{
m_SelectionServiceConnector3->RemovePostSelectionListener();
disconnect(m_SelectionServiceConnector3.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.singleSlot, &QmitkSingleNodeSelectionWidget::SetCurrentSelection);
}
}
void QmitkDataStorageViewerTestView::SetAsSelectionProvider4(bool checked)
{
if (checked)
{
m_SelectionServiceConnector4->SetAsSelectionProvider(GetSite()->GetSelectionProvider().Cast<QmitkDataNodeSelectionProvider>().GetPointer());
connect(m_Controls.multiSlot, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector4.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
}
else
{
m_SelectionServiceConnector4->RemoveAsSelectionProvider();
disconnect(m_Controls.multiSlot, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), m_SelectionServiceConnector4.get(), SLOT(ChangeServiceSelection(QList<mitk::DataNode::Pointer>)));
}
}
void QmitkDataStorageViewerTestView::SetAsSelectionListener4(bool checked)
{
if (checked)
{
m_SelectionServiceConnector4->AddPostSelectionListener(GetSite()->GetWorkbenchWindow()->GetSelectionService());
connect(m_SelectionServiceConnector4.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.multiSlot, &QmitkMultiNodeSelectionWidget::SetCurrentSelection);
}
else
{
m_SelectionServiceConnector4->RemovePostSelectionListener();
disconnect(m_SelectionServiceConnector4.get(), &QmitkSelectionServiceConnector::ServiceSelectionChanged, m_Controls.multiSlot, &QmitkMultiNodeSelectionWidget::SetCurrentSelection);
}
}
void QmitkDataStorageViewerTestView::OnOnlyImages(bool checked)
{
if (checked)
{
m_Controls.singleSlot->SetNodePredicate(mitk::NodePredicateDataType::New("Image"));
}
else
{
m_Controls.singleSlot->SetNodePredicate(nullptr);
}
};
void QmitkDataStorageViewerTestView::OnOnlyImages2(bool checked)
{
if (checked)
{
m_Controls.multiSlot->SetNodePredicate(mitk::NodePredicateDataType::New("Image"));
- m_Controls.multiSlot->SetInvalidInfo(QString("InvalidInfo: is displayed for invalid states. Only images allowed!"));
+ m_Controls.multiSlot->SetInvalidInfo(QStringLiteral("InvalidInfo: is displayed for invalid states. Only images allowed!"));
}
else
{
m_Controls.multiSlot->SetNodePredicate(nullptr);
- m_Controls.multiSlot->SetInvalidInfo(QString("InvalidInfo: is displayed for invalid states"));
+ m_Controls.multiSlot->SetInvalidInfo(QStringLiteral("InvalidInfo: is displayed for invalid states"));
}
};
void QmitkDataStorageViewerTestView::OnOnlyUneven(bool checked)
{
if (checked)
{
auto checkFunction = [](const QmitkMultiNodeSelectionWidget::NodeList & nodes)
{
if (!(nodes.size() % 2))
{
std::stringstream ss;
ss << "<font class=\"warning\"><p>Invalid selection.<p/><p>The number of selected nodes must be uneven! the current number is " << nodes.size() << ".</p>";
return ss.str();
}
return std::string();
};
m_Controls.multiSlot->SetSelectionCheckFunction(checkFunction);
}
else
{
auto checkFunction = [](const QmitkMultiNodeSelectionWidget::NodeList & /*nodes*/)
{
return std::string();
};
m_Controls.multiSlot->SetSelectionCheckFunction(checkFunction);
}
};
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/QmitkMatchPoint.cpp b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/QmitkMatchPoint.cpp
index 022b49d401..f8902e1204 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/QmitkMatchPoint.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.algorithm.control/src/internal/QmitkMatchPoint.cpp
@@ -1,873 +1,873 @@
/*============================================================================
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 "org_mitk_gui_qt_matchpoint_algorithmcontrol_Activator.h"
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
#include <berryISelectionProvider.h>
#include <berryQModelIndexObject.h>
// Mitk
#include <mitkStatusBar.h>
#include <mitkPointSet.h>
#include <mitkImageTimeSelector.h>
#include <mitkMAPAlgorithmInfoSelection.h>
#include <mitkRegistrationHelper.h>
#include <mitkAlgorithmHelper.h>
#include <mitkResultNodeGenerationHelper.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateDimension.h>
// Qmitk
#include "QmitkMatchPoint.h"
#include <QmitkRegistrationJob.h>
#include <QmitkMappingJob.h>
// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QErrorMessage>
#include <QThreadPool>
#include <QDateTime>
// MatchPoint
#include <mapImageRegistrationAlgorithmInterface.h>
#include <mapPointSetRegistrationAlgorithmInterface.h>
#include <mapRegistrationAlgorithmInterface.h>
#include <mapMaskedRegistrationAlgorithmInterface.h>
#include <mapAlgorithmEvents.h>
#include <mapAlgorithmWrapperEvent.h>
#include <mapExceptionObjectMacros.h>
#include <mapConvert.h>
#include <mapDeploymentDLLAccess.h>
const std::string QmitkMatchPoint::VIEW_ID = "org.mitk.views.matchpoint.algorithm.control";
QmitkMatchPoint::QmitkMatchPoint()
: m_Parent(nullptr), m_LoadedDLLHandle(nullptr), m_LoadedAlgorithm(nullptr)
{
m_CanLoadAlgorithm = false;
m_ValidInputs = false;
m_Working = false;
m_spSelectedTargetData = nullptr;
m_spSelectedMovingData = nullptr;
m_spSelectedTargetMaskData = nullptr;
m_spSelectedMovingMaskData = nullptr;
}
QmitkMatchPoint::~QmitkMatchPoint()
{
// remove selection service
berry::ISelectionService* s = this->GetSite()->GetWorkbenchWindow()->GetSelectionService();
if (s)
{
s->RemoveSelectionListener(m_AlgorithmSelectionListener.data());
}
}
void QmitkMatchPoint::SetFocus()
{
}
void QmitkMatchPoint::CreateConnections()
{
connect(m_Controls.targetNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.movingNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.targetMaskNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.movingMaskNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
// ------
// Tab 1 - Shared library loading interface
// ------
connect(m_Controls.m_pbLoadSelected, SIGNAL(clicked()), this, SLOT(OnLoadAlgorithmButtonPushed()));
// -----
// Tab 2 - Execution
// -----
connect(m_Controls.m_pbStartReg, SIGNAL(clicked()), this, SLOT(OnStartRegBtnPushed()));
connect(m_Controls.m_pbStopReg, SIGNAL(clicked()), this, SLOT(OnStopRegBtnPushed()));
connect(m_Controls.m_pbSaveLog, SIGNAL(clicked()), this, SLOT(OnSaveLogBtnPushed()));
}
const map::deployment::DLLInfo* QmitkMatchPoint::GetSelectedAlgorithmDLL() const
{
return m_SelectedAlgorithmInfo;
}
void QmitkMatchPoint::OnSelectedAlgorithmChanged()
{
std::stringstream descriptionString;
::map::deployment::DLLInfo::ConstPointer currentItemInfo = GetSelectedAlgorithmDLL();
if (!currentItemInfo)
{
- Error(QString("No valid algorithm is selected. ABORTING."));
+ Error(QStringLiteral("No valid algorithm is selected. ABORTING."));
return;
}
m_Controls.m_teAlgorithmDetails->updateInfo(currentItemInfo);
m_Controls.m_lbSelectedAlgorithm->setText(QString::fromStdString(
currentItemInfo->getAlgorithmUID().getName()));
// enable loading
m_CanLoadAlgorithm = true;
this->AdaptFolderGUIElements();
}
void QmitkMatchPoint::OnLoadAlgorithmButtonPushed()
{
map::deployment::DLLInfo::ConstPointer dllInfo = GetSelectedAlgorithmDLL();
if (!dllInfo)
{
- Error(QString("No valid algorithm is selected. Cannot load algorithm. ABORTING."));
+ Error(QStringLiteral("No valid algorithm is selected. Cannot load algorithm. ABORTING."));
return;
}
::map::deployment::DLLHandle::Pointer tempDLLHandle = ::map::deployment::openDeploymentDLL(
dllInfo->getLibraryFilePath());
::map::algorithm::RegistrationAlgorithmBase::Pointer tempAlgorithm
= ::map::deployment::getRegistrationAlgorithm(tempDLLHandle);
if (tempAlgorithm.IsNull())
{
- Error(QString("Error. Cannot load selected algorithm."));
+ Error(QStringLiteral("Error. Cannot load selected algorithm."));
return;
}
this->m_LoadedAlgorithm = tempAlgorithm;
this->m_LoadedDLLHandle = tempDLLHandle;
this->m_Controls.m_AlgoConfigurator->setAlgorithm(m_LoadedAlgorithm);
typedef ::map::algorithm::facet::MaskedRegistrationAlgorithmInterface<3, 3> MaskRegInterface;
const MaskRegInterface* pMaskReg = dynamic_cast<const MaskRegInterface*>
(m_LoadedAlgorithm.GetPointer());
if (!pMaskReg)
{
m_spSelectedTargetMaskData = nullptr;
m_spSelectedTargetMaskNode = nullptr;
m_spSelectedMovingMaskData = nullptr;
m_spSelectedMovingMaskNode = nullptr;
m_Controls.targetMaskNodeSelector->SetCurrentSelection(QmitkAbstractNodeSelectionWidget::NodeList());
m_Controls.movingMaskNodeSelector->SetCurrentSelection(QmitkAbstractNodeSelectionWidget::NodeList());
}
this->AdaptFolderGUIElements();
this->ConfigureNodeSelectors();
this->CheckInputs();
this->ConfigureRegistrationControls();
this->ConfigureProgressInfos();
this->m_Controls.m_tabs->setCurrentIndex(1);
this->m_Controls.m_teLog->clear();
}
void QmitkMatchPoint::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
- m_Controls.m_teLog->append(QString("<font color='red'><b>") + msg + QString("</b></font>"));
+ m_Controls.m_teLog->append(QStringLiteral("<font color='red'><b>") + msg + QStringLiteral("</b></font>"));
}
void QmitkMatchPoint::AdaptFolderGUIElements()
{
m_Controls.m_pbLoadSelected->setEnabled(m_CanLoadAlgorithm);
}
void QmitkMatchPoint::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Parent = parent;
m_Controls.m_tabs->setCurrentIndex(0);
m_Controls.movingNodeSelector->SetDataStorage(this->GetDataStorage());
m_Controls.movingNodeSelector->SetSelectionIsOptional(false);
m_Controls.targetNodeSelector->SetDataStorage(this->GetDataStorage());
m_Controls.targetNodeSelector->SetSelectionIsOptional(false);
m_Controls.movingMaskNodeSelector->SetDataStorage(this->GetDataStorage());
m_Controls.movingMaskNodeSelector->SetSelectionIsOptional(true);
m_Controls.targetMaskNodeSelector->SetDataStorage(this->GetDataStorage());
m_Controls.targetMaskNodeSelector->SetSelectionIsOptional(true);
m_AlgorithmSelectionListener.reset(new berry::SelectionChangedAdapter<QmitkMatchPoint>(this,
&QmitkMatchPoint::OnAlgorithmSelectionChanged));
// register selection listener
GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddSelectionListener(
m_AlgorithmSelectionListener.data());
this->CreateConnections();
this->AdaptFolderGUIElements();
this->CheckInputs();
this->ConfigureProgressInfos();
this->ConfigureRegistrationControls();
this->ConfigureNodeSelectors();
berry::ISelection::ConstPointer selection =
GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.matchpoint.algorithm.browser");
this->UpdateAlgorithmSelection(selection);
}
mitk::Image::Pointer ExtractFirstFrame(const mitk::Image* dynamicImage)
{
mitk::ImageTimeSelector::Pointer imageTimeSelector = mitk::ImageTimeSelector::New();
imageTimeSelector->SetInput(dynamicImage);
imageTimeSelector->SetTimeNr(0);
imageTimeSelector->UpdateLargestPossibleRegion();
return imageTimeSelector->GetOutput();
}
bool QmitkMatchPoint::CheckInputs()
{
if (m_LoadedAlgorithm.IsNull())
{
m_spSelectedMovingNode = nullptr;
m_spSelectedMovingData = nullptr;
m_spSelectedTargetNode = nullptr;
m_spSelectedTargetData = nullptr;
m_spSelectedMovingMaskNode = nullptr;
m_spSelectedMovingMaskData = nullptr;
m_spSelectedTargetMaskNode = nullptr;
m_spSelectedTargetMaskData = nullptr;
}
else
{
if (m_Controls.movingNodeSelector->GetSelectedNode().IsNull())
{
m_spSelectedMovingNode = nullptr;
m_spSelectedMovingData = nullptr;
}
else
{
m_spSelectedMovingNode = m_Controls.movingNodeSelector->GetSelectedNode();
m_spSelectedMovingData = m_spSelectedMovingNode->GetData();
auto movingImage = dynamic_cast<mitk::Image*>(m_spSelectedMovingNode->GetData());
if (movingImage && movingImage->GetDimension() - 1 == m_LoadedAlgorithm->getMovingDimensions()
&& movingImage->GetTimeSteps() > 1)
{
m_spSelectedMovingData = ExtractFirstFrame(movingImage).GetPointer();
m_Controls.m_teLog->append(
- QString("<font color='gray'><i>Selected moving image has multiple time steps. First time step is used as moving image.</i></font>"));
+ QStringLiteral("<font color='gray'><i>Selected moving image has multiple time steps. First time step is used as moving image.</i></font>"));
}
}
if (m_Controls.targetNodeSelector->GetSelectedNode().IsNull())
{
m_spSelectedTargetNode = nullptr;
m_spSelectedTargetData = nullptr;
}
else
{
m_spSelectedTargetNode = m_Controls.targetNodeSelector->GetSelectedNode();
m_spSelectedTargetData = m_spSelectedTargetNode->GetData();
auto targetImage = dynamic_cast<mitk::Image*>(m_spSelectedTargetNode->GetData());
if (targetImage && targetImage->GetDimension() - 1 == m_LoadedAlgorithm->getTargetDimensions()
&& targetImage->GetTimeSteps() > 1)
{
m_spSelectedTargetData = ExtractFirstFrame(targetImage).GetPointer();
m_Controls.m_teLog->append(
- QString("<font color='gray'><i>Selected target image has multiple time steps. First time step is used as target image.</i></font>"));
+ QStringLiteral("<font color='gray'><i>Selected target image has multiple time steps. First time step is used as target image.</i></font>"));
}
}
if (m_Controls.movingMaskNodeSelector->GetSelectedNode().IsNull())
{
m_spSelectedMovingMaskNode = nullptr;
m_spSelectedMovingMaskData = nullptr;
}
else
{
m_spSelectedMovingMaskNode = m_Controls.movingMaskNodeSelector->GetSelectedNode();
m_spSelectedMovingMaskData = nullptr;
auto movingMaskImage = dynamic_cast<mitk::Image*>(m_spSelectedMovingMaskNode->GetData());
if (movingMaskImage->GetDimension() - 1 == m_LoadedAlgorithm->getMovingDimensions()
&& movingMaskImage->GetTimeSteps() > 1)
{
m_spSelectedMovingMaskData = ExtractFirstFrame(movingMaskImage).GetPointer();
m_Controls.m_teLog->append(
- QString("<font color='gray'><i>Selected moving mask has multiple time steps. First time step is used as moving mask.</i></font>"));
+ QStringLiteral("<font color='gray'><i>Selected moving mask has multiple time steps. First time step is used as moving mask.</i></font>"));
}
}
if (m_Controls.targetMaskNodeSelector->GetSelectedNode().IsNull())
{
m_spSelectedTargetMaskNode = nullptr;
m_spSelectedTargetMaskData = nullptr;
}
else
{
m_spSelectedTargetMaskNode = m_Controls.targetMaskNodeSelector->GetSelectedNode();
m_spSelectedTargetMaskData = nullptr;
auto targetMaskImage = dynamic_cast<mitk::Image*>(m_spSelectedTargetMaskNode->GetData());
if (targetMaskImage->GetDimension() - 1 == m_LoadedAlgorithm->getTargetDimensions()
&& targetMaskImage->GetTimeSteps() > 1)
{
m_spSelectedTargetMaskData = ExtractFirstFrame(targetMaskImage).GetPointer();
m_Controls.m_teLog->append(
- QString("<font color='gray'><i>Selected target mask has multiple time steps. First time step is used as target mask.</i></font>"));
+ QStringLiteral("<font color='gray'><i>Selected target mask has multiple time steps. First time step is used as target mask.</i></font>"));
}
}
}
m_ValidInputs = m_spSelectedMovingData.IsNotNull() && m_spSelectedTargetData.IsNotNull();
return m_ValidInputs;
}
std::string QmitkMatchPoint::GetInputNodeDisplayName(const mitk::DataNode* node) const
{
std::string result = "UNDEFINED/nullptr";
if (node)
{
result = node->GetName();
const mitk::PointSet* pointSet = dynamic_cast<const mitk::PointSet*>(node->GetData());
if (pointSet)
{
mitk::DataStorage::SetOfObjects::ConstPointer sources = this->GetDataStorage()->GetSources(node);
if (sources.IsNotNull() && sources->Size() > 0)
{
result = result + " (" + sources->GetElement(0)->GetName() + ")";
}
}
}
return result;
}
mitk::DataStorage::SetOfObjects::Pointer QmitkMatchPoint::GetRegNodes() const
{
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetAll();
mitk::DataStorage::SetOfObjects::Pointer result = mitk::DataStorage::SetOfObjects::New();
for (mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end();
++pos)
{
if (mitk::MITKRegistrationHelper::IsRegNode(*pos))
{
result->push_back(*pos);
}
}
return result;
}
std::string QmitkMatchPoint::GetDefaultRegJobName() const
{
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetRegNodes().GetPointer();
mitk::DataStorage::SetOfObjects::ElementIdentifier estimatedIndex = nodes->Size();
bool isUnique = false;
std::string result = "Unnamed Reg";
while (!isUnique)
{
++estimatedIndex;
result = "Reg #" +::map::core::convert::toStr(estimatedIndex);
isUnique = this->GetDataStorage()->GetNamedNode(result) == nullptr;
}
return result;
}
void QmitkMatchPoint::ConfigureRegistrationControls()
{
m_Controls.m_tabSelection->setEnabled(!m_Working);
m_Controls.m_leRegJobName->setEnabled(!m_Working);
m_Controls.groupMasks->setEnabled(!m_Working);
m_Controls.m_pbStartReg->setEnabled(false);
m_Controls.m_pbStopReg->setEnabled(false);
m_Controls.m_pbStopReg->setVisible(false);
if (m_LoadedAlgorithm.IsNotNull())
{
m_Controls.m_tabSettings->setEnabled(!m_Working);
m_Controls.m_tabExecution->setEnabled(true);
m_Controls.m_pbStartReg->setEnabled(m_ValidInputs && !m_Working);
m_Controls.m_leRegJobName->setEnabled(!m_Working);
m_Controls.m_checkMapEntity->setEnabled(!m_Working);
m_Controls.targetNodeSelector->setEnabled(!m_Working);
m_Controls.movingNodeSelector->setEnabled(!m_Working);
m_Controls.targetMaskNodeSelector->setEnabled(!m_Working);
m_Controls.movingMaskNodeSelector->setEnabled(!m_Working);
const IStoppableAlgorithm* pIterativ = dynamic_cast<const IStoppableAlgorithm*>
(m_LoadedAlgorithm.GetPointer());
if (pIterativ)
{
m_Controls.m_pbStopReg->setVisible(pIterativ->isStoppable());
}
typedef ::map::algorithm::facet::MaskedRegistrationAlgorithmInterface<3, 3> MaskRegInterface;
const MaskRegInterface* pMaskReg = dynamic_cast<const MaskRegInterface*>
(m_LoadedAlgorithm.GetPointer());
m_Controls.groupMasks->setVisible(pMaskReg != nullptr);
//if the stop button is set to visible and the algorithm is working ->
//then the algorithm is stoppable, thus enable the button.
m_Controls.m_pbStopReg->setEnabled(m_Controls.m_pbStopReg->isVisible() && m_Working);
this->m_Controls.m_lbLoadedAlgorithmName->setText(
QString::fromStdString(m_LoadedAlgorithm->getUID()->toStr()));
}
else
{
m_Controls.m_tabSettings->setEnabled(false);
m_Controls.m_tabExecution->setEnabled(false);
this->m_Controls.m_lbLoadedAlgorithmName->setText(
- QString("<font color='red'>no algorithm loaded!</font>"));
+ QStringLiteral("<font color='red'>no algorithm loaded!</font>"));
m_Controls.groupMasks->setVisible(false);
}
if (!m_Working)
{
this->m_Controls.m_leRegJobName->setText(QString::fromStdString(this->GetDefaultRegJobName()));
}
}
void QmitkMatchPoint::ConfigureNodeSelectors()
{
auto isImage = mitk::MITKRegistrationHelper::ImageNodePredicate();
auto isPointSet = mitk::MITKRegistrationHelper::PointSetNodePredicate();
mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
mitk::NodePredicateBase::Pointer dimensionPredicate = mitk::NodePredicateOr::New(mitk::NodePredicateDimension::New(3), mitk::NodePredicateDimension::New(4)).GetPointer();
mitk::NodePredicateAnd::Pointer maskPredicate = mitk::NodePredicateAnd::New(mitk::NodePredicateOr::New(isLegacyMask, isLabelSet), dimensionPredicate);
m_Controls.movingNodeSelector->setEnabled(m_LoadedAlgorithm.IsNotNull());
m_Controls.targetNodeSelector->setEnabled(m_LoadedAlgorithm.IsNotNull());
m_Controls.movingMaskNodeSelector->setEnabled(m_LoadedAlgorithm.IsNotNull());
m_Controls.targetMaskNodeSelector->setEnabled(m_LoadedAlgorithm.IsNotNull());
if (m_LoadedAlgorithm.IsNotNull())
{
mitk::NodePredicateBase::ConstPointer dataPredicate;
if (m_LoadedAlgorithm->getMovingDimensions() == 2)
{
dimensionPredicate = mitk::NodePredicateDimension::New(2);
}
if (mitk::MITKAlgorithmHelper::HasImageAlgorithmInterface(m_LoadedAlgorithm))
{
dataPredicate = mitk::NodePredicateAnd::New(isImage, dimensionPredicate);
m_Controls.movingNodeSelector->SetInvalidInfo("Select valid moving image.");
m_Controls.movingNodeSelector->SetPopUpTitel("Select moving image.");
m_Controls.movingNodeSelector->SetPopUpHint("Select the moving image that should be registered onto the target image.");
m_Controls.targetNodeSelector->SetInvalidInfo("Select valid target image.");
m_Controls.targetNodeSelector->SetPopUpTitel("Select target image.");
m_Controls.targetNodeSelector->SetPopUpHint("Select the target image that should be used as reference for the registration.");
}
if (mitk::MITKAlgorithmHelper::HasPointSetAlgorithmInterface(m_LoadedAlgorithm))
{
if (dataPredicate.IsNull())
{
dataPredicate = isPointSet;
m_Controls.movingNodeSelector->SetInvalidInfo("Select valid moving point set.");
m_Controls.movingNodeSelector->SetPopUpTitel("Select moving point set.");
m_Controls.movingNodeSelector->SetPopUpHint("Select the moving point set that should be registered onto the target point set.");
m_Controls.targetNodeSelector->SetInvalidInfo("Select valid target point set.");
m_Controls.targetNodeSelector->SetPopUpTitel("Select target point set.");
m_Controls.targetNodeSelector->SetPopUpHint("Select the target point set that should be used as reference for the registration.");
}
else
{
dataPredicate = mitk::NodePredicateOr::New(dataPredicate, isPointSet);
m_Controls.movingNodeSelector->SetInvalidInfo("Select valid moving data.");
m_Controls.movingNodeSelector->SetPopUpTitel("Select moving data.");
m_Controls.movingNodeSelector->SetPopUpHint("Select the moving data that should be registered onto the target data. The algorithm supports images as well as point sets.");
m_Controls.targetNodeSelector->SetInvalidInfo("Select valid target data.");
m_Controls.targetNodeSelector->SetPopUpTitel("Select target data.");
m_Controls.targetNodeSelector->SetPopUpHint("Select the target data that should be used as reference for the registration. The algorithm supports images as well as point sets.");
}
}
mitk::NodePredicateBase::ConstPointer nodePredicate = dataPredicate;
m_Controls.movingNodeSelector->SetNodePredicate(nodePredicate);
m_Controls.targetNodeSelector->SetNodePredicate(nodePredicate);
nodePredicate = mitk::NodePredicateAnd::New(maskPredicate, dimensionPredicate);
m_Controls.movingMaskNodeSelector->SetEmptyInfo("Select moving mask. (optional)");
m_Controls.movingMaskNodeSelector->SetPopUpTitel("Select moving mask");
m_Controls.movingMaskNodeSelector->SetPopUpHint("Select a segmentation that serves as moving mask for the registration.");
m_Controls.targetMaskNodeSelector->SetEmptyInfo("Select target mask. (optional)");
m_Controls.targetMaskNodeSelector->SetPopUpTitel("Select target mask");
m_Controls.targetMaskNodeSelector->SetPopUpHint("Select a segmentation that serves as target mask for the registration.");
m_Controls.movingMaskNodeSelector->SetNodePredicate(nodePredicate);
m_Controls.targetMaskNodeSelector->SetNodePredicate(nodePredicate);
}
}
void QmitkMatchPoint::ConfigureProgressInfos()
{
const IIterativeAlgorithm* pIterative = dynamic_cast<const IIterativeAlgorithm*>
(m_LoadedAlgorithm.GetPointer());
const IMultiResAlgorithm* pMultiRes = dynamic_cast<const IMultiResAlgorithm*>
(m_LoadedAlgorithm.GetPointer());
m_Controls.m_progBarIteration->setVisible(pIterative);
m_Controls.m_lbProgBarIteration->setVisible(pIterative);
if (pIterative)
{
QString format = "%p% (%v/%m)";
if (!pIterative->hasMaxIterationCount())
{
format = "%v";
m_Controls.m_progBarIteration->setMaximum(0);
}
else
{
m_Controls.m_progBarIteration->setMaximum(pIterative->getMaxIterations());
}
m_Controls.m_progBarIteration->setFormat(format);
}
m_Controls.m_progBarLevel->setVisible(pMultiRes);
m_Controls.m_lbProgBarLevel->setVisible(pMultiRes);
if (pMultiRes)
{
m_Controls.m_progBarLevel->setMaximum(pMultiRes->getResolutionLevels());
}
else
{
m_Controls.m_progBarLevel->setMaximum(1);
}
m_Controls.m_progBarIteration->reset();
m_Controls.m_progBarLevel->reset();
}
void QmitkMatchPoint::OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
{
if (!m_Working)
{
CheckInputs();
ConfigureRegistrationControls();
}
}
void QmitkMatchPoint::OnStartRegBtnPushed()
{
this->m_Working = true;
////////////////////////////////
//configure GUI
this->ConfigureProgressInfos();
m_Controls.m_progBarIteration->reset();
m_Controls.m_progBarLevel->reset();
this->ConfigureRegistrationControls();
if (m_Controls.m_checkClearLog->checkState() == Qt::Checked)
{
this->m_Controls.m_teLog->clear();
}
/////////////////////////
//create job and put it into the thread pool
QmitkRegistrationJob* pJob = new QmitkRegistrationJob(m_LoadedAlgorithm);
pJob->setAutoDelete(true);
pJob->m_spTargetData = m_spSelectedTargetData;
pJob->m_spMovingData = m_spSelectedMovingData;
pJob->m_TargetDataUID = mitk::EnsureUID(this->m_spSelectedTargetNode->GetData());
pJob->m_MovingDataUID = mitk::EnsureUID(this->m_spSelectedMovingNode->GetData());
if (m_spSelectedTargetMaskData.IsNotNull())
{
pJob->m_spTargetMask = m_spSelectedTargetMaskData;
pJob->m_TargetMaskDataUID = mitk::EnsureUID(this->m_spSelectedTargetMaskNode->GetData());
}
if (m_spSelectedMovingMaskData.IsNotNull())
{
pJob->m_spMovingMask = m_spSelectedMovingMaskData;
pJob->m_MovingMaskDataUID = mitk::EnsureUID(this->m_spSelectedMovingMaskNode->GetData());
}
pJob->m_JobName = m_Controls.m_leRegJobName->text().toStdString();
pJob->m_StoreReg = true;
connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnRegJobError(QString)));
connect(pJob, SIGNAL(Finished()), this, SLOT(OnRegJobFinished()));
connect(pJob, SIGNAL(RegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer,
const QmitkRegistrationJob*)), this,
SLOT(OnRegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer, const QmitkRegistrationJob*)),
Qt::BlockingQueuedConnection);
connect(pJob, SIGNAL(AlgorithmInfo(QString)), this, SLOT(OnAlgorithmInfo(QString)));
connect(pJob, SIGNAL(AlgorithmStatusChanged(QString)), this,
SLOT(OnAlgorithmStatusChanged(QString)));
connect(pJob, SIGNAL(AlgorithmIterated(QString, bool, unsigned long)), this,
SLOT(OnAlgorithmIterated(QString, bool, unsigned long)));
connect(pJob, SIGNAL(LevelChanged(QString, bool, unsigned long)), this, SLOT(OnLevelChanged(QString,
bool, unsigned long)));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pJob);
}
void QmitkMatchPoint::OnStopRegBtnPushed()
{
if (m_LoadedAlgorithm.IsNotNull())
{
IStoppableAlgorithm* pIterativ = dynamic_cast<IStoppableAlgorithm*>(m_LoadedAlgorithm.GetPointer());
if (pIterativ && pIterativ->isStoppable())
{
if (pIterativ->stopAlgorithm())
{
}
else
{
}
m_Controls.m_pbStopReg->setEnabled(false);
}
else
{
}
}
}
void QmitkMatchPoint::OnSaveLogBtnPushed()
{
QDateTime currentTime = QDateTime::currentDateTime();
QString fileName = tr("registration_log_") + currentTime.toString(tr("yyyy-MM-dd_hh-mm-ss")) +
tr(".txt");
fileName = QFileDialog::getSaveFileName(nullptr, tr("Save registration log"), fileName,
tr("Text files (*.txt)"));
if (fileName.isEmpty())
{
QMessageBox::critical(nullptr, tr("No file selected!"),
tr("Cannot save registration log file. Please selected a file."));
}
else
{
std::ofstream file;
std::ios_base::openmode iOpenFlag = std::ios_base::out | std::ios_base::trunc;
file.open(fileName.toStdString().c_str(), iOpenFlag);
if (!file.is_open())
{
mitkThrow() << "Cannot open or create specified file to save. File path: "
<< fileName.toStdString();
}
file << this->m_Controls.m_teLog->toPlainText().toStdString() << std::endl;
file.close();
}
}
void QmitkMatchPoint::OnRegJobError(QString err)
{
Error(err);
}
void QmitkMatchPoint::OnRegJobFinished()
{
this->m_Working = false;
this->GetRenderWindowPart()->RequestUpdate();
this->CheckInputs();
this->ConfigureRegistrationControls();
this->ConfigureProgressInfos();
}
void QmitkMatchPoint::OnRegResultIsAvailable(mitk::MAPRegistrationWrapper::Pointer
spResultRegistration, const QmitkRegistrationJob* pRegJob)
{
mitk::DataNode::Pointer spResultRegistrationNode = mitk::generateRegistrationResultNode(
pRegJob->m_JobName, spResultRegistration, pRegJob->GetLoadedAlgorithm()->getUID()->toStr(),
pRegJob->m_MovingDataUID, pRegJob->m_TargetDataUID);
if (pRegJob->m_StoreReg)
{
m_Controls.m_teLog->append(
- QString("<b><font color='blue'> Storing registration object in data manager ... </font></b>"));
+ QStringLiteral("<b><font color='blue'> Storing registration object in data manager ... </font></b>"));
this->GetDataStorage()->Add(spResultRegistrationNode);
this->GetRenderWindowPart()->RequestUpdate();
}
if (m_Controls.m_checkMapEntity->checkState() == Qt::Checked)
{
QmitkMappingJob* pMapJob = new QmitkMappingJob();
pMapJob->setAutoDelete(true);
pMapJob->m_spInputData = pRegJob->m_spMovingData;
pMapJob->m_InputDataUID = pRegJob->m_MovingDataUID;
pMapJob->m_spRegNode = spResultRegistrationNode;
pMapJob->m_doGeometryRefinement = false;
pMapJob->m_spRefGeometry = pRegJob->m_spTargetData->GetGeometry()->Clone().GetPointer();
pMapJob->m_MappedName = pRegJob->m_JobName + std::string(" mapped moving data");
pMapJob->m_allowUndefPixels = true;
pMapJob->m_paddingValue = 100;
pMapJob->m_allowUnregPixels = true;
pMapJob->m_errorValue = 200;
pMapJob->m_InterpolatorLabel = "Linear Interpolation";
pMapJob->m_InterpolatorType = mitk::ImageMappingInterpolator::Linear;
connect(pMapJob, SIGNAL(Error(QString)), this, SLOT(OnMapJobError(QString)));
connect(pMapJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
Qt::BlockingQueuedConnection);
connect(pMapJob, SIGNAL(AlgorithmInfo(QString)), this, SLOT(OnAlgorithmInfo(QString)));
m_Controls.m_teLog->append(
- QString("<b><font color='blue'>Started mapping input data...</font></b>"));
+ QStringLiteral("<b><font color='blue'>Started mapping input data...</font></b>"));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pMapJob);
}
}
void QmitkMatchPoint::OnMapJobError(QString err)
{
Error(err);
}
void QmitkMatchPoint::OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData,
const QmitkMappingJob* job)
{
- m_Controls.m_teLog->append(QString("<b><font color='blue'>Mapped entity stored. Name: ") +
- QString::fromStdString(job->m_MappedName) + QString("</font></b>"));
+ m_Controls.m_teLog->append(QStringLiteral("<b><font color='blue'>Mapped entity stored. Name: ") +
+ QString::fromStdString(job->m_MappedName) + QStringLiteral("</font></b>"));
mitk::DataNode::Pointer spMappedNode = mitk::generateMappedResultNode(job->m_MappedName,
spMappedData, job->GetRegistration()->getRegistrationUID(), job->m_InputDataUID,
job->m_doGeometryRefinement, job->m_InterpolatorLabel);
this->GetDataStorage()->Add(spMappedNode);
this->GetRenderWindowPart()->RequestUpdate();
}
void QmitkMatchPoint::OnAlgorithmIterated(QString info, bool hasIterationCount,
unsigned long currentIteration)
{
if (hasIterationCount)
{
m_Controls.m_progBarIteration->setValue(currentIteration);
}
m_Controls.m_teLog->append(info);
}
void QmitkMatchPoint::OnLevelChanged(QString info, bool hasLevelCount, unsigned long currentLevel)
{
if (hasLevelCount)
{
m_Controls.m_progBarLevel->setValue(currentLevel);
}
- m_Controls.m_teLog->append(QString("<b><font color='green'>") + info + QString("</font></b>"));
+ m_Controls.m_teLog->append(QStringLiteral("<b><font color='green'>") + info + QStringLiteral("</font></b>"));
}
void QmitkMatchPoint::OnAlgorithmStatusChanged(QString info)
{
- m_Controls.m_teLog->append(QString("<b><font color='blue'>") + info + QString(" </font></b>"));
+ m_Controls.m_teLog->append(QStringLiteral("<b><font color='blue'>") + info + QStringLiteral(" </font></b>"));
}
void QmitkMatchPoint::OnAlgorithmInfo(QString info)
{
- m_Controls.m_teLog->append(QString("<font color='gray'><i>") + info + QString("</i></font>"));
+ m_Controls.m_teLog->append(QStringLiteral("<font color='gray'><i>") + info + QStringLiteral("</i></font>"));
}
void QmitkMatchPoint::OnAlgorithmSelectionChanged(const berry::IWorkbenchPart::Pointer& sourcepart,
const berry::ISelection::ConstPointer& selection)
{
// check for null selection
if (selection.IsNull())
{
return;
}
if (sourcepart != this)
{
UpdateAlgorithmSelection(selection);
}
}
void QmitkMatchPoint::UpdateAlgorithmSelection(berry::ISelection::ConstPointer selection)
{
mitk::MAPAlgorithmInfoSelection::ConstPointer currentSelection =
selection.Cast<const mitk::MAPAlgorithmInfoSelection>();
if (currentSelection)
{
mitk::MAPAlgorithmInfoSelection::AlgorithmInfoVectorType infoVector =
currentSelection->GetSelectedAlgorithmInfo();
if (!infoVector.empty())
{
// only the first selection is of interest, the rest will be skipped.
this->m_SelectedAlgorithmInfo = infoVector[0];
}
}
this->OnSelectedAlgorithmChanged();
}
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrection.cpp b/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrection.cpp
index e41dff4465..311a40947e 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrection.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrection.cpp
@@ -1,718 +1,720 @@
/*============================================================================
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 "org_mitk_gui_qt_matchpoint_framereg_Activator.h"
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
#include <berryISelectionProvider.h>
#include <berryQModelIndexObject.h>
// Mitk
#include <mitkStatusBar.h>
#include <mitkPointSet.h>
#include <mitkImageTimeSelector.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateDimension.h>
#include <mitkNodePredicateGeometry.h>
#include <mitkMAPAlgorithmInfoSelection.h>
#include <mitkRegistrationHelper.h>
#include <mitkResultNodeGenerationHelper.h>
// Qmitk
#include "QmitkMatchPointFrameCorrection.h"
#include <QmitkRegistrationJob.h>
#include <QmitkMappingJob.h>
// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QErrorMessage>
#include <QThreadPool>
#include <QDateTime>
// MatchPoint
#include <mapImageRegistrationAlgorithmInterface.h>
#include <mapPointSetRegistrationAlgorithmInterface.h>
#include <mapRegistrationAlgorithmInterface.h>
#include <mapMaskedRegistrationAlgorithmInterface.h>
#include <mapAlgorithmEvents.h>
#include <mapAlgorithmWrapperEvent.h>
#include <mapExceptionObjectMacros.h>
#include <mapConvert.h>
#include <mapDeploymentDLLAccess.h>
const std::string QmitkMatchPointFrameCorrection::VIEW_ID =
"org.mitk.views.matchpoint.algorithm.framereg";
QmitkMatchPointFrameCorrection::QmitkMatchPointFrameCorrection()
: m_Parent(nullptr), m_LoadedDLLHandle(nullptr), m_LoadedAlgorithm(nullptr), m_CanLoadAlgorithm(false), m_Working(false)
{
m_spSelectedTargetData = nullptr;
m_spSelectedTargetMaskData = nullptr;
}
QmitkMatchPointFrameCorrection::~QmitkMatchPointFrameCorrection()
{
// remove selection service
berry::ISelectionService* s = this->GetSite()->GetWorkbenchWindow()->GetSelectionService();
if (s)
{
s->RemoveSelectionListener(m_AlgorithmSelectionListener.data());
}
}
void QmitkMatchPointFrameCorrection::SetFocus()
{
}
void QmitkMatchPointFrameCorrection::CreateConnections()
{
connect(m_Controls.imageNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.maskNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
// ------
// Tab 1 - Shared library loading interface
// ------
connect(m_Controls.m_pbLoadSelected, SIGNAL(clicked()), this, SLOT(OnLoadAlgorithmButtonPushed()));
// -----
// Tab 2 - Execution
// -----
connect(m_Controls.m_pbStartReg, SIGNAL(clicked()), this, SLOT(OnStartRegBtnPushed()));
connect(m_Controls.m_pbSaveLog, SIGNAL(clicked()), this, SLOT(OnSaveLogBtnPushed()));
// -----
// Tab 4 - Frames
// -----
connect(m_Controls.m_btnFrameSelAll, SIGNAL(clicked()), this, SLOT(OnFramesSelectAllPushed()));
connect(m_Controls.m_btnFrameDeSelAll, SIGNAL(clicked()), this, SLOT(OnFramesDeSelectAllPushed()));
connect(m_Controls.m_btnFrameInvert, SIGNAL(clicked()), this, SLOT(OnFramesInvertPushed()));
}
const map::deployment::DLLInfo* QmitkMatchPointFrameCorrection::GetSelectedAlgorithmDLL() const
{
return m_SelectedAlgorithmInfo;
}
void QmitkMatchPointFrameCorrection::OnSelectedAlgorithmChanged()
{
std::stringstream descriptionString;
::map::deployment::DLLInfo::ConstPointer currentItemInfo = GetSelectedAlgorithmDLL();
if (!currentItemInfo)
{
return;
}
m_Controls.m_teAlgorithmDetails->updateInfo(currentItemInfo);
m_Controls.m_lbSelectedAlgorithm->setText(QString::fromStdString(
currentItemInfo->getAlgorithmUID().getName()));
// enable loading
m_CanLoadAlgorithm = true;
this->AdaptFolderGUIElements();
}
void QmitkMatchPointFrameCorrection::OnLoadAlgorithmButtonPushed()
{
map::deployment::DLLInfo::ConstPointer dllInfo = GetSelectedAlgorithmDLL();
if (!dllInfo)
{
- Error(QString("No valid algorithm is selected. Cannot load algorithm. ABORTING."));
+ Error(QStringLiteral("No valid algorithm is selected. Cannot load algorithm. ABORTING."));
return;
}
::map::deployment::DLLHandle::Pointer tempDLLHandle = ::map::deployment::openDeploymentDLL(
dllInfo->getLibraryFilePath());
::map::algorithm::RegistrationAlgorithmBase::Pointer tempAlgorithm
= ::map::deployment::getRegistrationAlgorithm(tempDLLHandle);
if (tempAlgorithm.IsNull())
{
- Error(QString("Error. Cannot load selected algorithm."));
+ Error(QStringLiteral("Error. Cannot load selected algorithm."));
return;
}
this->m_LoadedAlgorithm = tempAlgorithm;
this->m_LoadedDLLHandle = tempDLLHandle;
this->m_Controls.m_AlgoConfigurator->setAlgorithm(m_LoadedAlgorithm);
this->AdaptFolderGUIElements();
this->ConfigureNodeSelectorPredicates();
this->CheckInputs();
this->ConfigureRegistrationControls();
this->ConfigureProgressInfos();
this->m_Controls.m_tabs->setCurrentIndex(1);
}
void QmitkMatchPointFrameCorrection::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
m_Controls.m_teLog->append(QString("<font color='red'><b>") + msg + QString("</b></font>"));
}
void QmitkMatchPointFrameCorrection::AdaptFolderGUIElements()
{
m_Controls.m_pbLoadSelected->setEnabled(m_CanLoadAlgorithm);
}
void QmitkMatchPointFrameCorrection::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Parent = parent;
this->m_Controls.imageNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.imageNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.maskNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.maskNodeSelector->SetSelectionIsOptional(true);
this->m_Controls.imageNodeSelector->SetInvalidInfo("Select dymamic image.");
this->m_Controls.imageNodeSelector->SetPopUpTitel("Select dynamic image.");
this->m_Controls.imageNodeSelector->SetPopUpHint("Select a dynamic image (time resolved) that should be frame corrected.");
this->m_Controls.maskNodeSelector->SetInvalidInfo("Select target mask.");
this->m_Controls.maskNodeSelector->SetPopUpTitel("Select target mask.");
this->m_Controls.maskNodeSelector->SetPopUpHint("Select a target mask (mask of the target/first frame).");
m_Controls.m_tabs->setCurrentIndex(0);
m_Controls.m_mapperSettings->AllowSampling(false);
m_AlgorithmSelectionListener.reset(new
berry::SelectionChangedAdapter<QmitkMatchPointFrameCorrection>(this,
&QmitkMatchPointFrameCorrection::OnAlgorithmSelectionChanged));
// register selection listener
GetSite()->GetWorkbenchWindow()->GetSelectionService()->AddSelectionListener(
m_AlgorithmSelectionListener.data());
this->ConfigureNodeSelectorPredicates();
this->CreateConnections();
this->AdaptFolderGUIElements();
this->CheckInputs();
this->ConfigureProgressInfos();
this->ConfigureRegistrationControls();
berry::ISelection::ConstPointer selection =
GetSite()->GetWorkbenchWindow()->GetSelectionService()->GetSelection("org.mitk.views.matchpoint.algorithm.browser");
this->UpdateAlgorithmSelection(selection);
}
void QmitkMatchPointFrameCorrection::ConfigureNodeSelectorPredicates()
{
auto isImage = mitk::MITKRegistrationHelper::ImageNodePredicate();
mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
mitk::NodePredicateBase::Pointer maskDimensionPredicate = mitk::NodePredicateOr::New(mitk::NodePredicateDimension::New(3), mitk::NodePredicateDimension::New(4)).GetPointer();
mitk::NodePredicateDimension::Pointer imageDimensionPredicate = mitk::NodePredicateDimension::New(4);
m_Controls.imageNodeSelector->setEnabled(m_LoadedAlgorithm.IsNotNull());
m_Controls.maskNodeSelector->setEnabled(m_LoadedAlgorithm.IsNotNull());
m_Controls.imageNodeSelector->SetNodePredicate(mitk::NodePredicateAnd::New(isImage, imageDimensionPredicate));
mitk::NodePredicateAnd::Pointer maskPredicate = mitk::NodePredicateAnd::New(mitk::NodePredicateOr::New(isLegacyMask, isLabelSet), maskDimensionPredicate);
if (m_spSelectedTargetData != nullptr)
{
auto hasSameGeometry = mitk::NodePredicateGeometry::New(m_spSelectedTargetData->GetGeometry());
hasSameGeometry->SetCheckPrecision(1e-10);
maskPredicate = mitk::NodePredicateAnd::New(maskPredicate, hasSameGeometry);
}
m_Controls.maskNodeSelector->SetNodePredicate(maskPredicate);
}
void QmitkMatchPointFrameCorrection::CheckInputs()
{
mitk::DataNode::Pointer oldTargetNode = m_spSelectedTargetNode;
m_spSelectedTargetNode = nullptr;
m_spSelectedTargetData = nullptr;
m_spSelectedTargetMaskNode = nullptr;
m_spSelectedTargetMaskData = nullptr;
if (m_LoadedAlgorithm.IsNull())
{
m_Controls.m_lbLoadedAlgorithmName->setText(
- QString("<font color='red'>No algorithm seleted!</font>"));
+ QStringLiteral("<font color='red'>No algorithm seleted!</font>"));
}
else
{
m_spSelectedTargetNode = m_Controls.imageNodeSelector->GetSelectedNode();
if (m_spSelectedTargetNode.IsNotNull())
{
m_spSelectedTargetData = m_spSelectedTargetNode->GetData();
}
m_spSelectedTargetMaskNode = m_Controls.maskNodeSelector->GetSelectedNode();
if (m_spSelectedTargetMaskNode.IsNotNull())
{
m_spSelectedTargetMaskData = dynamic_cast<mitk::Image*>(m_spSelectedTargetMaskNode->GetData());
}
}
if (oldTargetNode != m_spSelectedTargetNode)
{
ConfigureFrameList();
}
}
mitk::DataStorage::SetOfObjects::Pointer QmitkMatchPointFrameCorrection::GetRegNodes() const
{
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetDataStorage()->GetAll();
mitk::DataStorage::SetOfObjects::Pointer result = mitk::DataStorage::SetOfObjects::New();
for (mitk::DataStorage::SetOfObjects::const_iterator pos = nodes->begin(); pos != nodes->end();
++pos)
{
if (mitk::MITKRegistrationHelper::IsRegNode(*pos))
{
result->push_back(*pos);
}
}
return result;
}
std::string QmitkMatchPointFrameCorrection::GetDefaultJobName() const
{
mitk::DataStorage::SetOfObjects::ConstPointer nodes = this->GetRegNodes().GetPointer();
mitk::DataStorage::SetOfObjects::ElementIdentifier newIndex = 0;
bool isUnique = false;
std::string baseName = "corrected #";
if (m_spSelectedTargetNode.IsNotNull())
{
baseName = m_spSelectedTargetNode->GetName() + "corrected #";
}
std::string result = baseName;
while (!isUnique)
{
++newIndex;
result = baseName + ::map::core::convert::toStr(newIndex);
isUnique = this->GetDataStorage()->GetNamedNode(result) == nullptr;
}
return result;
}
void QmitkMatchPointFrameCorrection::ConfigureRegistrationControls()
{
m_Controls.m_tabSelection->setEnabled(!m_Working);
m_Controls.m_leRegJobName->setEnabled(!m_Working);
m_Controls.m_pbStartReg->setEnabled(false);
m_Controls.imageNodeSelector->setEnabled(!m_Working);
m_Controls.maskNodeSelector->setEnabled(!m_Working);
if (m_LoadedAlgorithm.IsNotNull())
{
m_Controls.m_tabSettings->setEnabled(!m_Working);
m_Controls.m_tabExclusion->setEnabled(!m_Working);
m_Controls.m_tabExecution->setEnabled(true);
m_Controls.m_pbStartReg->setEnabled(m_spSelectedTargetNode.IsNotNull() && !m_Working);
m_Controls.m_leRegJobName->setEnabled(!m_Working);
typedef ::map::algorithm::facet::MaskedRegistrationAlgorithmInterface<3, 3> MaskRegInterface;
const MaskRegInterface* pMaskReg = dynamic_cast<const MaskRegInterface*>
(m_LoadedAlgorithm.GetPointer());
m_Controls.maskNodeSelector->setVisible(pMaskReg != nullptr);
+ m_Controls.label_TargetMask->setVisible(pMaskReg != nullptr);
if (!pMaskReg)
{
m_Controls.maskNodeSelector->SetCurrentSelection(QmitkSingleNodeSelectionWidget::NodeList());
}
this->m_Controls.m_lbLoadedAlgorithmName->setText(
QString::fromStdString(m_LoadedAlgorithm->getUID()->toStr()));
}
else
{
m_Controls.m_tabSettings->setEnabled(false);
m_Controls.m_tabExclusion->setEnabled(false);
m_Controls.m_tabExecution->setEnabled(false);
this->m_Controls.m_lbLoadedAlgorithmName->setText(
- QString("<font color='red'>no algorithm loaded!</font>"));
+ QStringLiteral("<font color='red'>no algorithm loaded!</font>"));
m_Controls.maskNodeSelector->setVisible(false);
+ m_Controls.label_TargetMask->setVisible(false);
}
if (!m_Working)
{
this->m_Controls.m_leRegJobName->setText(QString::fromStdString(this->GetDefaultJobName()));
}
}
void QmitkMatchPointFrameCorrection::ConfigureProgressInfos()
{
const IIterativeAlgorithm* pIterative = dynamic_cast<const IIterativeAlgorithm*>
(m_LoadedAlgorithm.GetPointer());
const IMultiResAlgorithm* pMultiRes = dynamic_cast<const IMultiResAlgorithm*>
(m_LoadedAlgorithm.GetPointer());
m_Controls.m_progBarIteration->setVisible(pIterative);
m_Controls.m_lbProgBarIteration->setVisible(pIterative);
if (pIterative)
{
QString format = "%p% (%v/%m)";
if (!pIterative->hasMaxIterationCount())
{
format = "%v";
m_Controls.m_progBarIteration->setMaximum(0);
}
else
{
m_Controls.m_progBarIteration->setMaximum(pIterative->getMaxIterations());
}
m_Controls.m_progBarIteration->setFormat(format);
}
if (pMultiRes)
{
m_Controls.m_progBarLevel->setMaximum(pMultiRes->getResolutionLevels());
}
else
{
m_Controls.m_progBarLevel->setMaximum(1);
}
m_Controls.m_progBarIteration->reset();
m_Controls.m_progBarLevel->reset();
m_Controls.m_progBarFrame->reset();
}
void QmitkMatchPointFrameCorrection::ConfigureFrameList()
{
m_Controls.m_listFrames->clear();
if (m_spSelectedTargetData.IsNotNull())
{
mitk::TimeGeometry::ConstPointer tg = m_spSelectedTargetData->GetTimeGeometry();
for (unsigned int i = 1; i < tg->CountTimeSteps(); ++i)
{
QString lable = "Timepoint #" + QString::number(i) + QString(" (") + QString::number(
tg->GetMinimumTimePoint(i)) + QString(" ms - " + QString::number(tg->GetMaximumTimePoint(
i)) + QString(" ms)"));
QListWidgetItem* item = new QListWidgetItem(lable, m_Controls.m_listFrames);
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
item->setCheckState(Qt::Checked);
}
}
}
void QmitkMatchPointFrameCorrection::OnFramesSelectAllPushed()
{
for (int row = 0; row < m_Controls.m_listFrames->count(); row++)
{
QListWidgetItem* item = m_Controls.m_listFrames->item(row);
item->setCheckState(Qt::Checked);
}
};
void QmitkMatchPointFrameCorrection::OnFramesDeSelectAllPushed()
{
for (int row = 0; row < m_Controls.m_listFrames->count(); row++)
{
QListWidgetItem* item = m_Controls.m_listFrames->item(row);
item->setCheckState(Qt::Unchecked);
}
};
void QmitkMatchPointFrameCorrection::OnFramesInvertPushed()
{
for (int row = 0; row < m_Controls.m_listFrames->count(); row++)
{
QListWidgetItem* item = m_Controls.m_listFrames->item(row);
if (item->checkState() == Qt::Unchecked)
{
item->setCheckState(Qt::Checked);
}
else
{
item->setCheckState(Qt::Unchecked);
}
}
};
mitk::TimeFramesRegistrationHelper::IgnoreListType
QmitkMatchPointFrameCorrection::GenerateIgnoreList() const
{
mitk::TimeFramesRegistrationHelper::IgnoreListType result;
for (int row = 0; row < m_Controls.m_listFrames->count(); row++)
{
QListWidgetItem* item = m_Controls.m_listFrames->item(row);
if (item->checkState() == Qt::Unchecked)
{
result.push_back(row + 1);
}
}
return result;
}
void QmitkMatchPointFrameCorrection::OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
{
if (!m_Working)
{
ConfigureNodeSelectorPredicates();
CheckInputs();
ConfigureRegistrationControls();
}
}
void QmitkMatchPointFrameCorrection::OnStartRegBtnPushed()
{
this->m_Working = true;
////////////////////////////////
//configure GUI
this->ConfigureProgressInfos();
m_Controls.m_progBarIteration->reset();
m_Controls.m_progBarLevel->reset();
this->ConfigureRegistrationControls();
if (m_Controls.m_checkClearLog->checkState() == Qt::Checked)
{
this->m_Controls.m_teLog->clear();
}
/////////////////////////
//create job and put it into the thread pool
QmitkFramesRegistrationJob* pJob = new QmitkFramesRegistrationJob(m_LoadedAlgorithm);
pJob->setAutoDelete(true);
pJob->m_spTargetData = m_spSelectedTargetData;
pJob->m_TargetDataUID = mitk::EnsureUID(this->m_spSelectedTargetNode->GetData());
pJob->m_IgnoreList = this->GenerateIgnoreList();
if (m_spSelectedTargetMaskData.IsNotNull())
{
pJob->m_spTargetMask = m_spSelectedTargetMaskData;
pJob->m_TargetMaskDataUID = mitk::EnsureUID(this->m_spSelectedTargetMaskNode->GetData());
}
pJob->m_MappedName = m_Controls.m_leRegJobName->text().toStdString();
m_Controls.m_mapperSettings->ConfigureJobSettings(pJob);
connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnRegJobError(QString)));
connect(pJob, SIGNAL(Finished()), this, SLOT(OnRegJobFinished()));
connect(pJob, SIGNAL(ResultIsAvailable(mitk::Image::Pointer, const QmitkFramesRegistrationJob*)),
this, SLOT(OnMapResultIsAvailable(mitk::Image::Pointer, const QmitkFramesRegistrationJob*)),
Qt::BlockingQueuedConnection);
connect(pJob, SIGNAL(AlgorithmInfo(QString)), this, SLOT(OnAlgorithmInfo(QString)));
connect(pJob, SIGNAL(AlgorithmStatusChanged(QString)), this,
SLOT(OnAlgorithmStatusChanged(QString)));
connect(pJob, SIGNAL(AlgorithmIterated(QString, bool, unsigned long)), this,
SLOT(OnAlgorithmIterated(QString, bool, unsigned long)));
connect(pJob, SIGNAL(LevelChanged(QString, bool, unsigned long)), this, SLOT(OnLevelChanged(QString,
bool, unsigned long)));
connect(pJob, SIGNAL(FrameRegistered(double)), this, SLOT(OnFrameRegistered(double)));
connect(pJob, SIGNAL(FrameMapped(double)), this, SLOT(OnFrameMapped(double)));
connect(pJob, SIGNAL(FrameProcessed(double)), this, SLOT(OnFrameProcessed(double)));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pJob);
}
void QmitkMatchPointFrameCorrection::OnSaveLogBtnPushed()
{
QDateTime currentTime = QDateTime::currentDateTime();
QString fileName = tr("registration_log_") + currentTime.toString(tr("yyyy-MM-dd_hh-mm-ss")) +
tr(".txt");
fileName = QFileDialog::getSaveFileName(nullptr, tr("Save registration log"), fileName,
tr("Text files (*.txt)"));
if (fileName.isEmpty())
{
QMessageBox::critical(nullptr, tr("No file selected!"),
tr("Cannot save registration log file. Please selected a file."));
}
else
{
std::ofstream file;
std::ios_base::openmode iOpenFlag = std::ios_base::out | std::ios_base::trunc;
file.open(fileName.toStdString().c_str(), iOpenFlag);
if (!file.is_open())
{
mitkThrow() << "Cannot open or create specified file to save. File path: "
<< fileName.toStdString();
}
file << this->m_Controls.m_teLog->toPlainText().toStdString() << std::endl;
file.close();
}
}
void QmitkMatchPointFrameCorrection::OnRegJobError(QString err)
{
Error(err);
};
void QmitkMatchPointFrameCorrection::OnRegJobFinished()
{
this->m_Working = false;
this->GetRenderWindowPart()->RequestUpdate();
this->CheckInputs();
this->ConfigureRegistrationControls();
this->ConfigureProgressInfos();
};
void QmitkMatchPointFrameCorrection::OnMapResultIsAvailable(mitk::Image::Pointer spMappedData,
const QmitkFramesRegistrationJob* job)
{
m_Controls.m_teLog->append(QString("<b><font color='blue'>Corrected image stored. Name: ") +
QString::fromStdString(job->m_MappedName) + QString("</font></b>"));
mitk::DataNode::Pointer spResultNode = mitk::generateMappedResultNode(job->m_MappedName,
spMappedData.GetPointer(), "", job->m_TargetDataUID, false, job->m_InterpolatorLabel);
this->GetDataStorage()->Add(spResultNode, this->m_spSelectedTargetNode);
this->GetRenderWindowPart()->RequestUpdate();
};
void QmitkMatchPointFrameCorrection::OnMapJobError(QString err)
{
Error(err);
};
void QmitkMatchPointFrameCorrection::OnAlgorithmIterated(QString info, bool hasIterationCount,
unsigned long currentIteration)
{
if (hasIterationCount)
{
m_Controls.m_progBarIteration->setValue(currentIteration);
}
m_Controls.m_teLog->append(info);
};
void QmitkMatchPointFrameCorrection::OnLevelChanged(QString info, bool hasLevelCount,
unsigned long currentLevel)
{
if (hasLevelCount)
{
m_Controls.m_progBarLevel->setValue(currentLevel);
}
m_Controls.m_teLog->append(QString("<b><font color='green'>") + info + QString("</font></b>"));
};
void QmitkMatchPointFrameCorrection::OnAlgorithmStatusChanged(QString info)
{
m_Controls.m_teLog->append(QString("<b><font color='blue'>") + info + QString(" </font></b>"));
};
void QmitkMatchPointFrameCorrection::OnAlgorithmInfo(QString info)
{
m_Controls.m_teLog->append(QString("<font color='gray'><i>") + info + QString("</i></font>"));
};
void QmitkMatchPointFrameCorrection::OnFrameProcessed(double progress)
{
- m_Controls.m_teLog->append(QString("<b><font color='blue'>Frame processed...</font></b>"));
+ m_Controls.m_teLog->append(QStringLiteral("<b><font color='blue'>Frame processed...</font></b>"));
m_Controls.m_progBarFrame->setValue(100 * progress);
};
void QmitkMatchPointFrameCorrection::OnFrameRegistered(double progress)
{
- m_Controls.m_teLog->append(QString("<b><font color='blue'>Frame registered...</font></b>"));
+ m_Controls.m_teLog->append(QStringLiteral("<b><font color='blue'>Frame registered...</font></b>"));
m_Controls.m_progBarFrame->setValue(100 * progress);
};
void QmitkMatchPointFrameCorrection::OnFrameMapped(double progress)
{
- m_Controls.m_teLog->append(QString("<b><font color='blue'>Frame mapped...</font></b>"));
+ m_Controls.m_teLog->append(QStringLiteral("<b><font color='blue'>Frame mapped...</font></b>"));
m_Controls.m_progBarFrame->setValue(100 * progress);
};
void QmitkMatchPointFrameCorrection::OnAlgorithmSelectionChanged(const
berry::IWorkbenchPart::Pointer& sourcepart,
const berry::ISelection::ConstPointer& selection)
{
// check for null selection
if (selection.IsNull())
{
return;
}
if (sourcepart != this)
{
UpdateAlgorithmSelection(selection);
}
}
void QmitkMatchPointFrameCorrection::UpdateAlgorithmSelection(berry::ISelection::ConstPointer
selection)
{
mitk::MAPAlgorithmInfoSelection::ConstPointer currentSelection =
selection.Cast<const mitk::MAPAlgorithmInfoSelection>();
if (currentSelection)
{
mitk::MAPAlgorithmInfoSelection::AlgorithmInfoVectorType infoVector =
currentSelection->GetSelectedAlgorithmInfo();
if (!infoVector.empty())
{
// only the first selection is of interest, the rest will be skipped.
this->m_SelectedAlgorithmInfo = infoVector[0];
}
}
this->OnSelectedAlgorithmChanged();
};
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrectionControls.ui b/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrectionControls.ui
index ac3def2fb2..6fd2592009 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrectionControls.ui
+++ b/Plugins/org.mitk.gui.qt.matchpoint.framereg/src/internal/QmitkMatchPointFrameCorrectionControls.ui
@@ -1,636 +1,636 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MatchPointFrameCorrectionControls</class>
<widget class="QWidget" name="MatchPointFrameCorrectionControls">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>348</width>
<height>850</height>
</rect>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<property name="spacing">
<number>5</number>
</property>
<property name="leftMargin">
<number>5</number>
</property>
<property name="topMargin">
<number>5</number>
</property>
<property name="rightMargin">
<number>5</number>
</property>
<property name="bottomMargin">
<number>5</number>
</property>
<item>
<widget class="QLabel" name="label_4">
<property name="text">
<string>Loaded algorithm:</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_lbLoadedAlgorithmName">
<property name="maximumSize">
<size>
<width>400</width>
<height>16777215</height>
</size>
</property>
<property name="palette">
<palette>
<active>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>0</red>
<green>170</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
<colorrole role="PlaceholderText">
<brush brushstyle="NoBrush">
<color alpha="128">
<red>0</red>
<green>170</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
</active>
<inactive>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>0</red>
<green>170</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
<colorrole role="PlaceholderText">
<brush brushstyle="NoBrush">
<color alpha="128">
<red>0</red>
<green>170</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
</inactive>
<disabled>
<colorrole role="Text">
<brush brushstyle="SolidPattern">
<color alpha="255">
<red>159</red>
<green>158</green>
<blue>158</blue>
</color>
</brush>
</colorrole>
<colorrole role="PlaceholderText">
<brush brushstyle="NoBrush">
<color alpha="128">
<red>0</red>
<green>170</green>
<blue>0</blue>
</color>
</brush>
</colorrole>
</disabled>
</palette>
</property>
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="lineWidth">
<number>2</number>
</property>
<property name="midLineWidth">
<number>1</number>
</property>
<property name="text">
<string/>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_5">
<property name="text">
<string>Image:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkSingleNodeSelectionWidget" name="imageNodeSelector" native="true">
<property name="minimumSize">
<size>
<width>0</width>
<height>40</height>
</size>
</property>
</widget>
</item>
<item>
- <widget class="QLabel" name="label_6">
+ <widget class="QLabel" name="label_TargetMask">
<property name="text">
<string>Target mask:</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkSingleNodeSelectionWidget" name="maskNodeSelector" native="true">
<property name="minimumSize">
<size>
<width>0</width>
<height>40</height>
</size>
</property>
</widget>
</item>
<item>
<widget class="QTabWidget" name="m_tabs">
<property name="enabled">
<bool>true</bool>
</property>
<property name="minimumSize">
<size>
<width>200</width>
<height>0</height>
</size>
</property>
<property name="currentIndex">
- <number>0</number>
+ <number>2</number>
</property>
<property name="documentMode">
<bool>false</bool>
</property>
<property name="tabsClosable">
<bool>false</bool>
</property>
<property name="movable">
<bool>false</bool>
</property>
<widget class="QWidget" name="m_tabSelection">
<attribute name="title">
<string>Selection</string>
</attribute>
<layout class="QGridLayout" name="gridLayout_2">
<property name="leftMargin">
<number>5</number>
</property>
<property name="topMargin">
<number>5</number>
</property>
<property name="rightMargin">
<number>5</number>
</property>
<property name="bottomMargin">
<number>5</number>
</property>
<property name="spacing">
<number>5</number>
</property>
<item row="0" column="0">
<widget class="QLabel" name="label_Heading1">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Load an algorithm</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_algo">
<property name="text">
<string>Algorithm browser selection:</string>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QPushButton" name="m_pbLoadSelected">
<property name="text">
<string>Load selected algorithm</string>
</property>
</widget>
</item>
<item row="4" column="0">
<widget class="QLabel" name="label_algoInfo">
<property name="enabled">
<bool>true</bool>
</property>
<property name="autoFillBackground">
<bool>false</bool>
</property>
<property name="text">
<string>Selected algorithm information:</string>
</property>
<property name="wordWrap">
<bool>true</bool>
</property>
<property name="margin">
<number>0</number>
</property>
<property name="indent">
<number>-1</number>
</property>
</widget>
</item>
<item row="5" column="0">
<widget class="QmitkAlgorithmProfileViewer" name="m_teAlgorithmDetails" native="true"/>
</item>
<item row="2" column="0">
<widget class="QLabel" name="m_lbSelectedAlgorithm">
<property name="frameShape">
<enum>QFrame::StyledPanel</enum>
</property>
<property name="lineWidth">
<number>2</number>
</property>
<property name="midLineWidth">
<number>1</number>
</property>
<property name="text">
<string>TextLabel</string>
</property>
</widget>
</item>
</layout>
<zorder>label_Heading1</zorder>
<zorder>m_teAlgorithmDetails</zorder>
<zorder>label_algo</zorder>
<zorder>label_algoInfo</zorder>
<zorder>m_pbLoadSelected</zorder>
<zorder>m_lbSelectedAlgorithm</zorder>
</widget>
<widget class="QWidget" name="m_tabExecution">
<attribute name="title">
<string>Execution</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_2">
<property name="spacing">
<number>5</number>
</property>
<property name="leftMargin">
<number>5</number>
</property>
<property name="topMargin">
<number>5</number>
</property>
<property name="rightMargin">
<number>5</number>
</property>
<property name="bottomMargin">
<number>5</number>
</property>
<item>
<widget class="QLabel" name="label_Heading3">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="Maximum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Perform frame correction</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_9">
<property name="text">
<string>Correction job name:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="m_leRegJobName">
<property name="toolTip">
<string>Name of the resulting mapped image</string>
</property>
<property name="text">
<string>Unnamed RegJob</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<widget class="QPushButton" name="m_pbStartReg">
<property name="text">
<string>Start</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QGroupBox" name="groupBox">
<property name="sizePolicy">
<sizepolicy hsizetype="Preferred" vsizetype="MinimumExpanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="title">
<string>Progress</string>
</property>
<property name="flat">
<bool>false</bool>
</property>
<layout class="QVBoxLayout" name="verticalLayout_3">
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string>Frames:</string>
</property>
</widget>
</item>
<item>
<widget class="QProgressBar" name="m_progBarFrame">
<property name="value">
<number>24</number>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_lbProgBarLevel">
<property name="text">
<string>Resolution level:</string>
</property>
</widget>
</item>
<item>
<widget class="QProgressBar" name="m_progBarLevel">
<property name="maximum">
<number>100</number>
</property>
<property name="value">
<number>24</number>
</property>
<property name="invertedAppearance">
<bool>false</bool>
</property>
<property name="format">
<string>%v/%m</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="m_lbProgBarIteration">
<property name="text">
<string>Iterations:</string>
</property>
</widget>
</item>
<item>
<widget class="QProgressBar" name="m_progBarIteration">
<property name="maximum">
<number>100</number>
</property>
<property name="value">
<number>24</number>
</property>
<property name="invertedAppearance">
<bool>false</bool>
</property>
<property name="format">
<string>%p% (%v/%m)</string>
</property>
</widget>
</item>
<item>
<widget class="QLabel" name="label_log">
<property name="text">
<string>Log:</string>
</property>
</widget>
</item>
<item>
<widget class="QTextEdit" name="m_teLog">
<property name="sizePolicy">
<sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="font">
<font>
<pointsize>9</pointsize>
</font>
</property>
<property name="verticalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOn</enum>
</property>
<property name="tabChangesFocus">
<bool>true</bool>
</property>
<property name="lineWrapMode">
<enum>QTextEdit::NoWrap</enum>
</property>
<property name="readOnly">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QCheckBox" name="m_checkClearLog">
<property name="text">
<string>Clear log on algorithm start</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_pbSaveLog">
<property name="text">
<string>Save log to file</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="m_tabSettings">
<attribute name="title">
<string>Settings</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_4">
<property name="spacing">
<number>5</number>
</property>
<property name="leftMargin">
<number>5</number>
</property>
<property name="topMargin">
<number>5</number>
</property>
<property name="rightMargin">
<number>5</number>
</property>
<property name="bottomMargin">
<number>5</number>
</property>
<item>
<widget class="QLabel" name="label_2">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Configure mapping parameters</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkMapperSettingsWidget" name="m_mapperSettings" native="true"/>
</item>
<item>
<widget class="QLabel" name="label_Heading2">
<property name="font">
<font>
<weight>75</weight>
<bold>true</bold>
</font>
</property>
<property name="text">
<string>Configure algorithm parameters</string>
</property>
</widget>
</item>
<item>
<widget class="QmitkAlgorithmSettingsConfig" name="m_AlgoConfigurator" native="true">
<property name="sizePolicy">
<sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="minimumSize">
<size>
<width>250</width>
<height>0</height>
</size>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="m_tabExclusion">
<attribute name="title">
<string>Frame selection</string>
</attribute>
<layout class="QVBoxLayout" name="verticalLayout_6">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Select frames/timepoints that should be corrected:</string>
</property>
</widget>
</item>
<item>
<widget class="QListWidget" name="m_listFrames"/>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QPushButton" name="m_btnFrameSelAll">
<property name="text">
<string>Select all</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_btnFrameDeSelAll">
<property name="text">
<string>Deselect all</string>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="m_btnFrameInvert">
<property name="text">
<string>Invert</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</widget>
</item>
</layout>
</widget>
<customwidgets>
+ <customwidget>
+ <class>QmitkSingleNodeSelectionWidget</class>
+ <extends>QWidget</extends>
+ <header location="global">QmitkSingleNodeSelectionWidget.h</header>
+ <container>1</container>
+ </customwidget>
<customwidget>
<class>QmitkAlgorithmProfileViewer</class>
<extends>QWidget</extends>
<header>QmitkAlgorithmProfileViewer.h</header>
</customwidget>
<customwidget>
<class>QmitkAlgorithmSettingsConfig</class>
<extends>QWidget</extends>
<header>QmitkAlgorithmSettingsConfig.h</header>
</customwidget>
<customwidget>
<class>QmitkMapperSettingsWidget</class>
<extends>QWidget</extends>
<header>QmitkMapperSettingsWidget.h</header>
<container>1</container>
</customwidget>
- <customwidget>
- <class>QmitkSingleNodeSelectionWidget</class>
- <extends>QWidget</extends>
- <header location="global">QmitkSingleNodeSelectionWidget.h</header>
- <container>1</container>
- </customwidget>
</customwidgets>
<resources/>
<connections/>
<designerdata>
<property name="gridDeltaX">
<number>5</number>
</property>
<property name="gridDeltaY">
<number>5</number>
</property>
<property name="gridSnapX">
<bool>true</bool>
</property>
<property name="gridSnapY">
<bool>true</bool>
</property>
<property name="gridVisible">
<bool>true</bool>
</property>
</designerdata>
</ui>
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.cpp b/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.cpp
index a83619fb53..80f900fc02 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.mapper/src/internal/QmitkMatchPointMapper.cpp
@@ -1,582 +1,582 @@
/*============================================================================
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 "org_mitk_gui_qt_matchpoint_mapper_Activator.h"
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Mitk
#include <mitkImageAccessByItk.h>
#include <mitkStatusBar.h>
#include "mitkImageMappingHelper.h"
#include "mitkMAPRegistrationWrapper.h"
#include "mitkMatchPointPropertyTags.h"
#include "mitkRegistrationHelper.h"
#include <mitkResultNodeGenerationHelper.h>
#include <mitkUIDHelper.h>
#include <mitkAlgorithmHelper.h>
#include <mitkResultNodeGenerationHelper.h>
#include <mitkNodePredicateDataProperty.h>
#include <mitkNodePredicateFunction.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateOr.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateProperty.h>
// Qmitk
#include "QmitkMatchPointMapper.h"
// Qt
#include <QMessageBox>
#include <QFileDialog>
#include <QErrorMessage>
#include <QThreadPool>
const std::string QmitkMatchPointMapper::VIEW_ID = "org.mitk.views.matchpoint.mapper";
QmitkMatchPointMapper::QmitkMatchPointMapper()
: m_Parent(nullptr), m_preparedForBinaryInput(false)
{
}
void QmitkMatchPointMapper::SetFocus()
{
//m_Controls.buttonPerformImageProcessing->setFocus();
}
void QmitkMatchPointMapper::CreateConnections()
{
connect(m_Controls.registrationNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnRegNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.inputNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnInputNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.referenceNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnReferenceNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls.m_cbManualRef, SIGNAL(clicked()), this, SLOT(OnManualRefChecked()));
connect(m_Controls.m_cbLinkFactors, SIGNAL(clicked()), this, SLOT(OnLinkSampleFactorChecked()));
connect(m_Controls.m_sbXFactor, SIGNAL(valueChanged(double)), this, SLOT(OnXFactorChanged(double)));
connect(m_Controls.m_pbMap, SIGNAL(clicked()), this, SLOT(OnMapBtnPushed()));
connect(m_Controls.m_pbRefine, SIGNAL(clicked()), this, SLOT(OnRefineBtnPushed()));
}
void QmitkMatchPointMapper::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
- m_Controls.m_teLog->append(QString("<font color='red'><b>") + msg + QString("</b></font>"));
+ m_Controls.m_teLog->append(QStringLiteral("<font color='red'><b>") + msg + QStringLiteral("</b></font>"));
}
void QmitkMatchPointMapper::CreateQtPartControl(QWidget* parent)
{
// create GUI widgets from the Qt Designer's .ui file
m_Controls.setupUi(parent);
m_Parent = parent;
this->m_Controls.registrationNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.registrationNodeSelector->SetSelectionIsOptional(true);
this->m_Controls.inputNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.inputNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.referenceNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls.referenceNodeSelector->SetSelectionIsOptional(false);
this->m_Controls.registrationNodeSelector->SetInvalidInfo("Select valid registration.");
this->m_Controls.registrationNodeSelector->SetEmptyInfo("Assuming identity mapping. Select registration to change.");
this->m_Controls.registrationNodeSelector->SetPopUpTitel("Select registration.");
this->m_Controls.registrationNodeSelector->SetPopUpHint("Select a registration object that should be used for the mapping of the input data. If no registration is selected, identity will be assumed for the mapping.");
this->m_Controls.inputNodeSelector->SetInvalidInfo("Select input data.");
this->m_Controls.inputNodeSelector->SetPopUpTitel("Select input data.");
this->m_Controls.inputNodeSelector->SetPopUpHint("Select the input data for the mapping. (Images or point sets are supported so far).");
this->m_Controls.referenceNodeSelector->SetInvalidInfo("Select the reference image.");
this->m_Controls.referenceNodeSelector->SetPopUpTitel("Select the reference image.");
this->m_Controls.referenceNodeSelector->SetPopUpHint("Select the reference image that specifies the target geometrie the input should be mapped into.");
this->ConfigureRegNodePredicate();
this->ConfigureNodePredicates();
// show first page
m_Controls.m_tabs->setCurrentIndex(0);
this->CreateConnections();
this->CheckInputs();
this->ConfigureProgressInfos();
this->ConfigureMappingControls();
}
/** Method checks if the currently selected reg node has a direct kernel that
* can be decomposed in a rotation matrix and a offset. If this is true, true
* is returned. In all other cases false is returned.*/
bool QmitkMatchPointMapper::IsAbleToRefineGeometry() const
{
bool result = false;
if (this->m_spSelectedRegNode.IsNotNull())
{
const mitk::MAPRegistrationWrapper* wrapper = dynamic_cast<const mitk::MAPRegistrationWrapper*>
(this->m_spSelectedRegNode->GetData());
//if the helper does not return null, we can refine the geometry.
result = mitk::MITKRegistrationHelper::getAffineMatrix(wrapper, false).IsNotNull();
}
return result;
}
bool QmitkMatchPointMapper::IsBinaryInput() const
{
mitk::NodePredicateDataType::Pointer isLabelSet = mitk::NodePredicateDataType::New("LabelSetImage");
mitk::NodePredicateDataType::Pointer isImage = mitk::NodePredicateDataType::New("Image");
mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
mitk::NodePredicateAnd::Pointer isLegacyMask = mitk::NodePredicateAnd::New(isImage, isBinary);
mitk::NodePredicateOr::Pointer maskPredicate = mitk::NodePredicateOr::New(isLegacyMask, isLabelSet);
bool result = false;
if(this->m_spSelectedInputNode.IsNotNull())
{
result = maskPredicate->CheckNode(this->m_spSelectedInputNode);
}
return result;
}
bool QmitkMatchPointMapper::IsPointSetInput() const
{
bool result = false;
if (this->m_spSelectedInputNode.IsNotNull())
{
result = dynamic_cast<const mitk::PointSet*>(this->m_spSelectedInputNode->GetData()) != nullptr;
}
return result;
}
mitk::DataNode::Pointer QmitkMatchPointMapper::GetAutoRefNodeByReg()
{
mitk::DataNode::Pointer spResult = nullptr;
if (this->m_spSelectedRegNode.IsNotNull() && this->m_spSelectedRegNode->GetData())
{
std::string nodeName;
mitk::BaseProperty* uidProp = m_spSelectedRegNode->GetData()->GetProperty(mitk::Prop_RegAlgTargetData);
if (uidProp)
{
//search for the target node
mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
uidProp);
spResult = this->GetDataStorage()->GetNode(predicate);
}
}
if (spResult.IsNull() && this->m_spSelectedInputNode.IsNotNull())
{
//no really reference is available -> use the input as reference
spResult = this->m_spSelectedInputNode;
if (this->m_spSelectedRefNode != spResult)
{
m_Controls.m_teLog->append(
- QString("<font color='gray'><i>Cannot determine reference automatically. Use input image as reference.</i></font>"));
+ QStringLiteral("<font color='gray'><i>Cannot determine reference automatically. Use input image as reference.</i></font>"));
}
}
return spResult;
}
void QmitkMatchPointMapper::ConfigureRegNodePredicate(const mitk::DataNode* input)
{
mitk::NodePredicateBase::ConstPointer nodePredicate = mitk::MITKRegistrationHelper::RegNodePredicate();
if (input != nullptr)
{
unsigned int dimension = 0;
auto inputImage = dynamic_cast<mitk::Image*>(input->GetData());
auto pointset = dynamic_cast<const mitk::PointSet*>(input->GetData());
if (inputImage)
{
dimension = inputImage->GetDimension();
if (inputImage->GetTimeSteps() > 1)
{
//images has multiple time steps -> remove one dimension.
dimension -= 1;
}
}
else if (pointset)
{
dimension = 3;
}
auto dimCheck = [dimension](const mitk::DataNode * node)
{
const mitk::MAPRegistrationWrapper* wrapper = dynamic_cast < const mitk::MAPRegistrationWrapper* >(node->GetData());
return wrapper != nullptr && wrapper->GetMovingDimensions() == dimension;
};
mitk::NodePredicateFunction::Pointer hasCorrectDim = mitk::NodePredicateFunction::New(dimCheck);
nodePredicate = mitk::NodePredicateAnd::New(nodePredicate, hasCorrectDim).GetPointer();
}
this->m_Controls.registrationNodeSelector->SetNodePredicate(nodePredicate);
}
std::function<bool(const mitk::DataNode *)> GenerateDimCheckLambda(unsigned int dim)
{
auto dimCheck = [dim](const mitk::DataNode * node)
{
auto inputImage = dynamic_cast<mitk::Image*>(node->GetData());
return inputImage != nullptr &&
(inputImage->GetDimension() == dim ||
(inputImage->GetDimension() == dim + 1 && inputImage->GetTimeSteps()>1));
};
return dimCheck;
}
void QmitkMatchPointMapper::ConfigureNodePredicates(const mitk::DataNode* reg)
{
auto isImage = mitk::MITKRegistrationHelper::ImageNodePredicate();
auto isPointSet = mitk::MITKRegistrationHelper::PointSetNodePredicate();
auto isData = mitk::NodePredicateOr::New(isImage, isPointSet);
mitk::NodePredicateBase::ConstPointer inputPredicate = isData.GetPointer();
mitk::NodePredicateBase::ConstPointer refPredicate = isImage.GetPointer();
if (reg != nullptr)
{
const mitk::MAPRegistrationWrapper* wrapper = dynamic_cast <const mitk::MAPRegistrationWrapper*>(reg->GetData());
if (wrapper != nullptr)
{
auto movingDim = wrapper->GetMovingDimensions();
auto dimCheck = GenerateDimCheckLambda(movingDim);
auto hasCorrectDim = mitk::NodePredicateFunction::New(dimCheck);
if (movingDim == 3)
{
//Remark: Point sets are always 3D
auto is3DInput = mitk::NodePredicateOr::New(isPointSet, mitk::NodePredicateAnd::New(isImage, hasCorrectDim));
inputPredicate = is3DInput.GetPointer();
}
else
{
auto is2DInput = mitk::NodePredicateAnd::New(isImage, hasCorrectDim);
inputPredicate = is2DInput.GetPointer();
}
auto targetDim = wrapper->GetTargetDimensions();
auto targetDimCheck = GenerateDimCheckLambda(targetDim);
auto hasCorrectTargetDim = mitk::NodePredicateFunction::New(targetDimCheck);
auto isRef = mitk::NodePredicateAnd::New(isImage, hasCorrectTargetDim);
refPredicate = isRef;
}
}
this->m_Controls.inputNodeSelector->SetNodePredicate(inputPredicate);
this->m_Controls.referenceNodeSelector->SetNodePredicate(refPredicate);
}
void QmitkMatchPointMapper::CheckInputs()
{
this->m_spSelectedRegNode = this->m_Controls.registrationNodeSelector->GetSelectedNode();
this->m_spSelectedInputNode = this->m_Controls.inputNodeSelector->GetSelectedNode();
this->m_spSelectedRefNode = this->m_Controls.referenceNodeSelector->GetSelectedNode();
if (!(m_Controls.m_cbManualRef->isChecked()))
{
auto autoRefNode = this->GetAutoRefNodeByReg();
if (this->m_spSelectedRefNode != autoRefNode)
{
this->m_spSelectedRefNode = autoRefNode;
QmitkSingleNodeSelectionWidget::NodeList selection;
if (this->m_spSelectedRefNode.IsNotNull())
{
selection.append(this->m_spSelectedRefNode);
}
this->m_Controls.referenceNodeSelector->SetCurrentSelection(selection);
}
}
if (this->m_spSelectedRefNode.IsNotNull() && this->m_spSelectedRefNode->GetData()
&& this->m_spSelectedRefNode->GetData()->GetTimeSteps() > 1)
{
m_Controls.m_teLog->append(
- QString("<font color='gray'><i>Selected reference image has multiple time steps. Only geometry of time step 1 is used as reference.</i></font>"));
+ QStringLiteral("<font color='gray'><i>Selected reference image has multiple time steps. Only geometry of time step 1 is used as reference.</i></font>"));
}
}
void QmitkMatchPointMapper::ConfigureMappingControls()
{
bool validInput = m_spSelectedInputNode.IsNotNull();
bool validReg = m_spSelectedRegNode.IsNotNull();
bool validRef = m_spSelectedRefNode.IsNotNull();
this->m_Controls.referenceNodeSelector->setEnabled(this->m_Controls.m_cbManualRef->isChecked());
this->m_Controls.m_pbMap->setEnabled(validInput && validRef && validReg);
this->m_Controls.m_pbRefine->setEnabled(validInput && validReg
&& this->IsAbleToRefineGeometry() && !this->IsPointSetInput());
if (validInput && validReg)
{
this->m_Controls.m_leMappedName->setText(tr("mapped_by_") + QString::fromStdString(
m_spSelectedRegNode->GetName()));
}
else
{
this->m_Controls.m_leMappedName->setText(tr("mappedData"));
}
if (this->IsBinaryInput() != this->m_preparedForBinaryInput)
{
if (this->IsBinaryInput())
{
m_Controls.m_teLog->append(
- QString("<font color='gray'><i>Binary input (mask) detected. Preparing for mask mapping (default interpolation: nearest neigbour; padding value: 0)</i></font>"));
+ QStringLiteral("<font color='gray'><i>Binary input (mask) detected. Preparing for mask mapping (default interpolation: nearest neigbour; padding value: 0)</i></font>"));
this->m_Controls.m_comboInterpolator->setCurrentIndex(0);
this->m_Controls.m_sbErrorValue->setValue(0);
this->m_Controls.m_sbPaddingValue->setValue(0);
}
else
{
this->m_Controls.m_comboInterpolator->setCurrentIndex(1);
}
this->m_preparedForBinaryInput = this->IsBinaryInput();
}
OnLinkSampleFactorChecked();
}
void QmitkMatchPointMapper::ConfigureProgressInfos()
{
}
void QmitkMatchPointMapper::OnRegNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
{
mitk::DataNode::Pointer regNode;
if (!nodes.isEmpty())
{
regNode = nodes.front();
}
this->ConfigureNodePredicates(regNode);
this->CheckInputs();
this->ConfigureMappingControls();
}
void QmitkMatchPointMapper::OnInputNodeSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
{
mitk::DataNode::Pointer inputNode;
if (!nodes.isEmpty())
{
inputNode = nodes.front();
}
this->ConfigureRegNodePredicate(inputNode);
this->CheckInputs();
this->ConfigureMappingControls();
}
void QmitkMatchPointMapper::OnReferenceNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
{
this->CheckInputs();
this->ConfigureMappingControls();
}
void QmitkMatchPointMapper::OnManualRefChecked()
{
this->CheckInputs();
this->ConfigureMappingControls();
}
void QmitkMatchPointMapper::OnLinkSampleFactorChecked()
{
this->m_Controls.m_sbYFactor->setEnabled(!(this->m_Controls.m_cbLinkFactors->isChecked()));
this->m_Controls.m_sbZFactor->setEnabled(!(this->m_Controls.m_cbLinkFactors->isChecked()));
if (m_Controls.m_cbLinkFactors->isChecked())
{
this->m_Controls.m_sbYFactor->setValue(this->m_Controls.m_sbXFactor->value());
this->m_Controls.m_sbZFactor->setValue(this->m_Controls.m_sbXFactor->value());
}
}
void QmitkMatchPointMapper::OnMapBtnPushed()
{
SpawnMappingJob();
}
void QmitkMatchPointMapper::OnRefineBtnPushed()
{
SpawnMappingJob(true);
}
void QmitkMatchPointMapper::SpawnMappingJob(bool doGeometryRefinement)
{
if (m_Controls.m_checkClearLog->checkState() == Qt::Checked)
{
this->m_Controls.m_teLog->clear();
}
/////////////////////////
//create job and put it into the thread pool
QmitkMappingJob* pJob = new QmitkMappingJob();
pJob->setAutoDelete(true);
pJob->m_spInputData = this->m_spSelectedInputNode->GetData();
pJob->m_InputDataUID = mitk::EnsureUID(this->m_spSelectedInputNode->GetData());
pJob->m_doGeometryRefinement = doGeometryRefinement;
pJob->m_spRegNode = m_spSelectedRegNode;
if (m_spSelectedRegNode.IsNull())
{
pJob->m_spRegNode = mitk::DataNode::New();
pJob->m_spRegNode->SetData(mitk::GenerateIdentityRegistration3D().GetPointer());
pJob->m_spRegNode->SetName("Auto_Generated_Identity_Transform");
m_Controls.m_teLog->append(
- QString("<font color='gray'><i>No registration selected. Preforming mapping with identity transform</i></font>"));
+ QStringLiteral("<font color='gray'><i>No registration selected. Preforming mapping with identity transform</i></font>"));
}
if (!doGeometryRefinement)
{
pJob->m_spRefGeometry = m_spSelectedRefNode->GetData()->GetGeometry()->Clone().GetPointer();
//check for super/sub sampling
if (m_Controls.m_groupActivateSampling->isChecked())
{
//change the pixel count and spacing of the geometry
mitk::BaseGeometry::BoundsArrayType geoBounds = pJob->m_spRefGeometry->GetBounds();
auto oldSpacing = pJob->m_spRefGeometry->GetSpacing();
mitk::Vector3D geoSpacing;
geoSpacing[0] = oldSpacing[0] / m_Controls.m_sbXFactor->value();
geoSpacing[1] = oldSpacing[1] / m_Controls.m_sbYFactor->value();
geoSpacing[2] = oldSpacing[2] / m_Controls.m_sbZFactor->value();
geoBounds[1] = geoBounds[1] * m_Controls.m_sbXFactor->value();
geoBounds[3] = geoBounds[3] * m_Controls.m_sbYFactor->value();
geoBounds[5] = geoBounds[5] * m_Controls.m_sbZFactor->value();
pJob->m_spRefGeometry->SetBounds(geoBounds);
pJob->m_spRefGeometry->SetSpacing(geoSpacing);
auto oldOrigin = pJob->m_spRefGeometry->GetOrigin();
//if we change the spacing we must also correct the origin to ensure
//that the voxel matrix still covers the same space. This is due the fact
//that the origin is not in the corner of the voxel matrix, but in the center
// of the voxel that is in the corner.
mitk::Point3D newOrigin;
for (mitk::Point3D::SizeType i = 0; i < 3; ++i)
{
newOrigin[i] = 0.5* (geoSpacing[i] - oldSpacing[i]) + oldOrigin[i];
}
pJob->m_spRefGeometry->SetOrigin(newOrigin);
}
}
pJob->m_MappedName = m_Controls.m_leMappedName->text().toStdString();
pJob->m_allowUndefPixels = m_Controls.m_groupAllowUndefPixels->isChecked();
pJob->m_paddingValue = m_Controls.m_sbPaddingValue->value();
pJob->m_allowUnregPixels = m_Controls.m_groupAllowUnregPixels->isChecked();
pJob->m_errorValue = m_Controls.m_sbErrorValue->value();
pJob->m_InterpolatorLabel = m_Controls.m_comboInterpolator->currentText().toStdString();
switch (m_Controls.m_comboInterpolator->currentIndex())
{
case 0:
pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::NearestNeighbor;
break;
case 1:
pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::Linear;
break;
case 2:
pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::BSpline_3;
break;
case 3:
pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::WSinc_Hamming;
break;
case 4:
pJob->m_InterpolatorType = mitk::ImageMappingInterpolator::WSinc_Welch;
break;
}
connect(pJob, SIGNAL(Error(QString)), this, SLOT(OnMapJobError(QString)));
connect(pJob, SIGNAL(MapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)), this,
SLOT(OnMapResultIsAvailable(mitk::BaseData::Pointer, const QmitkMappingJob*)),
Qt::BlockingQueuedConnection);
connect(pJob, SIGNAL(AlgorithmInfo(QString)), this, SLOT(OnMappingInfo(QString)));
- m_Controls.m_teLog->append(QString("<b><font color='blue'>Started mapping job. Name: ") +
- m_Controls.m_leMappedName->text() + QString("</font></b>"));
+ m_Controls.m_teLog->append(QStringLiteral("<b><font color='blue'>Started mapping job. Name: ") +
+ m_Controls.m_leMappedName->text() + QStringLiteral("</font></b>"));
QThreadPool* threadPool = QThreadPool::globalInstance();
threadPool->start(pJob);
}
void QmitkMatchPointMapper::OnMapJobError(QString err)
{
Error(err);
}
void QmitkMatchPointMapper::OnMapResultIsAvailable(mitk::BaseData::Pointer spMappedData,
const QmitkMappingJob* job)
{
- m_Controls.m_teLog->append(QString("<b><font color='blue'>Mapped entity stored. Name: ") +
- QString::fromStdString(job->m_MappedName) + QString("</font></b>"));
+ m_Controls.m_teLog->append(QStringLiteral("<b><font color='blue'>Mapped entity stored. Name: ") +
+ QString::fromStdString(job->m_MappedName) + QStringLiteral("</font></b>"));
mitk::DataNode::Pointer spMappedNode = mitk::generateMappedResultNode(job->m_MappedName,
spMappedData, job->GetRegistration()->getRegistrationUID(), job->m_InputDataUID,
job->m_doGeometryRefinement, job->m_InterpolatorLabel);
this->GetDataStorage()->Add(spMappedNode);
this->GetRenderWindowPart()->RequestUpdate();
this->CheckInputs();
this->ConfigureMappingControls();
}
void QmitkMatchPointMapper::OnMappingInfo(QString info)
{
- m_Controls.m_teLog->append(QString("<font color='gray'><i>") + info + QString("</i></font>"));
+ m_Controls.m_teLog->append(QStringLiteral("<font color='gray'><i>") + info + QStringLiteral("</i></font>"));
}
void QmitkMatchPointMapper::OnXFactorChanged(double d)
{
if (m_Controls.m_cbLinkFactors->isChecked())
{
this->m_Controls.m_sbYFactor->setValue(d);
this->m_Controls.m_sbZFactor->setValue(d);
}
}
diff --git a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.cpp b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.cpp
index 52c2f6262b..35757719d6 100644
--- a/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.cpp
+++ b/Plugins/org.mitk.gui.qt.matchpoint.visualizer/src/internal/QmitkMatchPointRegistrationVisualizer.cpp
@@ -1,795 +1,795 @@
/*============================================================================
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 "org_mitk_gui_qt_matchpoint_visualizer_Activator.h"
// Blueberry
#include <berryISelectionService.h>
#include <berryIWorkbenchWindow.h>
// Mitk
#include <mitkStatusBar.h>
#include <mitkProperties.h>
#include <mitkColorProperty.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateDataProperty.h>
#include <mitkNodePredicateFunction.h>
#include "mitkRegVisDirectionProperty.h"
#include "mitkRegVisStyleProperty.h"
#include "mitkRegVisColorStyleProperty.h"
#include "mitkRegVisPropertyTags.h"
#include "mitkRegVisHelper.h"
#include "mitkMatchPointPropertyTags.h"
#include "mitkRegistrationHelper.h"
// Qmitk
#include "QmitkMatchPointRegistrationVisualizer.h"
// Qt
#include <QMessageBox>
#include <QErrorMessage>
const std::string QmitkMatchPointRegistrationVisualizer::VIEW_ID =
"org.mitk.views.matchpoint.visualizer";
QmitkMatchPointRegistrationVisualizer::QmitkMatchPointRegistrationVisualizer()
: m_Parent(nullptr), m_internalUpdateGuard(false), m_spSelectedFOVRefNode(nullptr),
m_spSelectedRegNode(nullptr)
{
}
void QmitkMatchPointRegistrationVisualizer::SetFocus()
{
}
void QmitkMatchPointRegistrationVisualizer::CreateConnections()
{
connect(m_Controls->registrationNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls->fovReferenceNodeSelector, SIGNAL(CurrentSelectionChanged(QList<mitk::DataNode::Pointer>)), this, SLOT(OnNodeSelectionChanged(QList<mitk::DataNode::Pointer>)));
connect(m_Controls->m_pbStyleGrid, SIGNAL(clicked()), this, SLOT(OnStyleButtonPushed()));
connect(m_Controls->m_pbStyleGlyph, SIGNAL(clicked()), this, SLOT(OnStyleButtonPushed()));
connect(m_Controls->m_pbStylePoints, SIGNAL(clicked()), this, SLOT(OnStyleButtonPushed()));
connect(m_Controls->m_comboDirection, SIGNAL(currentIndexChanged(int)), this,
SLOT(OnDirectionChanged(int)));
connect(m_Controls->m_pbUpdateViz, SIGNAL(clicked()), this, SLOT(OnUpdateBtnPushed()));
connect(m_Controls->radioColorUni, SIGNAL(toggled(bool)), m_Controls->btnUniColor,
SLOT(setEnabled(bool)));
connect(m_Controls->radioColorVecMag, SIGNAL(toggled(bool)), m_Controls->groupColorCoding,
SLOT(setEnabled(bool)));
connect(m_Controls->m_pbStyleGrid, SIGNAL(toggled(bool)), m_Controls->tabGrid,
SLOT(setEnabled(bool)));
connect(m_Controls->cbVevMagInterlolate, SIGNAL(toggled(bool)), this,
SLOT(OnColorInterpolationChecked(bool)));
connect(m_Controls->m_checkUseRefSize, SIGNAL(clicked()), this, SLOT(TransferFOVRefGeometry()));
connect(m_Controls->m_checkUseRefSpacing, SIGNAL(clicked()), this, SLOT(TransferFOVRefGeometry()));
connect(m_Controls->m_checkUseRefOrigin, SIGNAL(clicked()), this, SLOT(TransferFOVRefGeometry()));
connect(m_Controls->m_checkUseRefOrientation, SIGNAL(clicked()), this, SLOT(TransferFOVRefGeometry()));
}
void QmitkMatchPointRegistrationVisualizer::Error(QString msg)
{
mitk::StatusBar::GetInstance()->DisplayErrorText(msg.toLatin1());
MITK_ERROR << msg.toStdString().c_str();
}
void QmitkMatchPointRegistrationVisualizer::CreateQtPartControl(QWidget* parent)
{
m_Controls = new Ui::MatchPointRegVisControls;
// create GUI widgets from the Qt Designer's .ui file
m_Controls->setupUi(parent);
m_Parent = parent;
this->m_Controls->registrationNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls->registrationNodeSelector->SetSelectionIsOptional(false);
this->m_Controls->fovReferenceNodeSelector->SetDataStorage(this->GetDataStorage());
this->m_Controls->fovReferenceNodeSelector->SetSelectionIsOptional(false);
m_Controls->registrationNodeSelector->SetInvalidInfo("Select registration.");
m_Controls->registrationNodeSelector->SetPopUpTitel("Select registration.");
m_Controls->registrationNodeSelector->SetPopUpHint("Select the registration object whose registration visualization should be edited.");
m_Controls->fovReferenceNodeSelector->SetInvalidInfo("Select a FOV reference image.");
m_Controls->fovReferenceNodeSelector->SetPopUpTitel("Select a FOV reference image.");
m_Controls->fovReferenceNodeSelector->SetPopUpHint("Select the the image that should be used to define the field of view (FOV) for the registration visualization. The visualization will use the image geometry (size, orientation, spacing...).");
this->ConfigureNodePredicates();
this->m_Controls->btnVecMagColorSmall->setDisplayColorName(false);
this->m_Controls->btnVecMagColorMedium->setDisplayColorName(false);
this->m_Controls->btnVecMagColorLarge->setDisplayColorName(false);
this->m_Controls->btnVecMagColorNeg->setDisplayColorName(false);
this->m_Controls->btnUniColor->setDisplayColorName(false);
this->m_Controls->btnStartGridColor->setDisplayColorName(false);
this->CreateConnections();
this->m_Controls->radioColorUni->setChecked(false);
this->m_Controls->radioColorVecMag->setChecked(true);
this->CheckInputs();
this->LoadStateFromNode();
this->ConfigureVisualizationControls();
}
void QmitkMatchPointRegistrationVisualizer::ConfigureNodePredicates()
{
m_Controls->registrationNodeSelector->SetNodePredicate(mitk::MITKRegistrationHelper::RegNodePredicate());
auto geometryCheck = [](const mitk::DataNode * node)
{
return node->GetData() && node->GetData()->GetGeometry();
};
mitk::NodePredicateFunction::Pointer hasGeometry = mitk::NodePredicateFunction::New(geometryCheck);
auto nodePredicate = mitk::NodePredicateAnd::New(mitk::MITKRegistrationHelper::ImageNodePredicate().GetPointer(), hasGeometry.GetPointer());
m_Controls->fovReferenceNodeSelector->SetNodePredicate(nodePredicate.GetPointer());
}
mitk::MAPRegistrationWrapper* QmitkMatchPointRegistrationVisualizer::GetCurrentRegistration()
{
mitk::MAPRegistrationWrapper* result = nullptr;
if (this->m_spSelectedRegNode.IsNotNull())
{
result = dynamic_cast<mitk::MAPRegistrationWrapper*>(this->m_spSelectedRegNode->GetData());
assert(result);
}
return result;
}
mitk::DataNode::Pointer QmitkMatchPointRegistrationVisualizer::GetSelectedRegNode() const
{
return m_Controls->registrationNodeSelector->GetSelectedNode();
}
mitk::DataNode::Pointer QmitkMatchPointRegistrationVisualizer::GetRefNodeOfReg(bool target) const
{
mitk::DataNode::Pointer spResult = nullptr;
if (this->m_spSelectedRegNode.IsNotNull() && m_spSelectedRegNode->GetData())
{
std::string nodeName;
mitk::BaseProperty* uidProp;
if (target)
{
uidProp = m_spSelectedRegNode->GetData()->GetProperty(mitk::Prop_RegAlgTargetData);
}
else
{
uidProp = m_spSelectedRegNode->GetData()->GetProperty(mitk::Prop_RegAlgMovingData);
}
if (uidProp)
{
//search for the target node
mitk::NodePredicateDataProperty::Pointer predicate = mitk::NodePredicateDataProperty::New(mitk::Prop_UID,
uidProp);
spResult = this->GetDataStorage()->GetNode(predicate);
}
}
return spResult;
}
mitk::DataNode::Pointer QmitkMatchPointRegistrationVisualizer::GetSelectedDataNode()
{
return m_Controls->fovReferenceNodeSelector->GetSelectedNode();
}
void QmitkMatchPointRegistrationVisualizer::CheckInputs()
{
this->m_spSelectedRegNode = this->GetSelectedRegNode();
this->InitRegNode();
this->m_spSelectedFOVRefNode = this->GetSelectedDataNode();
}
void QmitkMatchPointRegistrationVisualizer::ConfigureVisualizationControls()
{
if (!m_internalUpdateGuard)
{
m_internalUpdateGuard = true;
m_Controls->groupViz->setVisible(this->m_spSelectedRegNode.IsNotNull());
m_Controls->m_pbUpdateViz->setEnabled(this->m_spSelectedRegNode.IsNotNull());
m_Controls->m_boxSettings->setEnabled(this->m_spSelectedRegNode.IsNotNull());
m_Controls->m_boxStyles->setEnabled(this->m_spSelectedRegNode.IsNotNull());
this->ActualizeRegInfo(this->GetCurrentRegistration());
this->m_Controls->m_checkUseRefSize->setEnabled(this->m_spSelectedRegNode.IsNotNull()
&& this->m_spSelectedFOVRefNode.IsNotNull());
this->m_Controls->m_checkUseRefOrigin->setEnabled(this->m_spSelectedRegNode.IsNotNull()
&& this->m_spSelectedFOVRefNode.IsNotNull());
this->m_Controls->m_checkUseRefSpacing->setEnabled(this->m_spSelectedRegNode.IsNotNull()
&& this->m_spSelectedFOVRefNode.IsNotNull());
m_internalUpdateGuard = false;
}
}
void QmitkMatchPointRegistrationVisualizer::StoreStateInNode()
{
if (this->m_spSelectedRegNode.IsNotNull())
{
//general
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisDirection,
mitk::RegVisDirectionProperty::New(this->m_Controls->m_comboDirection->currentIndex()));
this->m_spSelectedRegNode->SetBoolProperty(mitk::nodeProp_RegVisGrid,
this->m_Controls->m_pbStyleGrid->isChecked());
this->m_spSelectedRegNode->SetBoolProperty(mitk::nodeProp_RegVisGlyph,
this->m_Controls->m_pbStyleGlyph->isChecked());
this->m_spSelectedRegNode->SetBoolProperty(mitk::nodeProp_RegVisPoints,
this->m_Controls->m_pbStylePoints->isChecked());
//Visualization
if (this->m_Controls->radioColorUni->isChecked())
{
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisColorStyle,
mitk::RegVisColorStyleProperty::New(0));
}
else
{
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisColorStyle,
mitk::RegVisColorStyleProperty::New(1));
}
float tmpColor[3];
tmpColor[0] = this->m_Controls->btnUniColor->color().redF();
tmpColor[1] = this->m_Controls->btnUniColor->color().greenF();
tmpColor[2] = this->m_Controls->btnUniColor->color().blueF();
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorUni,
mitk::ColorProperty::New(tmpColor), nullptr, true);
tmpColor[0] = this->m_Controls->btnVecMagColorNeg->color().redF();
tmpColor[1] = this->m_Controls->btnVecMagColorNeg->color().greenF();
tmpColor[2] = this->m_Controls->btnVecMagColorNeg->color().blueF();
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor1Value,
mitk::ColorProperty::New(tmpColor), nullptr, true);
tmpColor[0] = this->m_Controls->btnVecMagColorSmall->color().redF();
tmpColor[1] = this->m_Controls->btnVecMagColorSmall->color().greenF();
tmpColor[2] = this->m_Controls->btnVecMagColorSmall->color().blueF();
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor2Value,
mitk::ColorProperty::New(tmpColor), nullptr, true);
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor2Magnitude,
mitk::DoubleProperty::New(this->m_Controls->sbVecMagSmall->value()), nullptr, true);
tmpColor[0] = this->m_Controls->btnVecMagColorMedium->color().redF();
tmpColor[1] = this->m_Controls->btnVecMagColorMedium->color().greenF();
tmpColor[2] = this->m_Controls->btnVecMagColorMedium->color().blueF();
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor3Value,
mitk::ColorProperty::New(tmpColor), nullptr, true);
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor3Magnitude,
mitk::DoubleProperty::New(this->m_Controls->sbVecMagMedium->value()), nullptr, true);
tmpColor[0] = this->m_Controls->btnVecMagColorLarge->color().redF();
tmpColor[1] = this->m_Controls->btnVecMagColorLarge->color().greenF();
tmpColor[2] = this->m_Controls->btnVecMagColorLarge->color().blueF();
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor4Value,
mitk::ColorProperty::New(tmpColor), nullptr, true);
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor4Magnitude,
mitk::DoubleProperty::New(this->m_Controls->sbVecMagLarge->value()), nullptr, true);
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorInterpolate,
mitk::BoolProperty::New(this->m_Controls->cbVevMagInterlolate->isChecked()), nullptr, true);
//Grid Settings
this->m_spSelectedRegNode->SetIntProperty(mitk::nodeProp_RegVisGridFrequence,
this->m_Controls->m_sbGridFrequency->value());
this->m_spSelectedRegNode->SetBoolProperty(mitk::nodeProp_RegVisGridShowStart,
this->m_Controls->m_groupShowStartGrid->isChecked());
tmpColor[0] = this->m_Controls->btnStartGridColor->color().redF();
tmpColor[1] = this->m_Controls->btnStartGridColor->color().greenF();
tmpColor[2] = this->m_Controls->btnStartGridColor->color().blueF();
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGridStartColor,
mitk::ColorProperty::New(tmpColor), nullptr, true);
//FOV
mitk::Vector3D value;
value[0] = this->m_Controls->m_sbFOVSizeX->value();
value[1] = this->m_Controls->m_sbFOVSizeY->value();
value[2] = this->m_Controls->m_sbFOVSizeZ->value();
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVSize,
mitk::Vector3DProperty::New(value));
value[0] = this->m_Controls->m_sbGridSpX->value();
value[1] = this->m_Controls->m_sbGridSpY->value();
value[2] = this->m_Controls->m_sbGridSpZ->value();
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVSpacing,
mitk::Vector3DProperty::New(value));
mitk::Point3D origin;
origin[0] = this->m_Controls->m_sbFOVOriginX->value();
origin[1] = this->m_Controls->m_sbFOVOriginY->value();
origin[2] = this->m_Controls->m_sbFOVOriginZ->value();
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVOrigin,
mitk::Point3dProperty::New(origin));
mitk::Vector3D orientationRow1;
mitk::Vector3D orientationRow2;
mitk::Vector3D orientationRow3;
orientationRow1.SetVnlVector(m_FOVRefOrientation.GetVnlMatrix().get_row(0));
orientationRow2.SetVnlVector(m_FOVRefOrientation.GetVnlMatrix().get_row(1));
orientationRow3.SetVnlVector(m_FOVRefOrientation.GetVnlMatrix().get_row(2));
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVOrientation1,
mitk::Vector3DProperty::New(orientationRow1));
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVOrientation2,
mitk::Vector3DProperty::New(orientationRow2));
this->m_spSelectedRegNode->SetProperty(mitk::nodeProp_RegVisFOVOrientation3,
mitk::Vector3DProperty::New(orientationRow3));
}
}
void QmitkMatchPointRegistrationVisualizer::LoadStateFromNode()
{
if (this->m_spSelectedRegNode.IsNotNull())
{
mitk::RegVisDirectionProperty* directionProp = nullptr;
if (this->m_spSelectedRegNode->GetProperty(directionProp, mitk::nodeProp_RegVisDirection))
{
this->m_Controls->m_comboDirection->setCurrentIndex(directionProp->GetValueAsId());
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisDirection) + QString(" has not the assumed type."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisDirection) + QStringLiteral(" has not the assumed type."));
}
bool styleActive = false;
if (this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisGrid, styleActive))
{
this->m_Controls->m_pbStyleGrid->setChecked(styleActive);
this->m_Controls->tabGrid->setEnabled(styleActive);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisGrid) + QString(" has not the assumed type."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisGrid) + QStringLiteral(" has not the assumed type."));
}
if (this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisGlyph, styleActive))
{
this->m_Controls->m_pbStyleGlyph->setChecked(styleActive);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisGlyph) + QString(" has not the assumed type."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisGlyph) + QStringLiteral(" has not the assumed type."));
}
if (this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisPoints, styleActive))
{
this->m_Controls->m_pbStylePoints->setChecked(styleActive);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisPoints) + QString(" has not the assumed type."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisPoints) + QStringLiteral(" has not the assumed type."));
}
///////////////////////////////////////////////////////
//visualization
mitk::RegVisColorStyleProperty* colorStyleProp = nullptr;
if (this->m_spSelectedRegNode->GetProperty(colorStyleProp, mitk::nodeProp_RegVisColorStyle))
{
this->m_Controls->radioColorUni->setChecked(colorStyleProp->GetValueAsId() == 0);
this->m_Controls->radioColorVecMag->setChecked(colorStyleProp->GetValueAsId() == 1);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisColorStyle) + QString(" has not the assumed type."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisColorStyle) + QStringLiteral(" has not the assumed type."));
}
QColor tmpColor;
float colorUni[3] = { 0.0, 0.0, 0.0 };
this->m_spSelectedRegNode->GetColor(colorUni, nullptr, mitk::nodeProp_RegVisColorUni);
tmpColor.setRgbF(colorUni[0], colorUni[1], colorUni[2]);
this->m_Controls->btnUniColor->setColor(tmpColor);
float color1[3] = { 0.0, 0.0, 0.0 };
this->m_spSelectedRegNode->GetColor(color1, nullptr, mitk::nodeProp_RegVisColor1Value);
tmpColor.setRgbF(color1[0], color1[1], color1[2]);
this->m_Controls->btnVecMagColorNeg->setColor(tmpColor);
float color2[3] = { 0.25, 0.25, 0.25 };
this->m_spSelectedRegNode->GetColor(color2, nullptr, mitk::nodeProp_RegVisColor2Value);
tmpColor.setRgbF(color2[0], color2[1], color2[2]);
this->m_Controls->btnVecMagColorSmall->setColor(tmpColor);
float color3[3] = { 0.5, 0.5, 0.5 };
this->m_spSelectedRegNode->GetColor(color3, nullptr, mitk::nodeProp_RegVisColor3Value);
tmpColor.setRgbF(color3[0], color3[1], color3[2]);
this->m_Controls->btnVecMagColorMedium->setColor(tmpColor);
float color4[3] = { 1.0, 1.0, 1.0 };
this->m_spSelectedRegNode->GetColor(color4, nullptr, mitk::nodeProp_RegVisColor4Value);
tmpColor.setRgbF(color4[0], color4[1], color4[2]);
this->m_Controls->btnVecMagColorLarge->setColor(tmpColor);
double mag2 = 0;
this->m_spSelectedRegNode->GetPropertyValue(mitk::nodeProp_RegVisColor2Magnitude, mag2);
double mag3 = 0;
this->m_spSelectedRegNode->GetPropertyValue(mitk::nodeProp_RegVisColor3Magnitude, mag3);
double mag4 = 0;
this->m_spSelectedRegNode->GetPropertyValue(mitk::nodeProp_RegVisColor4Magnitude, mag4);
bool interpolate = true;
this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisColorInterpolate, interpolate);
this->m_Controls->sbVecMagSmall->setValue(mag2);
this->m_Controls->sbVecMagMedium->setValue(mag3);
this->m_Controls->sbVecMagLarge->setValue(mag4);
this->m_Controls->cbVevMagInterlolate->setChecked(interpolate);
///////////////////////////////////////////////////////
//Grid general
bool showStart = false;
if (this->m_spSelectedRegNode->GetBoolProperty(mitk::nodeProp_RegVisGridShowStart, showStart))
{
this->m_Controls->m_groupShowStartGrid->setChecked(showStart);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisGridShowStart) + QString(" is not correctly defined."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisGridShowStart) + QStringLiteral(" is not correctly defined."));
}
int gridFrequ = 5;
if (this->m_spSelectedRegNode->GetIntProperty(mitk::nodeProp_RegVisGridFrequence, gridFrequ))
{
this->m_Controls->m_sbGridFrequency->setValue(gridFrequ);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisGridFrequence) + QString(" is not correctly defined."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisGridFrequence) + QStringLiteral(" is not correctly defined."));
}
float colorStart[3] = { 0.0, 0.0, 0.0 };
this->m_spSelectedRegNode->GetColor(colorStart, nullptr, mitk::nodeProp_RegVisGridStartColor);
tmpColor.setRgbF(colorStart[0], colorStart[1], colorStart[2]);
this->m_Controls->btnStartGridColor->setColor(tmpColor);
///////////////////////////////////////////////////////
//FOV
mitk::Vector3DProperty* valueProp = nullptr;
if (this->m_spSelectedRegNode->GetProperty(valueProp, mitk::nodeProp_RegVisFOVSize))
{
this->m_Controls->m_sbFOVSizeX->setValue(valueProp->GetValue()[0]);
this->m_Controls->m_sbFOVSizeY->setValue(valueProp->GetValue()[1]);
this->m_Controls->m_sbFOVSizeZ->setValue(valueProp->GetValue()[2]);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisFOVSize) + QString(" is not correctly defined."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisFOVSize) + QStringLiteral(" is not correctly defined."));
}
if (this->m_spSelectedRegNode->GetProperty(valueProp, mitk::nodeProp_RegVisFOVSpacing))
{
this->m_Controls->m_sbGridSpX->setValue(valueProp->GetValue()[0]);
this->m_Controls->m_sbGridSpY->setValue(valueProp->GetValue()[1]);
this->m_Controls->m_sbGridSpZ->setValue(valueProp->GetValue()[2]);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisFOVSpacing) + QString(" is not correctly defined."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisFOVSpacing) + QStringLiteral(" is not correctly defined."));
}
mitk::Point3dProperty* originProp = nullptr;
if (this->m_spSelectedRegNode->GetProperty(originProp, mitk::nodeProp_RegVisFOVOrigin))
{
this->m_Controls->m_sbFOVOriginX->setValue(originProp->GetValue()[0]);
this->m_Controls->m_sbFOVOriginY->setValue(originProp->GetValue()[1]);
this->m_Controls->m_sbFOVOriginZ->setValue(originProp->GetValue()[2]);
}
else
{
- this->Error(QString("Cannot configure plugin controlls correctly. Node property ") + QString(
- mitk::nodeProp_RegVisFOVOrigin) + QString(" is not correctly defined."));
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. Node property ") + QString(
+ mitk::nodeProp_RegVisFOVOrigin) + QStringLiteral(" is not correctly defined."));
}
mitk::Vector3DProperty* orientationProp1;
mitk::Vector3DProperty* orientationProp2;
mitk::Vector3DProperty* orientationProp3;
if (this->m_spSelectedRegNode->GetProperty(orientationProp1, mitk::nodeProp_RegVisFOVOrientation1) &&
this->m_spSelectedRegNode->GetProperty(orientationProp2, mitk::nodeProp_RegVisFOVOrientation2) &&
this->m_spSelectedRegNode->GetProperty(orientationProp3, mitk::nodeProp_RegVisFOVOrientation3))
{
this->m_Controls->m_sbFOVOriginX->setValue(originProp->GetValue()[0]);
this->m_Controls->m_sbFOVOriginY->setValue(originProp->GetValue()[1]);
this->m_Controls->m_sbFOVOriginZ->setValue(originProp->GetValue()[2]);
m_FOVRefOrientation.GetVnlMatrix().set_row(0, orientationProp1->GetValue().GetVnlVector());
m_FOVRefOrientation.GetVnlMatrix().set_row(1, orientationProp2->GetValue().GetVnlVector());
m_FOVRefOrientation.GetVnlMatrix().set_row(2, orientationProp3->GetValue().GetVnlVector());
}
else
{
m_FOVRefOrientation.SetIdentity();
- this->Error(QString("Cannot configure plugin controlls correctly. One of the node propertiesy ") +
+ this->Error(QStringLiteral("Cannot configure plugin controlls correctly. One of the node propertiesy ") +
QString(mitk::nodeProp_RegVisFOVOrientation1) + QString(mitk::nodeProp_RegVisFOVOrientation2) +
- QString(mitk::nodeProp_RegVisFOVOrientation3) + QString(" is not correctly defined."));
+ QString(mitk::nodeProp_RegVisFOVOrientation3) + QStringLiteral(" is not correctly defined."));
}
this->UpdateOrientationMatrixWidget();
}
}
void QmitkMatchPointRegistrationVisualizer::CheckAndSetDefaultFOVRef()
{
//check if node has a default reference node.
mitk::DataNode::Pointer defaultRef = this->GetRefNodeOfReg(
this->m_Controls->m_comboDirection->currentIndex() ==
1); //direction value 1 = show inverse mapping -> we need the target image used for the registration.
//if there is a default node and no m_spSelectedFOVRefNode is set -> set default node and transfer values
if (defaultRef.IsNotNull() && this->m_spSelectedFOVRefNode.IsNull())
{
//there is a default ref and no ref lock -> select default ref and transfer its values
this->m_spSelectedFOVRefNode = defaultRef;
QmitkSingleNodeSelectionWidget::NodeList selection({ defaultRef });
this->m_Controls->fovReferenceNodeSelector->SetCurrentSelection(selection);
this->m_Controls->m_checkUseRefSize->setChecked(true);
this->m_Controls->m_checkUseRefOrigin->setChecked(true);
this->m_Controls->m_checkUseRefSpacing->setChecked(true);
this->m_Controls->m_checkUseRefOrientation->setChecked(true);
}
if (this->m_spSelectedFOVRefNode.IsNotNull())
{
//auto transfere values
this->TransferFOVRefGeometry();
}
}
void QmitkMatchPointRegistrationVisualizer::OnNodeSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
{
this->CheckInputs();
this->LoadStateFromNode();
this->CheckAndSetDefaultFOVRef();
this->ConfigureVisualizationControls();
}
void QmitkMatchPointRegistrationVisualizer::ActualizeRegInfo(mitk::MAPRegistrationWrapper*
currentReg)
{
std::stringstream descriptionString;
m_Controls->m_teRegInfo->clear();
if (currentReg)
{
descriptionString << "Moving dimension: " << currentReg->GetMovingDimensions() << "<br/>";
descriptionString << "Target dimension: " << currentReg->GetTargetDimensions() << "<br/>";
descriptionString << "Limited moving representation: " <<
currentReg->HasLimitedMovingRepresentation() << "<br/>";
descriptionString << "Limited target representation: " <<
currentReg->HasLimitedTargetRepresentation() << "<br/>";
mitk::MAPRegistrationWrapper::TagMapType tagMap = currentReg->GetTags();
descriptionString << "<br/><b>Tags:</b><br/>";
for (mitk::MAPRegistrationWrapper::TagMapType::const_iterator pos = tagMap.begin();
pos != tagMap.end(); ++pos)
{
descriptionString << pos->first << " : " << pos->second << "<br/>";
}
}
else
{
descriptionString << "<font color='red'>no registration selected!</font>";
}
m_Controls->m_teRegInfo->insertHtml(QString::fromStdString(descriptionString.str()));
}
void QmitkMatchPointRegistrationVisualizer::OnDirectionChanged(int)
{
this->CheckAndSetDefaultFOVRef();
this->ConfigureVisualizationControls();
}
void QmitkMatchPointRegistrationVisualizer::OnUpdateBtnPushed()
{
this->StoreStateInNode();
mitk::Geometry3D::Pointer gridDesc;
unsigned int gridFrequ = 5;
mitk::GetGridGeometryFromNode(this->m_spSelectedRegNode, gridDesc, gridFrequ);
this->GetCurrentRegistration()->SetGeometry(gridDesc);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdateAll();
}
void QmitkMatchPointRegistrationVisualizer::OnStyleButtonPushed()
{
}
void QmitkMatchPointRegistrationVisualizer::OnColorInterpolationChecked(bool checked)
{
if (checked)
{
- this->m_Controls->labelVecMagSmall->setText(QString("="));
- this->m_Controls->labelVecMagMedium->setText(QString("="));
- this->m_Controls->labelVecMagLarge->setText(QString("="));
+ this->m_Controls->labelVecMagSmall->setText(QStringLiteral("="));
+ this->m_Controls->labelVecMagMedium->setText(QStringLiteral("="));
+ this->m_Controls->labelVecMagLarge->setText(QStringLiteral("="));
}
else
{
- this->m_Controls->labelVecMagSmall->setText(QString(">"));
- this->m_Controls->labelVecMagMedium->setText(QString(">"));
- this->m_Controls->labelVecMagLarge->setText(QString(">"));
+ this->m_Controls->labelVecMagSmall->setText(QStringLiteral(">"));
+ this->m_Controls->labelVecMagMedium->setText(QStringLiteral(">"));
+ this->m_Controls->labelVecMagLarge->setText(QStringLiteral(">"));
}
}
mitk::ScalarType QmitkMatchPointRegistrationVisualizer::GetSaveSpacing(mitk::ScalarType gridRes,
mitk::ScalarType spacing, unsigned int maxGridRes) const
{
mitk::ScalarType newSpacing = spacing;
mitk::ScalarType scaling = gridRes / maxGridRes;
if (scaling > 1.0)
{
newSpacing = spacing * scaling;
}
return newSpacing;
}
void QmitkMatchPointRegistrationVisualizer::TransferFOVRefGeometry()
{
if (this->m_spSelectedFOVRefNode.IsNotNull())
{
assert(this->m_spSelectedFOVRefNode->GetData());
assert(this->m_spSelectedFOVRefNode->GetData()->GetGeometry());
mitk::BaseGeometry* gridRef = this->m_spSelectedFOVRefNode->GetData()->GetGeometry();
mitk::Vector3D spacing = gridRef->GetSpacing();
mitk::Point3D origin = gridRef->GetOrigin();
mitk::Geometry3D::BoundsArrayType bounds = gridRef->GetBounds();
mitk::AffineTransform3D::ConstPointer fovTransform = gridRef->GetIndexToWorldTransform();
if (this->m_Controls->m_checkUseRefSize->isChecked())
{
this->m_Controls->m_sbFOVSizeX->setValue((bounds[1] - bounds[0])*spacing[0]);
this->m_Controls->m_sbFOVSizeY->setValue((bounds[3] - bounds[2])*spacing[1]);
this->m_Controls->m_sbFOVSizeZ->setValue((bounds[5] - bounds[4])*spacing[2]);
}
if (this->m_Controls->m_checkUseRefSpacing->isChecked())
{
this->m_Controls->m_sbGridSpX->setValue(GetSaveSpacing((bounds[1] - bounds[0]), spacing[0], 20));
this->m_Controls->m_sbGridSpY->setValue(GetSaveSpacing((bounds[3] - bounds[2]), spacing[1], 20));
this->m_Controls->m_sbGridSpZ->setValue(GetSaveSpacing((bounds[5] - bounds[4]), spacing[2], 20));
}
if (this->m_Controls->m_checkUseRefOrigin->isChecked())
{
this->m_Controls->m_sbFOVOriginX->setValue(origin[0]);
this->m_Controls->m_sbFOVOriginY->setValue(origin[1]);
this->m_Controls->m_sbFOVOriginZ->setValue(origin[2]);
}
if (this->m_Controls->m_checkUseRefOrientation->isChecked())
{
this->m_FOVRefOrientation = fovTransform->GetMatrix();
this->UpdateOrientationMatrixWidget();
}
}
}
void QmitkMatchPointRegistrationVisualizer::UpdateOrientationMatrixWidget()
{
for (unsigned int r = 0; r < 3; ++r)
{
for (unsigned int c = 0; c < 3; ++c)
{
this->m_Controls->m_tableOrientation->item(r,
c)->setText(QString::number(this->m_FOVRefOrientation.GetVnlMatrix().get(r, c)));
}
}
}
void QmitkMatchPointRegistrationVisualizer::InitRegNode()
{
if (this->m_spSelectedRegNode.IsNotNull())
{
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGrid, mitk::BoolProperty::New(true));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGlyph, mitk::BoolProperty::New(false));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisPoints, mitk::BoolProperty::New(false));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisDirection,
mitk::RegVisDirectionProperty::New());
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorStyle,
mitk::RegVisColorStyleProperty::New(1));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorUni, mitk::ColorProperty::New(0,
0.5, 0));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGridFrequence,
mitk::IntProperty::New(3));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGridShowStart,
mitk::BoolProperty::New(false));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisGridStartColor,
mitk::ColorProperty::New(0.5, 0, 0));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVSize,
mitk::Vector3DProperty::New(mitk::Vector3D(100.0)));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVSpacing,
mitk::Vector3DProperty::New(mitk::Vector3D(5.0)));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor1Value, mitk::ColorProperty::New(0,
0, 0.5));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor2Value, mitk::ColorProperty::New(0,
0.7, 0));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor2Magnitude,
mitk::DoubleProperty::New(1));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor3Value, mitk::ColorProperty::New(1,
1, 0));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor3Magnitude,
mitk::DoubleProperty::New(5));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor4Value, mitk::ColorProperty::New(1,
0, 0));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColor4Magnitude,
mitk::DoubleProperty::New(15));
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisColorInterpolate,
mitk::BoolProperty::New(true));
mitk::Point3D origin;
origin.Fill(0.0);
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVOrigin,
mitk::Point3dProperty::New(mitk::Point3D(origin)));
mitk::Vector3D vec(0.0);
vec.SetElement(0, 1.0);
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVOrientation1,
mitk::Vector3DProperty::New(vec));
vec.Fill(0.0);
vec.SetElement(1, 1.0);
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVOrientation2,
mitk::Vector3DProperty::New(vec));
vec.Fill(0.0);
vec.SetElement(2, 1.0);
this->m_spSelectedRegNode->AddProperty(mitk::nodeProp_RegVisFOVOrientation3,
mitk::Vector3DProperty::New(vec));
}
}