diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
index 3e556d7f77..5700679abe 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkMultiNodeSelectionWidget.cpp
@@ -1,272 +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)
{
if (this->isEnabled())
{
- m_Overlay->SetOverlayText(QString("<font class=\"normal\">") + m_EmptyInfo + QString("</font>"));
+ m_Overlay->SetOverlayText(QStringLiteral("<font class=\"normal\">") + m_EmptyInfo + QStringLiteral("</font>"));
}
else
{
- m_Overlay->SetOverlayText(QString("<font class=\"disabled\">") + m_EmptyInfo + QString("</font>"));
+ m_Overlay->SetOverlayText(QStringLiteral("<font class=\"disabled\">") + m_EmptyInfo + QStringLiteral("</font>"));
}
}
else
{
if (this->isEnabled())
{
- m_Overlay->SetOverlayText(QString("<font class=\"warning\">") + m_InvalidInfo + QString("</font>"));
+ m_Overlay->SetOverlayText(QStringLiteral("<font class=\"warning\">") + m_InvalidInfo + QStringLiteral("</font>"));
}
else
{
- m_Overlay->SetOverlayText(QString("<font class=\"disabled\">") + m_InvalidInfo + QString("</font>"));
+ 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.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp b/Plugins/org.mitk.gui.qt.datastorageviewertest/src/internal/QmitkDataStorageViewerTestView.cpp
index de255ca099..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,276 +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 67acaa8b43..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,720 +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.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));
}
}