diff --git a/Modules/QtWidgets/include/QmitkAutomatedLayoutWidget.h b/Modules/QtWidgets/include/QmitkAutomatedLayoutWidget.h
index 2b437496e5..b68c179731 100644
--- a/Modules/QtWidgets/include/QmitkAutomatedLayoutWidget.h
+++ b/Modules/QtWidgets/include/QmitkAutomatedLayoutWidget.h
@@ -1,43 +1,47 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkAutomatedLayoutDialog_h
#define QmitkAutomatedLayoutDialog_h
#include "MitkQtWidgetsExports.h"
#include "ui_QmitkAutomatedLayoutWidget.h"
-//#include <QmitkNodeSelectionDialog.h>
+#include "mitkDataStorage.h"
#include <qwidget.h>
class MITKQTWIDGETS_EXPORT QmitkAutomatedLayoutWidget : public QWidget
{
- Q_OBJECT
+ Q_OBJECT
private Q_SLOTS:
-
- void OnSelectDataClicked();
- void OnSetLayoutClicked();
- void OnSelectionDialogClosed();
+ void OnSetLayoutClicked();
+ void OnSelectionDialogClosed();
+
+Q_SIGNALS:
+ void SetDataBasedLayout(QmitkAbstractNodeSelectionWidget::NodeList nodes);
+
public:
- QmitkAutomatedLayoutWidget(QWidget* parent = nullptr);
+ QmitkAutomatedLayoutWidget(QWidget* parent = nullptr);
+ void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
private:
- Ui::QmitkAutomatedLayoutWidget m_Controls;
+ Ui::QmitkAutomatedLayoutWidget m_Controls;
+ mitk::DataStorage::Pointer m_DataStorage = nullptr;
};
-#endif
\ No newline at end of file
+#endif
diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h b/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
index 18bb853e67..009e90d34f 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetConfigurationToolBar.h
@@ -1,70 +1,73 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkMultiWidgetConfigurationToolBar_h
#define QmitkMultiWidgetConfigurationToolBar_h
#include "MitkQtWidgetsExports.h"
#include <mitkInteractionSchemeSwitcher.h>
+#include "mitkDataStorage.h"
#include <nlohmann/json.hpp>
// qt
#include <QToolBar>
class QmitkAbstractMultiWidget;
class QmitkMultiWidgetLayoutSelectionWidget;
/**
* @brief
*
*
*/
class MITKQTWIDGETS_EXPORT QmitkMultiWidgetConfigurationToolBar : public QToolBar
{
Q_OBJECT
public:
QmitkMultiWidgetConfigurationToolBar(QmitkAbstractMultiWidget* multiWidget);
~QmitkMultiWidgetConfigurationToolBar() override;
+ void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
Q_SIGNALS:
void LayoutSet(int row, int column);
void SaveLayout(std::ostream* outStream);
void LoadLayout(const nlohmann::json* jsonData);
+ void SetDataBasedLayout(QList<mitk::DataNode::Pointer> nodes);
void Synchronized(bool synchronized);
void InteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
protected Q_SLOTS:
void OnSetLayout();
void OnSynchronize();
void OnInteractionSchemeChanged();
private:
void InitializeToolBar();;
void AddButtons();
QmitkAbstractMultiWidget* m_MultiWidget;
QAction* m_SynchronizeAction;
QAction* m_InteractionSchemeChangeAction;
QmitkMultiWidgetLayoutSelectionWidget* m_LayoutSelectionPopup;
};
#endif
diff --git a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
index ee4f9db511..5b371453ca 100644
--- a/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
+++ b/Modules/QtWidgets/include/QmitkMultiWidgetLayoutSelectionWidget.h
@@ -1,68 +1,70 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkMultiWidgetLayoutSelectionWidget_h
#define QmitkMultiWidgetLayoutSelectionWidget_h
#include "MitkQtWidgetsExports.h"
#include "ui_QmitkMultiWidgetLayoutSelectionWidget.h"
#include "QmitkAutomatedLayoutWidget.h"
#include <nlohmann/json.hpp>
// qt
#include "QWidget"
/**
* @brief
*
*
*/
class MITKQTWIDGETS_EXPORT QmitkMultiWidgetLayoutSelectionWidget : public QWidget
{
Q_OBJECT
public:
QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent = nullptr);
+ void SetDataStorage(mitk::DataStorage::Pointer dataStorage);
Q_SIGNALS:
void LayoutSet(int row, int column);
+ void SetDataBasedLayout(QmitkAbstractNodeSelectionWidget::NodeList nodes);
// needs to be connected via Qt::DirectConnection (usually default), to ensure the stream pointers validity
void SaveLayout(std::ostream* outStream);
void LoadLayout(const nlohmann::json* jsonData);
private Q_SLOTS:
void OnTableItemSelectionChanged();
void OnSetLayoutButtonClicked();
void OnDataBasedLayoutButtonClicked();
void OnSaveLayoutButtonClicked();
void OnLoadLayoutButtonClicked();
void OnLayoutPresetSelected(int index);
private:
void Init();
Ui::QmitkMultiWidgetLayoutSelectionWidget ui;
std::map<int, nlohmann::json> m_PresetMap;
QmitkAutomatedLayoutWidget* m_AutomatedDataLayoutWidget;
};
#endif
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index 92d5e7a7b5..bc186f2d49 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,131 +1,133 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkMxNMultiWidget_h
#define QmitkMxNMultiWidget_h
#include "MitkQtWidgetsExports.h"
// qt widgets module
#include "QmitkAbstractMultiWidget.h"
#include <QmitkSynchronizedNodeSelectionWidget.h>
#include <QmitkSynchronizedWidgetConnector.h>
#include <nlohmann/json.hpp>
class QSplitter;
/**
* @brief The 'QmitkMxNMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
* Render windows can dynamically be added and removed to change the layout of the multi widget. This
* is done by using the 'SetLayout'-function to define a layout. This will automatically add or remove
* the appropriate number of render window widgets.
*/
class MITKQTWIDGETS_EXPORT QmitkMxNMultiWidget : public QmitkAbstractMultiWidget
{
Q_OBJECT
public:
QmitkMxNMultiWidget(QWidget* parent = nullptr,
Qt::WindowFlags f = {},
const QString& multiWidgetName = "mxn");
~QmitkMxNMultiWidget();
void InitializeMultiWidget() override;
void Synchronize(bool synchronized) override;
QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
/**
* @brief Initialize the active render windows of the MxNMultiWidget to the given geometry.
*
* @param geometry The geometry to be used to initialize / update the
* active render window's time and slice navigation controller.
* @param resetCamera If true, the camera and crosshair will be reset to the default view (centered, no zoom).
* If false, the current crosshair position and the camera zoom will be stored and reset
* after the reference geometry has been updated.
*/
void InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera) override;
/**
* @brief Forward the given time geometry to all base renderers, so that they can store it as their
* interaction reference geometry.
* This will update the alignment status of the reference geometry for each base renderer.
* For more details, see 'BaseRenderer::SetInteractionReferenceGeometry'.
* Overridem from 'QmitkAbstractMultiWidget'.
*/
void SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry) override;
/**
* @brief Returns true if the render windows are coupled; false if not.
*
* For the MxNMultiWidget the render windows are typically decoupled.
*/
bool HasCoupledRenderWindows() const override;
void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
void SetCrosshairVisibility(bool visible) override;
bool GetCrosshairVisibility() const override;
void SetCrosshairGap(unsigned int gapSize) override;
void ResetCrosshair() override;
void SetWidgetPlaneMode(int userMode) override;
mitk::SliceNavigationController* GetTimeNavigationController();
void EnableCrosshair();
void DisableCrosshair();
public Q_SLOTS:
// mouse events
void wheelEvent(QWheelEvent* e) override;
void mousePressEvent(QMouseEvent* e) override;
void moveEvent(QMoveEvent* e) override;
void LoadLayout(const nlohmann::json* jsonData);
void SaveLayout(std::ostream* outStream);
+ void SetDataBasedLayout(QmitkAbstractNodeSelectionWidget::NodeList nodes);
Q_SIGNALS:
void WheelMoved(QWheelEvent *);
void Moved();
void UpdateUtilityWidgetViewPlanes();
void LayoutChanged();
private:
void SetLayoutImpl() override;
void SetInteractionSchemeImpl() override { }
QmitkAbstractMultiWidget::RenderWindowWidgetPointer CreateRenderWindowWidget();
+ QmitkAbstractMultiWidget::RenderWindowWidgetPointer GetWindowFromIndex(size_t index);
void SetInitialSelection();
void ToggleSynchronization(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget);
static nlohmann::json BuildJSONFromLayout(const QSplitter* splitter);
QSplitter* BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter = nullptr);
std::unique_ptr<QmitkSynchronizedWidgetConnector> m_SynchronizedWidgetConnector;
bool m_CrosshairVisibility;
};
#endif
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
index 8df33517f5..3ae8f1fb18 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h
@@ -1,77 +1,79 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkRenderWindowUtilityWidget_h
#define QmitkRenderWindowUtilityWidget_h
#include "MitkQtWidgetsExports.h"
// qt widgets module
#include <QmitkSynchronizedNodeSelectionWidget.h>
#include <QmitkSliceNavigationWidget.h>
#include <QmitkStepperAdapter.h>
#include <mitkRenderWindowLayerController.h>
#include <mitkRenderWindowViewDirectionController.h>
// qt
#include <QWidget>
#include <QHBoxLayout>
#include <QMenuBar>
#include <QComboBox>
namespace mitk
{
class DataStorage;
}
class QmitkRenderWindow;
class MITKQTWIDGETS_EXPORT QmitkRenderWindowUtilityWidget : public QWidget
{
Q_OBJECT
public:
QmitkRenderWindowUtilityWidget(
QWidget* parent = nullptr,
QmitkRenderWindow* renderWindow = nullptr,
mitk::DataStorage* dataStorage = nullptr
);
~QmitkRenderWindowUtilityWidget() override;
void ToggleSynchronization(bool synchronized);
void SetGeometry(const itk::EventObject& event);
public Q_SLOTS:
void UpdateViewPlaneSelection();
Q_SIGNALS:
void SynchronizationToggled(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget);
+ void SetDataSelection(const QList<mitk::DataNode::Pointer> newSelection);
private:
mitk::BaseRenderer* m_BaseRenderer;
QmitkSynchronizedNodeSelectionWidget* m_NodeSelectionWidget;
+ QPushButton* m_SynchPushButton;
QmitkSliceNavigationWidget* m_SliceNavigationWidget;
QmitkStepperAdapter* m_StepperAdapter;
std::unique_ptr<mitk::RenderWindowLayerController> m_RenderWindowLayerController;
std::unique_ptr<mitk::RenderWindowViewDirectionController> m_RenderWindowViewDirectionController;
QComboBox* m_ViewDirectionSelector;
void ChangeViewDirection(const QString& viewDirection);
};
#endif
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
index 98f734fec0..ca0343a6ec 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h
@@ -1,123 +1,125 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkRenderWindowWidget_h
#define QmitkRenderWindowWidget_h
#include "MitkQtWidgetsExports.h"
// qt widgets module
#include <QmitkRenderWindow.h>
// mitk core
#include <mitkCrosshairManager.h>
#include <mitkDataStorage.h>
#include <mitkRenderWindow.h>
+#include "QmitkRenderWindowUtilityWidget.h"
// qt
#include <QFrame>
#include <QMouseEvent>
#include <QVBoxLayout>
class vtkCornerAnnotation;
/**
* @brief The 'QmitkRenderWindowWidget' is a QFrame that holds a render window
* and some associates properties, e.g. decorations.
* Decorations are corner annotation (text and color), frame color or background color
* and can be set using this class.
* The 'QmitkRenderWindowWidget' is used inside a 'QmitkAbstractMultiWidget', where a map contains
* several render window widgets to create the multi widget display.
* This class uses a CrosshairManager, which allows to use plane geometries as crosshair.
*/
class MITKQTWIDGETS_EXPORT QmitkRenderWindowWidget : public QFrame
{
Q_OBJECT
public:
QmitkRenderWindowWidget(
QWidget* parent = nullptr,
const QString& widgetName = "",
mitk::DataStorage* dataStorage = nullptr);
~QmitkRenderWindowWidget() override;
void SetDataStorage(mitk::DataStorage* dataStorage);
const QString& GetWidgetName() const { return m_WidgetName; };
QmitkRenderWindow* GetRenderWindow() const { return m_RenderWindow; };
mitk::SliceNavigationController* GetSliceNavigationController() const;
void RequestUpdate();
void ForceImmediateUpdate();
void AddUtilityWidget(QWidget* utilityWidget);
+ QmitkRenderWindowUtilityWidget* GetUtilityWidget();
void SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower);
void ShowGradientBackground(bool enable);
std::pair<mitk::Color, mitk::Color> GetGradientBackgroundColors() const { return m_GradientBackgroundColors; };
bool IsGradientBackgroundOn() const;
void SetDecorationColor(const mitk::Color& color);
mitk::Color GetDecorationColor() const { return m_DecorationColor; };
void ShowColoredRectangle(bool show);
bool IsColoredRectangleVisible() const;
void ShowCornerAnnotation(bool show);
bool IsCornerAnnotationVisible() const;
void SetCornerAnnotationText(const std::string& cornerAnnotation);
std::string GetCornerAnnotationText() const;
bool IsRenderWindowMenuActivated() const;
void SetCrosshairVisibility(bool visible);
bool GetCrosshairVisibility();
void SetCrosshairGap(unsigned int gapSize);
void EnableCrosshair();
void DisableCrosshair();
void SetCrosshairPosition(const mitk::Point3D& newPosition);
mitk::Point3D GetCrosshairPosition() const;
void SetGeometry(const itk::EventObject& event);
void SetGeometrySlice(const itk::EventObject& event);
public Q_SLOTS:
void OnResetGeometry();
private:
void InitializeGUI();
void InitializeDecorations();
void ResetGeometry(const mitk::TimeGeometry* referenceGeometry);
QString m_WidgetName;
QVBoxLayout* m_Layout;
mitk::DataStorage* m_DataStorage;
QmitkRenderWindow* m_RenderWindow;
mitk::CrosshairManager::Pointer m_CrosshairManager;
std::pair<mitk::Color, mitk::Color> m_GradientBackgroundColors;
mitk::Color m_DecorationColor;
vtkSmartPointer<vtkCornerAnnotation> m_CornerAnnotation;
};
#endif
diff --git a/Modules/QtWidgets/include/QmitkSynchronizedNodeSelectionWidget.h b/Modules/QtWidgets/include/QmitkSynchronizedNodeSelectionWidget.h
index 104403f81f..b1e9335396 100644
--- a/Modules/QtWidgets/include/QmitkSynchronizedNodeSelectionWidget.h
+++ b/Modules/QtWidgets/include/QmitkSynchronizedNodeSelectionWidget.h
@@ -1,103 +1,106 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkSynchronizedNodeSelectionWidget_h
#define QmitkSynchronizedNodeSelectionWidget_h
#include <MitkQtWidgetsExports.h>
#include "ui_QmitkSynchronizedNodeSelectionWidget.h"
// mitk core
#include <mitkBaseRenderer.h>
// qt widgets module
#include <QmitkAbstractNodeSelectionWidget.h>
#include <QmitkRenderWindowDataNodeTableModel.h>
/*
* @brief The 'QmitkSynchronizedNodeSelectionWidget' implements the 'QmitkAbstractNodeSelectionWidget'
* by providing a table view, using a 'QmitkRenderWindowDataNodeTableModel' and extending it
* with base renderer-specific functionality.
*
* Given a base renderer, the selection widget is able to display and access render window specific properties
* of the selected nodes, making it possible to switch between a "synchronized" and "desynchronized" selection
* state.
* The widget can be used to decide if all data nodes of the data storage should be selected or
* only an individually selected set of nodes, defined by a 'QmitkNodeSelectionDialog'.
* If individual nodes are selected / removed from the selection, the widget can inform other
* 'QmitkSynchronizedNodeSelectionWidget' about the current selection, if desired.
* Additionally the widget allows to reinitialize the corresponding base renderer with a specific
* data node geometry.
*/
class MITKQTWIDGETS_EXPORT QmitkSynchronizedNodeSelectionWidget : public QmitkAbstractNodeSelectionWidget
{
Q_OBJECT
public:
QmitkSynchronizedNodeSelectionWidget(QWidget* parent);
~QmitkSynchronizedNodeSelectionWidget();
using NodeList = QmitkAbstractNodeSelectionWidget::NodeList;
void SetBaseRenderer(mitk::BaseRenderer* baseRenderer);
void SetSelectAll(bool selectAll);
bool GetSelectAll() const;
void SelectAll();
void SetSynchronized(bool synchronize);
bool IsSynchronized() const;
Q_SIGNALS:
void SelectionModeChanged(bool selectAll);
void DeregisterSynchronization();
+public Q_SLOTS:
+ void SetSelection(const NodeList& newSelection);
+
private Q_SLOTS:
void OnModelUpdated();
void OnSelectionModeChanged(bool selectAll);
void OnEditSelection();
void OnTableClicked(const QModelIndex& index);
protected:
void SetUpConnections();
void Initialize();
void UpdateInfo() override;
void OnDataStorageChanged() override;
void OnNodePredicateChanged() override;
void ReviseSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection) override;
void OnInternalSelectionChanged() override;
bool AllowEmissionOfSelection(const NodeList& emissionCandidates) const override;
void OnNodeAddedToStorage(const mitk::DataNode* node) override;
void OnNodeModified(const itk::Object* caller, const itk::EventObject& event) override;
private:
void ReviseSynchronizedSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection);
void ReviseDesynchronizedSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection);
void ReinitNode(const mitk::DataNode* dataNode);
void RemoveFromInternalSelection(mitk::DataNode* dataNode);
bool IsParentNodeSelected(const mitk::DataNode* dataNode) const;
void DeselectNode(mitk::DataNode* dataNode);
Ui::QmitkSynchronizedNodeSelectionWidget m_Controls;
mitk::WeakPointer<mitk::BaseRenderer> m_BaseRenderer;
std::unique_ptr<QmitkRenderWindowDataNodeTableModel> m_StorageModel;
};
#endif
diff --git a/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.cpp b/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.cpp
index f8cbfc6a57..0bed3d7614 100644
--- a/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkAutomatedLayoutWidget.cpp
@@ -1,37 +1,48 @@
/*============================================================================
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 "QmitkAutomatedLayoutWidget.h"
-//#include <QmitkNodeSelec>
-
QmitkAutomatedLayoutWidget::QmitkAutomatedLayoutWidget(QWidget* parent)
{
- m_Controls.setupUi(this);
+ m_Controls.setupUi(this);
+
+ m_Controls.dataSelector->SetInvalidInfo(QStringLiteral("Please select images for the layout"));
+ m_Controls.dataSelector->SetPopUpTitel(QStringLiteral("Select input images"));
+ m_Controls.dataSelector->SetPopUpHint(QStringLiteral("Select as many images as you want to compare"));
- connect(m_Controls.dataSelector, &QmitkMultiNodeSelectionWidget::DialogClosed, this, &QmitkAutomatedLayoutWidget::OnSelectionDialogClosed);
+ m_Controls.setLayoutButton->setEnabled(false);
+
+ connect(m_Controls.dataSelector, &QmitkMultiNodeSelectionWidget::DialogClosed, this, &QmitkAutomatedLayoutWidget::OnSelectionDialogClosed);
+ connect(m_Controls.setLayoutButton, &QPushButton::clicked, this, &QmitkAutomatedLayoutWidget::OnSetLayoutClicked);
}
-void QmitkAutomatedLayoutWidget::OnSelectDataClicked()
+void QmitkAutomatedLayoutWidget::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
{
-
+ // smart pointer to data storage needs to be saved here because dataSelector makes it a regular pointer
+ m_DataStorage = dataStorage;
+ m_Controls.dataSelector->SetDataStorage(m_DataStorage);
}
void QmitkAutomatedLayoutWidget::OnSetLayoutClicked()
{
-
+ auto selectedNodes = m_Controls.dataSelector->GetSelectedNodes();
+ emit SetDataBasedLayout(selectedNodes);
+ this->hide();
}
void QmitkAutomatedLayoutWidget::OnSelectionDialogClosed()
{
- this->show();
+ bool setLayoutEnabled = m_Controls.dataSelector->GetSelectedNodes().size() > 0;
+ m_Controls.setLayoutButton->setEnabled(setLayoutEnabled);
+ this->show();
}
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
index 1987f7653f..2446476a64 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetConfigurationToolBar.cpp
@@ -1,111 +1,119 @@
/*============================================================================
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 "QmitkMultiWidgetConfigurationToolBar.h"
// mitk qt widgets module
#include "QmitkAbstractMultiWidget.h"
#include "QmitkMultiWidgetLayoutSelectionWidget.h"
QmitkMultiWidgetConfigurationToolBar::QmitkMultiWidgetConfigurationToolBar(QmitkAbstractMultiWidget* multiWidget)
: QToolBar(multiWidget)
, m_MultiWidget(multiWidget)
{
QToolBar::setOrientation(Qt::Vertical);
QToolBar::setIconSize(QSize(17, 17));
InitializeToolBar();
}
QmitkMultiWidgetConfigurationToolBar::~QmitkMultiWidgetConfigurationToolBar()
{
// nothing here
}
void QmitkMultiWidgetConfigurationToolBar::InitializeToolBar()
{
// create popup to show a widget to modify the multi widget layout
m_LayoutSelectionPopup = new QmitkMultiWidgetLayoutSelectionWidget(this);
m_LayoutSelectionPopup->hide();
AddButtons();
connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::LayoutSet, this, &QmitkMultiWidgetConfigurationToolBar::LayoutSet);
+ connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::SetDataBasedLayout, this, &QmitkMultiWidgetConfigurationToolBar::SetDataBasedLayout);
connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::SaveLayout, this, &QmitkMultiWidgetConfigurationToolBar::SaveLayout);
connect(m_LayoutSelectionPopup, &QmitkMultiWidgetLayoutSelectionWidget::LoadLayout, this, &QmitkMultiWidgetConfigurationToolBar::LoadLayout);
}
void QmitkMultiWidgetConfigurationToolBar::AddButtons()
{
QAction* setLayoutAction = new QAction(QIcon(":/Qmitk/mwLayout.png"), tr("Set multi widget layout"), this);
connect(setLayoutAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnSetLayout);
QToolBar::addAction(setLayoutAction);
m_SynchronizeAction = new QAction(QIcon(":/Qmitk/mwDesynchronized.png"), tr("Synchronize render windows"), this);
m_SynchronizeAction->setCheckable(true);
m_SynchronizeAction->setChecked(false);
connect(m_SynchronizeAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnSynchronize);
QToolBar::addAction(m_SynchronizeAction);
m_InteractionSchemeChangeAction = new QAction(QIcon(":/Qmitk/mwMITK.png"), tr("Change to PACS interaction"), this);
m_InteractionSchemeChangeAction->setCheckable(true);
m_InteractionSchemeChangeAction->setChecked(false);
connect(m_InteractionSchemeChangeAction, &QAction::triggered, this, &QmitkMultiWidgetConfigurationToolBar::OnInteractionSchemeChanged);
QToolBar::addAction(m_InteractionSchemeChangeAction);
}
+void QmitkMultiWidgetConfigurationToolBar::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
+{
+ if (m_LayoutSelectionPopup == nullptr)
+ return;
+ m_LayoutSelectionPopup->SetDataStorage(dataStorage);
+}
+
void QmitkMultiWidgetConfigurationToolBar::OnSetLayout()
{
if (nullptr != m_MultiWidget)
{
m_LayoutSelectionPopup->setWindowFlags(Qt::Popup);
m_LayoutSelectionPopup->move(this->cursor().pos().x() - m_LayoutSelectionPopup->width(), this->cursor().pos().y());
m_LayoutSelectionPopup->show();
}
}
void QmitkMultiWidgetConfigurationToolBar::OnSynchronize()
{
bool synchronized = m_SynchronizeAction->isChecked();
if (synchronized)
{
m_SynchronizeAction->setIcon(QIcon(":/Qmitk/mwSynchronized.png"));
m_SynchronizeAction->setText(tr("Desynchronize render windows"));
}
else
{
m_SynchronizeAction->setIcon(QIcon(":/Qmitk/mwDesynchronized.png"));
m_SynchronizeAction->setText(tr("Synchronize render windows"));
}
m_SynchronizeAction->setChecked(synchronized);
emit Synchronized(synchronized);
}
void QmitkMultiWidgetConfigurationToolBar::OnInteractionSchemeChanged()
{
bool PACSInteractionScheme = m_InteractionSchemeChangeAction->isChecked();
if (PACSInteractionScheme)
{
m_InteractionSchemeChangeAction->setIcon(QIcon(":/Qmitk/mwPACS.png"));
m_InteractionSchemeChangeAction->setText(tr("Change to MITK interaction"));
emit InteractionSchemeChanged(mitk::InteractionSchemeSwitcher::PACSStandard);
}
else
{
m_InteractionSchemeChangeAction->setIcon(QIcon(":/Qmitk/mwMITK.png"));
m_InteractionSchemeChangeAction->setText(tr("Change to PACS interaction"));
emit InteractionSchemeChanged(mitk::InteractionSchemeSwitcher::MITKStandard);
}
m_InteractionSchemeChangeAction->setChecked(PACSInteractionScheme);
}
diff --git a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
index 92d3de87fe..1e90051357 100644
--- a/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMultiWidgetLayoutSelectionWidget.cpp
@@ -1,150 +1,158 @@
/*============================================================================
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 "QmitkMultiWidgetLayoutSelectionWidget.h"
#include <QFileDialog>
#include <usGetModuleContext.h>
#include <usModuleContext.h>
#include <usModuleResource.h>
#include <usModuleResourceStream.h>
QmitkMultiWidgetLayoutSelectionWidget::QmitkMultiWidgetLayoutSelectionWidget(QWidget* parent/* = 0*/)
: QWidget(parent)
{
Init();
}
void QmitkMultiWidgetLayoutSelectionWidget::Init()
{
ui.setupUi(this);
auto stylesheet = "QTableWidget::item{background-color: white;}\nQTableWidget::item:selected{background-color: #1C97EA;}";
ui.tableWidget->setStyleSheet(stylesheet);
m_AutomatedDataLayoutWidget = new QmitkAutomatedLayoutWidget(this);
+ connect(m_AutomatedDataLayoutWidget, &QmitkAutomatedLayoutWidget::SetDataBasedLayout, this, &QmitkMultiWidgetLayoutSelectionWidget::SetDataBasedLayout);
m_AutomatedDataLayoutWidget->hide();
connect(ui.tableWidget, &QTableWidget::itemSelectionChanged, this, &QmitkMultiWidgetLayoutSelectionWidget::OnTableItemSelectionChanged);
connect(ui.setLayoutPushButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnSetLayoutButtonClicked);
connect(ui.dataBasedLayoutButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnDataBasedLayoutButtonClicked);
connect(ui.loadLayoutPushButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnLoadLayoutButtonClicked);
connect(ui.saveLayoutPushButton, &QPushButton::clicked, this, &QmitkMultiWidgetLayoutSelectionWidget::OnSaveLayoutButtonClicked);
connect(ui.selectDefaultLayoutComboBox, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &QmitkMultiWidgetLayoutSelectionWidget::OnLayoutPresetSelected);
ui.selectDefaultLayoutComboBox->addItem("Select a layout preset");
auto presetResources = us::GetModuleContext()->GetModule()->FindResources("/", "mxnLayout_*.json", false);
for (const auto& resource : presetResources)
{
us::ModuleResourceStream jsonStream(resource);
auto data = nlohmann::json::parse(jsonStream);
auto resourceName = data["name"].get<std::string>();
ui.selectDefaultLayoutComboBox->addItem(QString::fromStdString(resourceName));
m_PresetMap[ui.selectDefaultLayoutComboBox->count() - 1] = data;
}
}
+void QmitkMultiWidgetLayoutSelectionWidget::SetDataStorage(mitk::DataStorage::Pointer dataStorage)
+{
+ if (m_AutomatedDataLayoutWidget == nullptr)
+ return;
+ m_AutomatedDataLayoutWidget->SetDataStorage(dataStorage);
+}
+
void QmitkMultiWidgetLayoutSelectionWidget::OnTableItemSelectionChanged()
{
QItemSelectionModel* selectionModel = ui.tableWidget->selectionModel();
int row = 0;
int column = 0;
QModelIndexList indices = selectionModel->selectedIndexes();
if (indices.size() > 0)
{
row = indices[0].row();
column = indices[0].column();
QModelIndex topLeft = ui.tableWidget->model()->index(0, 0, QModelIndex());
QModelIndex bottomRight = ui.tableWidget->model()->index(row, column, QModelIndex());
QItemSelection cellSelection;
cellSelection.select(topLeft, bottomRight);
selectionModel->select(cellSelection, QItemSelectionModel::Select);
}
}
void QmitkMultiWidgetLayoutSelectionWidget::OnSetLayoutButtonClicked()
{
int row = 0;
int column = 0;
QModelIndexList indices = ui.tableWidget->selectionModel()->selectedIndexes();
if (indices.size() > 0)
{
// find largest row and column
for (const auto& modelIndex : std::as_const(indices))
{
if (modelIndex.row() > row)
{
row = modelIndex.row();
}
if (modelIndex.column() > column)
{
column = modelIndex.column();
}
}
close();
emit LayoutSet(row+1, column+1);
}
ui.selectDefaultLayoutComboBox->setCurrentIndex(0);
}
void QmitkMultiWidgetLayoutSelectionWidget::OnDataBasedLayoutButtonClicked()
{
this->hide();
m_AutomatedDataLayoutWidget->setWindowFlags(Qt::Popup);
m_AutomatedDataLayoutWidget->move(this->pos().x() - m_AutomatedDataLayoutWidget->width() + this->width(), this->pos().y());
m_AutomatedDataLayoutWidget->show();
}
void QmitkMultiWidgetLayoutSelectionWidget::OnSaveLayoutButtonClicked()
{
QString filename = QFileDialog::getSaveFileName(nullptr, "Select where to save the current layout", "", "MITK Window Layout (*.json)");
if (filename.isEmpty())
return;
QString fileExt(".json");
if (!filename.endsWith(fileExt))
filename += fileExt;
auto outStream = std::ofstream(filename.toStdString());
emit SaveLayout(&outStream);
}
void QmitkMultiWidgetLayoutSelectionWidget::OnLoadLayoutButtonClicked()
{
QString filename = QFileDialog::getOpenFileName(nullptr, "Load a layout file", "", "MITK Window Layouts (*.json)");
if (filename.isEmpty())
return;
ui.selectDefaultLayoutComboBox->setCurrentIndex(0);
std::ifstream f(filename.toStdString());
auto jsonData = nlohmann::json::parse(f);
emit LoadLayout(&jsonData);
}
void QmitkMultiWidgetLayoutSelectionWidget::OnLayoutPresetSelected(int index)
{
if (index == 0)
{
// First entry is only for description
return;
}
auto jsonData = m_PresetMap[index];
close();
emit LoadLayout(&jsonData);
}
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index 55c15a1c4e..9db968ceb7 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,600 +1,649 @@
/*============================================================================
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 "QmitkMxNMultiWidget.h"
// mitk core
#include <mitkDisplayActionEventFunctions.h>
#include <mitkDisplayActionEventHandlerDesynchronized.h>
#include <mitkDisplayActionEventHandlerSynchronized.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateProperty.h>
// mitk qt widget
#include <QmitkRenderWindowUtilityWidget.h>
#include <QmitkRenderWindowWidget.h>
// qt
#include <QGridLayout>
#include <QMessageBox>
#include <QSplitter>
#include <fstream>
QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
Qt::WindowFlags f/* = 0*/,
const QString& multiWidgetName/* = "mxn"*/)
: QmitkAbstractMultiWidget(parent, f, multiWidgetName)
, m_SynchronizedWidgetConnector(std::make_unique<QmitkSynchronizedWidgetConnector>())
, m_CrosshairVisibility(false)
{
}
QmitkMxNMultiWidget::~QmitkMxNMultiWidget()
{
}
void QmitkMxNMultiWidget::InitializeMultiWidget()
{
SetLayout(1, 1);
SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
auto displayActionEventHandler = GetDisplayActionEventHandler();
if (nullptr != displayActionEventHandler)
{
displayActionEventHandler->InitActions();
}
this->SetInitialSelection();
}
void QmitkMxNMultiWidget::Synchronize(bool synchronized)
{
if (synchronized)
{
SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerSynchronized>());
}
else
{
SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
}
auto displayActionEventHandler = GetDisplayActionEventHandler();
if (nullptr != displayActionEventHandler)
{
displayActionEventHandler->InitActions();
}
}
QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
{
if ("axial" == widgetName || "sagittal" == widgetName || "coronal" == widgetName || "3d" == widgetName)
{
return GetActiveRenderWindowWidget()->GetRenderWindow();
}
return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
}
QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::AnatomicalPlane& /*orientation*/) const
{
// currently no mapping between plane orientation and render windows
// simply return the currently active render window
return GetActiveRenderWindowWidget()->GetRenderWindow();
}
void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
{
auto currentActiveRenderWindowWidget = GetActiveRenderWindowWidget();
if (currentActiveRenderWindowWidget == activeRenderWindowWidget)
{
return;
}
// reset the decoration color of the previously active render window widget
if (nullptr != currentActiveRenderWindowWidget)
{
auto decorationColor = currentActiveRenderWindowWidget->GetDecorationColor();
QColor hexColor(decorationColor[0] * 255, decorationColor[1] * 255, decorationColor[2] * 255);
currentActiveRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " +
hexColor.name(QColor::HexRgb) + "; }");
}
// set the new decoration color of the currently active render window widget
if (nullptr != activeRenderWindowWidget)
{
activeRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid #FF6464; }");
}
QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(activeRenderWindowWidget);
}
void QmitkMxNMultiWidget::InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera)
{
auto* renderingManager = mitk::RenderingManager::GetInstance();
mitk::Point3D currentPosition = mitk::Point3D();
unsigned int imageTimeStep = 0;
if (!resetCamera)
{
// store the current position to set it again later, if the camera should not be reset
currentPosition = this->GetSelectedPosition("");
// store the current time step to set it again later, if the camera should not be reset
const mitk::TimePointType currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
if (geometry->IsValidTimePoint(currentTimePoint))
{
imageTimeStep = geometry->TimePointToTimeStep(currentTimePoint);
}
}
// initialize active render window
renderingManager->InitializeView(
this->GetActiveRenderWindowWidget()->GetRenderWindow()->GetVtkRenderWindow(), geometry, resetCamera);
if (!resetCamera)
{
this->SetSelectedPosition(currentPosition, "");
renderingManager->GetTimeNavigationController()->GetStepper()->SetPos(imageTimeStep);
}
}
void QmitkMxNMultiWidget::SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry)
{
// Set the interaction reference referenceGeometry for all render windows.
auto allRenderWindows = this->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
auto* baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow());
baseRenderer->SetInteractionReferenceGeometry(referenceGeometry);
}
}
bool QmitkMxNMultiWidget::HasCoupledRenderWindows() const
{
return false;
}
void QmitkMxNMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName)
{
RenderWindowWidgetPointer renderWindowWidget;
if (widgetName.isNull() || widgetName.isEmpty())
{
renderWindowWidget = GetActiveRenderWindowWidget();
}
else
{
renderWindowWidget = GetRenderWindowWidget(widgetName);
}
if (nullptr != renderWindowWidget)
{
renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
return;
}
MITK_ERROR << "Position can not be set for an unknown render window widget.";
}
const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& widgetName) const
{
RenderWindowWidgetPointer renderWindowWidget;
if (widgetName.isNull() || widgetName.isEmpty())
{
renderWindowWidget = GetActiveRenderWindowWidget();
}
else
{
renderWindowWidget = GetRenderWindowWidget(widgetName);
}
if (nullptr != renderWindowWidget)
{
return renderWindowWidget->GetCrosshairPosition();
}
MITK_ERROR << "Crosshair position can not be retrieved.";
return mitk::Point3D(0.0);
}
void QmitkMxNMultiWidget::SetCrosshairVisibility(bool visible)
{
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return;
}
auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
renderWindowWidget->SetCrosshairVisibility(visible);
}
bool QmitkMxNMultiWidget::GetCrosshairVisibility() const
{
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return false;
}
auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
return renderWindowWidget->GetCrosshairVisibility();
}
void QmitkMxNMultiWidget::SetCrosshairGap(unsigned int gapSize)
{
auto renderWindowWidgets = this->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : renderWindowWidgets)
{
renderWindowWidget.second->SetCrosshairGap(gapSize);
}
}
void QmitkMxNMultiWidget::ResetCrosshair()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return;
}
mitk::RenderingManager::GetInstance()->InitializeViewByBoundingObjects(renderWindow->GetVtkRenderWindow(), dataStorage);
SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
}
void QmitkMxNMultiWidget::SetWidgetPlaneMode(int userMode)
{
MITK_DEBUG << "Changing crosshair mode to " << userMode;
switch (userMode)
{
case 0:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKStandard);
break;
case 1:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationUncoupled);
break;
case 2:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKRotationCoupled);
break;
case 3:
SetInteractionScheme(mitk::InteractionSchemeSwitcher::MITKSwivel);
break;
}
}
void QmitkMxNMultiWidget::EnableCrosshair()
{
auto renderWindowWidgets = this->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : renderWindowWidgets)
{
renderWindowWidget.second->EnableCrosshair();
}
}
void QmitkMxNMultiWidget::DisableCrosshair()
{
auto renderWindowWidgets = this->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : renderWindowWidgets)
{
renderWindowWidget.second->DisableCrosshair();
}
}
//////////////////////////////////////////////////////////////////////////
// PUBLIC SLOTS
// MOUSE EVENTS
//////////////////////////////////////////////////////////////////////////
void QmitkMxNMultiWidget::wheelEvent(QWheelEvent* e)
{
emit WheelMoved(e);
}
void QmitkMxNMultiWidget::mousePressEvent(QMouseEvent*)
{
// nothing here, but necessary for mouse interactions (.xml-configuration files)
}
void QmitkMxNMultiWidget::moveEvent(QMoveEvent* e)
{
QWidget::moveEvent(e);
// it is necessary to readjust the position of the overlays as the MultiWidget has moved
// unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
emit Moved();
}
//////////////////////////////////////////////////////////////////////////
// PRIVATE
//////////////////////////////////////////////////////////////////////////
void QmitkMxNMultiWidget::SetLayoutImpl()
{
int requiredRenderWindowWidgets = GetRowCount() * GetColumnCount();
int existingRenderWindowWidgets = GetRenderWindowWidgets().size();
int difference = requiredRenderWindowWidgets - existingRenderWindowWidgets;
while (0 < difference)
{
// more render window widgets needed
CreateRenderWindowWidget();
--difference;
}
while (0 > difference)
{
// less render window widgets needed
RemoveRenderWindowWidget();
++difference;
}
auto firstRenderWindowWidget = GetFirstRenderWindowWidget();
if (nullptr != firstRenderWindowWidget)
{
SetActiveRenderWindowWidget(firstRenderWindowWidget);
}
GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
}
QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::CreateRenderWindowWidget()
{
// create the render window widget and connect signal / slot
QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets());
RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
auto renderWindow = renderWindowWidget->GetRenderWindow();
QmitkRenderWindowUtilityWidget* utilityWidget = new QmitkRenderWindowUtilityWidget(this, renderWindow, GetDataStorage());
renderWindowWidget->AddUtilityWidget(utilityWidget);
connect(utilityWidget, &QmitkRenderWindowUtilityWidget::SynchronizationToggled,
this, &QmitkMxNMultiWidget::ToggleSynchronization);
connect(this, &QmitkMxNMultiWidget::UpdateUtilityWidgetViewPlanes,
utilityWidget, &QmitkRenderWindowUtilityWidget::UpdateViewPlaneSelection);
// needs to be done after 'QmitkRenderWindowUtilityWidget::ToggleSynchronization' has been connected
// initially synchronize the node selection widget
utilityWidget->ToggleSynchronization(true);
auto layoutManager = GetMultiWidgetLayoutManager();
connect(renderWindow, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(renderWindow, &QmitkRenderWindow::ResetView, this, &QmitkMxNMultiWidget::ResetCrosshair);
connect(renderWindow, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkMxNMultiWidget::SetCrosshairVisibility);
connect(renderWindow, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkMxNMultiWidget::SetWidgetPlaneMode);
return renderWindowWidget;
}
+QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::GetWindowFromIndex(size_t index)
+{
+ if (index >= GetRenderWindowWidgets().size())
+ {
+ return nullptr;
+ }
+
+ auto renderWindowName = this->GetNameFromIndex(index);
+ auto renderWindowWidgets = GetRenderWindowWidgets();
+ auto it = renderWindowWidgets.find(renderWindowName);
+ if (it != renderWindowWidgets.end())
+ {
+ return it->second;
+ }
+ else
+ {
+ MITK_ERROR << "Could not find render window " << renderWindowName.toStdString() << ", although it should be there.";
+ return nullptr;
+ }
+}
+
void QmitkMxNMultiWidget::LoadLayout(const nlohmann::json* jsonData)
{
if ((*jsonData).is_null())
{
QMessageBox::warning(this, "Load layout", "Could not read window layout");
return;
}
unsigned int windowCounter = 0;
try
{
auto version = jsonData->at("version").get<std::string>();
if (version != "1.0")
{
QMessageBox::warning(this, "Load layout", "Unknown layout version, could not load");
return;
}
delete this->layout();
auto content = BuildLayoutFromJSON(jsonData, &windowCounter);
auto hBoxLayout = new QHBoxLayout(this);
this->setLayout(hBoxLayout);
hBoxLayout->addWidget(content);
emit UpdateUtilityWidgetViewPlanes();
}
catch (nlohmann::json::out_of_range& e)
{
MITK_ERROR << "Error in loading window layout from JSON: " << e.what();
return;
}
while (GetNumberOfRenderWindowWidgets() > windowCounter)
{
RemoveRenderWindowWidget();
}
EnableCrosshair();
emit LayoutChanged();
}
void QmitkMxNMultiWidget::SaveLayout(std::ostream* outStream)
{
if (outStream == nullptr)
{
return;
}
auto layout = this->layout();
if (layout == nullptr)
return;
// There should only ever be one item: a splitter
auto widget = layout->itemAt(0)->widget();
auto splitter = dynamic_cast<QSplitter*>(widget);
if (!splitter)
{
MITK_ERROR << "Tried to save unexpected layout format. Make sure the layout of this instance contains a single QSplitter.";
return;
}
auto layoutJSON = BuildJSONFromLayout(splitter);
layoutJSON["version"] = "1.0";
layoutJSON["name"] = "Custom Layout";
*outStream << std::setw(4) << layoutJSON << std::endl;
}
nlohmann::json QmitkMxNMultiWidget::BuildJSONFromLayout(const QSplitter* splitter)
{
nlohmann::json resultJSON;
resultJSON["isWindow"] = false;
resultJSON["vertical"] = (splitter->orientation() == Qt::Vertical) ? true : false;
auto sizes = splitter->sizes();
auto content = nlohmann::json::array();
auto countSplitter = splitter->count();
for (int i = 0; i < countSplitter; ++i)
{
auto widget = splitter->widget(i);
nlohmann::json widgetJSON;
if (auto widgetSplitter = dynamic_cast<QSplitter*>(widget); widgetSplitter)
{
widgetJSON = BuildJSONFromLayout(widgetSplitter);
}
else if (auto widgetWindow = dynamic_cast<QmitkRenderWindowWidget*>(widget); widgetWindow)
{
widgetJSON["isWindow"] = true;
widgetJSON["viewDirection"] = widgetWindow->GetSliceNavigationController()->GetViewDirectionAsString();
}
widgetJSON["size"] = sizes[i];
content.push_back(widgetJSON);
}
resultJSON["content"] = content;
return resultJSON;
}
QSplitter* QmitkMxNMultiWidget::BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter)
{
bool vertical = jsonData->at("vertical").get<bool>();
auto orientation = vertical ? Qt::Vertical : Qt::Horizontal;
auto split = new QSplitter(orientation, parentSplitter);
QList<int> sizes;
for (auto object : jsonData->at("content"))
{
bool isWindow = object["isWindow"].get<bool>();
int size = object["size"].get<int>();
sizes.append(size);
if (isWindow)
{
auto viewDirection = object["viewDirection"].get<std::string>();
mitk::AnatomicalPlane viewPlane = mitk::AnatomicalPlane::Sagittal;
if (viewDirection == "Axial")
{
viewPlane = mitk::AnatomicalPlane::Axial;
}
else if (viewDirection == "Coronal")
{
viewPlane = mitk::AnatomicalPlane::Coronal;
}
else if (viewDirection == "Original")
{
viewPlane = mitk::AnatomicalPlane::Original;
}
else if (viewDirection == "Sagittal")
{
viewPlane = mitk::AnatomicalPlane::Sagittal;
}
- QmitkAbstractMultiWidget::RenderWindowWidgetPointer window = nullptr;
- QString renderWindowName;
- QmitkAbstractMultiWidget::RenderWindowWidgetMap::iterator it;
-
// repurpose existing render windows as far as they already exist
- if (*windowCounter < GetRenderWindowWidgets().size())
- {
- renderWindowName = this->GetNameFromIndex(*windowCounter);
- auto renderWindowWidgets = GetRenderWindowWidgets();
- it = renderWindowWidgets.find(renderWindowName);
- if (it != renderWindowWidgets.end())
- {
- window = it->second;
- }
- else
- {
- MITK_ERROR << "Could not find render window " << renderWindowName.toStdString() << ", although it should be there.";
- }
- }
-
+ auto window = GetWindowFromIndex(*windowCounter);
if (window == nullptr)
{
window = CreateRenderWindowWidget();
}
window->GetSliceNavigationController()->SetDefaultViewDirection(viewPlane);
window->GetSliceNavigationController()->Update();
split->addWidget(window.get());
window->show();
(*windowCounter)++;
}
else
{
auto subSplitter = BuildLayoutFromJSON(&object, windowCounter, split);
split->addWidget(subSplitter);
}
}
split->setSizes(sizes);
return split;
}
+void QmitkMxNMultiWidget::SetDataBasedLayout(QmitkAbstractNodeSelectionWidget::NodeList nodes)
+{
+ auto vSplit = new QSplitter(Qt::Vertical);
+
+ unsigned int windowCounter = 0;
+ for (auto node : nodes)
+ {
+ auto hSplit = new QSplitter(Qt::Horizontal);
+ for (auto viewPlane : { mitk::AnatomicalPlane::Axial, mitk::AnatomicalPlane::Coronal, mitk::AnatomicalPlane::Sagittal })
+ {
+ // repurpose existing render windows as far as they already exist
+ auto window = GetWindowFromIndex(windowCounter);
+ if (window == nullptr)
+ {
+ window = CreateRenderWindowWidget();
+ }
+
+ auto utilityWidget = window->GetUtilityWidget();
+ utilityWidget->ToggleSynchronization(false);
+ utilityWidget->SetDataSelection(QList({ node }));
+ window->GetSliceNavigationController()->SetDefaultViewDirection(viewPlane);
+ window->GetSliceNavigationController()->Update();
+ hSplit->addWidget(window.get());
+ window->show();
+ windowCounter++;
+ }
+ auto sizes = QList<int>({1, 1, 1});
+ hSplit->setSizes(sizes);
+ vSplit->addWidget(hSplit);
+ }
+
+ delete this->layout();
+ auto hBoxLayout = new QHBoxLayout(this);
+ this->setLayout(hBoxLayout);
+ hBoxLayout->addWidget(vSplit);
+ emit UpdateUtilityWidgetViewPlanes();
+
+ while (GetNumberOfRenderWindowWidgets() > windowCounter)
+ {
+ RemoveRenderWindowWidget();
+ }
+
+ EnableCrosshair();
+ emit LayoutChanged();
+}
+
void QmitkMxNMultiWidget::SetInitialSelection()
{
auto dataStorage = this->GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
mitk::NodePredicateAnd::Pointer noHelperObjects = mitk::NodePredicateAnd::New();
noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
auto allNodes = dataStorage->GetSubset(noHelperObjects);
QmitkSynchronizedNodeSelectionWidget::NodeList currentSelection;
for (auto& node : *allNodes)
{
currentSelection.append(node);
}
m_SynchronizedWidgetConnector->ChangeSelection(currentSelection);
}
void QmitkMxNMultiWidget::ToggleSynchronization(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget)
{
bool synchronized = synchronizedWidget->IsSynchronized();
if (synchronized)
{
m_SynchronizedWidgetConnector->ConnectWidget(synchronizedWidget);
m_SynchronizedWidgetConnector->SynchronizeWidget(synchronizedWidget);
}
else
{
m_SynchronizedWidgetConnector->DisconnectWidget(synchronizedWidget);
}
}
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
index 4934c397d3..47057d7442 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp
@@ -1,185 +1,190 @@
/*============================================================================
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 "QmitkRenderWindowUtilityWidget.h"
#include <QWidgetAction>
// mitk core
#include <mitkDataStorage.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateProperty.h>
// mitk qt widgets
#include <QmitkRenderWindow.h>
#include <QmitkStyleManager.h>
// itk
#include <itkSpatialOrientationAdapter.h>
QmitkRenderWindowUtilityWidget::QmitkRenderWindowUtilityWidget(
QWidget* parent/* = nullptr */,
QmitkRenderWindow* renderWindow/* = nullptr */,
mitk::DataStorage* dataStorage/* = nullptr */)
: m_NodeSelectionWidget(nullptr)
, m_SliceNavigationWidget(nullptr)
, m_StepperAdapter(nullptr)
, m_ViewDirectionSelector(nullptr)
{
this->setParent(parent);
auto layout = new QHBoxLayout(this);
layout->setContentsMargins({});
mitk::NodePredicateAnd::Pointer noHelperObjects = mitk::NodePredicateAnd::New();
noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
m_BaseRenderer = mitk::BaseRenderer::GetInstance(renderWindow->GetVtkRenderWindow());
m_NodeSelectionWidget = new QmitkSynchronizedNodeSelectionWidget(parent);
m_NodeSelectionWidget->SetBaseRenderer(m_BaseRenderer);
m_NodeSelectionWidget->SetDataStorage(dataStorage);
m_NodeSelectionWidget->SetNodePredicate(noHelperObjects);
+ connect(this, &QmitkRenderWindowUtilityWidget::SetDataSelection, m_NodeSelectionWidget, &QmitkSynchronizedNodeSelectionWidget::SetSelection);
auto menuBar = new QMenuBar(this);
menuBar->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
menuBar->setNativeMenuBar(false);
auto dataMenu = menuBar->addMenu("Data");
QWidgetAction* dataAction = new QWidgetAction(dataMenu);
dataAction->setDefaultWidget(m_NodeSelectionWidget);
dataMenu->addAction(dataAction);
layout->addWidget(menuBar);
- auto* synchPushButton = new QPushButton(this);
+ m_SynchPushButton = new QPushButton(this);
auto* synchIcon = new QIcon();
auto synchronizeSvg = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/lock.svg"));
auto desynchronizeSvg = QmitkStyleManager::ThemeIcon(QLatin1String(":/Qmitk/unlock.svg"));
synchIcon->addPixmap(synchronizeSvg.pixmap(64), QIcon::Normal, QIcon::On);
synchIcon->addPixmap(desynchronizeSvg.pixmap(64), QIcon::Normal, QIcon::Off);
- synchPushButton->setIcon(*synchIcon);
- synchPushButton->setToolTip("Synchronize / desynchronize data management");
- synchPushButton->setCheckable(true);
- synchPushButton->setChecked(true);
- connect(synchPushButton, &QPushButton::clicked,
+ m_SynchPushButton->setIcon(*synchIcon);
+ m_SynchPushButton->setToolTip("Synchronize / desynchronize data management");
+ m_SynchPushButton->setCheckable(true);
+ m_SynchPushButton->setChecked(true);
+ connect(m_SynchPushButton, &QPushButton::clicked,
this, &QmitkRenderWindowUtilityWidget::ToggleSynchronization);
- layout->addWidget(synchPushButton);
+ layout->addWidget(m_SynchPushButton);
auto* sliceNavigationController = m_BaseRenderer->GetSliceNavigationController();
m_SliceNavigationWidget = new QmitkSliceNavigationWidget(this);
m_StepperAdapter =
new QmitkStepperAdapter(m_SliceNavigationWidget, sliceNavigationController->GetStepper());
layout->addWidget(m_SliceNavigationWidget);
mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer{ m_BaseRenderer };
m_RenderWindowViewDirectionController = std::make_unique<mitk::RenderWindowViewDirectionController>();
m_RenderWindowViewDirectionController->SetControlledRenderer(controlledRenderer);
m_RenderWindowViewDirectionController->SetDataStorage(dataStorage);
m_ViewDirectionSelector = new QComboBox(this);
QStringList viewDirections{ "axial", "coronal", "sagittal"};
m_ViewDirectionSelector->insertItems(0, viewDirections);
m_ViewDirectionSelector->setMinimumContentsLength(12);
connect(m_ViewDirectionSelector, &QComboBox::currentTextChanged, this, &QmitkRenderWindowUtilityWidget::ChangeViewDirection);
UpdateViewPlaneSelection();
layout->addWidget(m_ViewDirectionSelector);
// finally add observer, after all relevant objects have been created / initialized
sliceNavigationController->ConnectGeometrySendEvent(this);
}
QmitkRenderWindowUtilityWidget::~QmitkRenderWindowUtilityWidget()
{
}
void QmitkRenderWindowUtilityWidget::ToggleSynchronization(bool synchronized)
{
+ if (m_SynchPushButton->isChecked() != synchronized)
+ {
+ m_SynchPushButton->setChecked(synchronized);
+ }
m_NodeSelectionWidget->SetSynchronized(synchronized);
emit SynchronizationToggled(m_NodeSelectionWidget);
}
void QmitkRenderWindowUtilityWidget::SetGeometry(const itk::EventObject& event)
{
if (!mitk::SliceNavigationController::GeometrySendEvent(nullptr, 0).CheckEvent(&event))
{
return;
}
const auto* sliceNavigationController = m_BaseRenderer->GetSliceNavigationController();
auto viewDirection = sliceNavigationController->GetViewDirection();
unsigned int axis = 0;
switch (viewDirection)
{
case mitk::AnatomicalPlane::Original:
return;
case mitk::AnatomicalPlane::Axial:
{
axis = 2;
break;
}
case mitk::AnatomicalPlane::Coronal:
{
axis = 1;
break;
}
case mitk::AnatomicalPlane::Sagittal:
{
axis = 0;
break;
}
}
const auto* inputTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry();
const mitk::BaseGeometry* rendererGeometry = m_BaseRenderer->GetCurrentWorldGeometry();
mitk::TimeStepType timeStep = sliceNavigationController->GetStepper()->GetPos();
mitk::BaseGeometry::ConstPointer geometry = inputTimeGeometry->GetGeometryForTimeStep(timeStep);
if (geometry == nullptr)
return;
mitk::AffineTransform3D::MatrixType matrix = geometry->GetIndexToWorldTransform()->GetMatrix();
matrix.GetVnlMatrix().normalize_columns();
mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetInverse();
int dominantAxis = itk::Function::Max3(inverseMatrix[0][axis], inverseMatrix[1][axis], inverseMatrix[2][axis]);
bool referenceGeometryAxisInverted = inverseMatrix[dominantAxis][axis] < 0;
bool rendererZAxisInverted = rendererGeometry->GetAxisVector(2)[axis] < 0;
m_SliceNavigationWidget->SetInverseDirection(referenceGeometryAxisInverted != rendererZAxisInverted);
}
void QmitkRenderWindowUtilityWidget::ChangeViewDirection(const QString& viewDirection)
{
m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString());
}
void QmitkRenderWindowUtilityWidget::UpdateViewPlaneSelection()
{
const auto sliceNavigationController = m_BaseRenderer->GetSliceNavigationController();
const auto viewDirection = sliceNavigationController->GetDefaultViewDirection();
switch (viewDirection)
{
case mitk::AnatomicalPlane::Axial:
m_ViewDirectionSelector->setCurrentIndex(0);
break;
case mitk::AnatomicalPlane::Coronal:
m_ViewDirectionSelector->setCurrentIndex(1);
break;
case mitk::AnatomicalPlane::Sagittal:
m_ViewDirectionSelector->setCurrentIndex(2);
break;
default:
break;
}
}
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index 8c7d54c727..730adb3ea7 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,322 +1,333 @@
/*============================================================================
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 "QmitkRenderWindowWidget.h"
// vtk
#include <vtkCornerAnnotation.h>
#include <vtkTextProperty.h>
QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/,
const QString& widgetName/* = ""*/,
mitk::DataStorage* dataStorage/* = nullptr*/)
: QFrame(parent)
, m_WidgetName(widgetName)
, m_DataStorage(dataStorage)
, m_RenderWindow(nullptr)
, m_CrosshairManager(nullptr)
{
this->InitializeGUI();
}
QmitkRenderWindowWidget::~QmitkRenderWindowWidget()
{
auto sliceNavigationController = this->GetSliceNavigationController();
if (nullptr != sliceNavigationController)
{
sliceNavigationController->SetCrosshairEvent.RemoveListener(
mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
this, &QmitkRenderWindowWidget::SetCrosshairPosition));
}
this->DisableCrosshair();
}
void QmitkRenderWindowWidget::SetDataStorage(mitk::DataStorage* dataStorage)
{
if (dataStorage == m_DataStorage)
{
return;
}
m_DataStorage = dataStorage;
if (nullptr != m_RenderWindow)
{
mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow())->SetDataStorage(dataStorage);
}
}
mitk::SliceNavigationController* QmitkRenderWindowWidget::GetSliceNavigationController() const
{
return m_RenderWindow->GetSliceNavigationController();
}
void QmitkRenderWindowWidget::RequestUpdate()
{
mitk::RenderingManager::GetInstance()->RequestUpdate(m_RenderWindow->renderWindow());
}
void QmitkRenderWindowWidget::ForceImmediateUpdate()
{
mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(m_RenderWindow->renderWindow());
}
void QmitkRenderWindowWidget::AddUtilityWidget(QWidget* utilityWidget)
{
m_Layout->insertWidget(0, utilityWidget);
}
+QmitkRenderWindowUtilityWidget* QmitkRenderWindowWidget::GetUtilityWidget()
+{
+ auto layoutItem = m_Layout->itemAt(0)->widget();
+ auto utilityWidget = dynamic_cast<QmitkRenderWindowUtilityWidget*>(layoutItem);
+ if (utilityWidget != nullptr)
+ {
+ return utilityWidget;
+ }
+ return nullptr;
+}
+
void QmitkRenderWindowWidget::SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower)
{
vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
if (nullptr == vtkRenderer)
{
return;
}
m_GradientBackgroundColors.first = upper;
m_GradientBackgroundColors.second = lower;
vtkRenderer->SetBackground(lower[0], lower[1], lower[2]);
vtkRenderer->SetBackground2(upper[0], upper[1], upper[2]);
ShowGradientBackground(true);
}
void QmitkRenderWindowWidget::ShowGradientBackground(bool show)
{
m_RenderWindow->GetRenderer()->GetVtkRenderer()->SetGradientBackground(show);
}
bool QmitkRenderWindowWidget::IsGradientBackgroundOn() const
{
return m_RenderWindow->GetRenderer()->GetVtkRenderer()->GetGradientBackground();
}
void QmitkRenderWindowWidget::SetDecorationColor(const mitk::Color& color)
{
m_DecorationColor = color;
m_CornerAnnotation->GetTextProperty()->SetColor(m_DecorationColor[0], m_DecorationColor[1], m_DecorationColor[2]);
QColor hexColor(m_DecorationColor[0] * 255, m_DecorationColor[1] * 255, m_DecorationColor[2] * 255);
setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " + hexColor.name(QColor::HexRgb) + "; }");
}
void QmitkRenderWindowWidget::ShowColoredRectangle(bool show)
{
if (show)
{
setFrameStyle(QFrame::Box | QFrame::Plain);
}
else
{
setFrameStyle(NoFrame);
}
}
bool QmitkRenderWindowWidget::IsColoredRectangleVisible() const
{
return frameStyle() > 0;
}
void QmitkRenderWindowWidget::ShowCornerAnnotation(bool show)
{
m_CornerAnnotation->SetVisibility(show);
}
bool QmitkRenderWindowWidget::IsCornerAnnotationVisible() const
{
return m_CornerAnnotation->GetVisibility() > 0;
}
void QmitkRenderWindowWidget::SetCornerAnnotationText(const std::string& cornerAnnotation)
{
m_CornerAnnotation->SetText(0, cornerAnnotation.c_str());
}
std::string QmitkRenderWindowWidget::GetCornerAnnotationText() const
{
return std::string(m_CornerAnnotation->GetText(0));
}
bool QmitkRenderWindowWidget::IsRenderWindowMenuActivated() const
{
return m_RenderWindow->GetActivateMenuWidgetFlag();
}
void QmitkRenderWindowWidget::SetCrosshairVisibility(bool visible)
{
m_CrosshairManager->SetCrosshairVisibility(visible, m_RenderWindow->GetRenderer());
this->RequestUpdate();
}
bool QmitkRenderWindowWidget::GetCrosshairVisibility()
{
return m_CrosshairManager->GetCrosshairVisibility(m_RenderWindow->GetRenderer());
}
void QmitkRenderWindowWidget::SetCrosshairGap(unsigned int gapSize)
{
m_CrosshairManager->SetCrosshairGap(gapSize);
}
void QmitkRenderWindowWidget::EnableCrosshair()
{
m_CrosshairManager->AddCrosshairNodeToDataStorage(m_DataStorage);
}
void QmitkRenderWindowWidget::DisableCrosshair()
{
m_CrosshairManager->RemoveCrosshairNodeFromDataStorage(m_DataStorage);
}
void QmitkRenderWindowWidget::InitializeGUI()
{
m_Layout = new QVBoxLayout(this);
m_Layout->setContentsMargins({});
setLayout(m_Layout);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
setContentsMargins(0, 0, 0, 0);
if (nullptr == m_DataStorage)
{
return;
}
mitk::RenderingManager::GetInstance()->SetDataStorage(m_DataStorage);
// create render window for this render window widget
m_RenderWindow = new QmitkRenderWindow(this, m_WidgetName, nullptr);
m_RenderWindow->SetLayoutIndex(mitk::AnatomicalPlane::Sagittal);
connect(m_RenderWindow, &QmitkRenderWindow::ResetGeometry,
this, &QmitkRenderWindowWidget::OnResetGeometry);
auto* sliceNavigationController = this->GetSliceNavigationController();
sliceNavigationController->SetDefaultViewDirection(mitk::AnatomicalPlane::Sagittal);
m_Layout->addWidget(m_RenderWindow);
// set colors and corner annotation
InitializeDecorations();
// use crosshair manager
m_CrosshairManager = mitk::CrosshairManager::New(m_RenderWindow->GetRenderer());
sliceNavigationController->SetCrosshairEvent.AddListener(
mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
this, &QmitkRenderWindowWidget::SetCrosshairPosition));
// finally add observer, after all relevant objects have been created / initialized
sliceNavigationController->ConnectGeometrySendEvent(this);
sliceNavigationController->ConnectGeometrySliceEvent(this);
mitk::TimeGeometry::ConstPointer timeGeometry = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeView(m_RenderWindow->GetVtkRenderWindow(), timeGeometry);
}
void QmitkRenderWindowWidget::InitializeDecorations()
{
vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
if (nullptr == vtkRenderer)
{
return;
}
// initialize background color gradients
float black[3] = { 0.0f, 0.0f, 0.0f };
SetGradientBackgroundColors(black, black);
// initialize annotation text and decoration color
setFrameStyle(QFrame::Box | QFrame::Plain);
m_CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
m_CornerAnnotation->SetText(0, "Sagittal");
m_CornerAnnotation->SetMaximumFontSize(12);
if (0 == vtkRenderer->HasViewProp(m_CornerAnnotation))
{
vtkRenderer->AddViewProp(m_CornerAnnotation);
}
float white[3] = { 1.0f, 1.0f, 1.0f };
SetDecorationColor(mitk::Color(white));
}
void QmitkRenderWindowWidget::SetCrosshairPosition(const mitk::Point3D& newPosition)
{
m_CrosshairManager->SetCrosshairPosition(newPosition);
this->RequestUpdate();
}
mitk::Point3D QmitkRenderWindowWidget::GetCrosshairPosition() const
{
return m_CrosshairManager->GetCrosshairPosition();
}
void QmitkRenderWindowWidget::SetGeometry(const itk::EventObject& event)
{
if (!mitk::SliceNavigationController::GeometrySendEvent(nullptr, 0).CheckEvent(&event))
{
return;
}
const auto* planeGeometry = this->GetSliceNavigationController()->GetCurrentPlaneGeometry();
if (nullptr == planeGeometry)
{
mitkThrow() << "No valid plane geometry set. Render window is in an invalid state.";
}
return SetCrosshairPosition(planeGeometry->GetCenter());
}
void QmitkRenderWindowWidget::SetGeometrySlice(const itk::EventObject& event)
{
if (!mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0).CheckEvent(&event))
{
return;
}
const auto* sliceNavigationController = this->GetSliceNavigationController();
m_CrosshairManager->UpdateCrosshairPosition(sliceNavigationController);
}
void QmitkRenderWindowWidget::OnResetGeometry()
{
const auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow());
const auto* interactionReferenceGeometry = baseRenderer->GetInteractionReferenceGeometry();
this->ResetGeometry(interactionReferenceGeometry);
m_RenderWindow->ShowOverlayMessage(false);
}
void QmitkRenderWindowWidget::ResetGeometry(const mitk::TimeGeometry* referenceGeometry)
{
if (nullptr == referenceGeometry)
{
return;
}
mitk::TimeStepType imageTimeStep = 0;
// store the current position to set it again later, if the camera should not be reset
mitk::Point3D currentPosition = this->GetCrosshairPosition();
// store the current time step to set it again later, if the camera should not be reset
auto* renderingManager = mitk::RenderingManager::GetInstance();
const mitk::TimePointType currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
if (referenceGeometry->IsValidTimePoint(currentTimePoint))
{
imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
}
const auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow());
renderingManager->InitializeView(baseRenderer->GetRenderWindow(), referenceGeometry, false);
// reset position and time step
this->GetSliceNavigationController()->SelectSliceByPoint(currentPosition);
renderingManager->GetTimeNavigationController()->GetStepper()->SetPos(imageTimeStep);
}
diff --git a/Modules/QtWidgets/src/QmitkSynchronizedNodeSelectionWidget.cpp b/Modules/QtWidgets/src/QmitkSynchronizedNodeSelectionWidget.cpp
index 233074881c..ffe0359efa 100644
--- a/Modules/QtWidgets/src/QmitkSynchronizedNodeSelectionWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkSynchronizedNodeSelectionWidget.cpp
@@ -1,710 +1,716 @@
/*============================================================================
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.
============================================================================*/
// mitk qt widgets module
#include <QmitkSynchronizedNodeSelectionWidget.h>
#include <QmitkCustomVariants.h>
#include <QmitkEnums.h>
#include <QmitkNodeSelectionDialog.h>
// mitk core module
#include <mitkImage.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkRenderWindowLayerUtilities.h>
QmitkSynchronizedNodeSelectionWidget::QmitkSynchronizedNodeSelectionWidget(QWidget* parent)
: QmitkAbstractNodeSelectionWidget(parent)
{
m_Controls.setupUi(this);
m_StorageModel = std::make_unique<QmitkRenderWindowDataNodeTableModel>(this);
m_Controls.tableView->setModel(m_StorageModel.get());
m_Controls.tableView->horizontalHeader()->setVisible(false);
m_Controls.tableView->verticalHeader()->setVisible(false);
m_Controls.tableView->setSelectionMode(QAbstractItemView::SingleSelection);
m_Controls.tableView->setSelectionBehavior(QAbstractItemView::SelectRows);
m_Controls.tableView->setContextMenuPolicy(Qt::CustomContextMenu);
m_Controls.tableView->resizeColumnsToContents();
this->SetUpConnections();
this->Initialize();
}
QmitkSynchronizedNodeSelectionWidget::~QmitkSynchronizedNodeSelectionWidget()
{
bool isSynchronized = this->IsSynchronized();
if (isSynchronized)
{
emit DeregisterSynchronization();
return;
}
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
auto dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNull())
{
return;
}
// If the model is not synchronized,
// we know that renderer-specific properties exist for all nodes.
// These properties need to be removed from the nodes.
auto allNodes = dataStorage->GetAll();
for (auto& node : *allNodes)
{
// Delete the relevant renderer-specific properties for the node using the current base renderer.
mitk::RenderWindowLayerUtilities::DeleteRenderWindowProperties(node, baseRenderer);
}
}
void QmitkSynchronizedNodeSelectionWidget::SetBaseRenderer(mitk::BaseRenderer* baseRenderer)
{
if (m_BaseRenderer == baseRenderer)
{
// no need to do something
return;
}
if (nullptr == baseRenderer)
{
return;
}
auto oldBaseRenderer = m_BaseRenderer.Lock();
m_BaseRenderer = baseRenderer;
auto dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNull())
{
return;
}
bool isSynchronized = this->IsSynchronized();
if (isSynchronized)
{
// If the model is synchronized,
// all nodes use global / default properties.
// No renderer-specific property lists should exist
// so there is no need to transfer any property values.
}
else
{
// If the model is not synchronized,
// we know that renderer-specific properties exist for all nodes.
// These properties need to be removed from the nodes and
// we need to transfer their values to new renderer-specific properties.
auto allNodes = dataStorage->GetAll();
for (auto& node : *allNodes)
{
// Set the relevant renderer-specific properties for the node using the new base renderer.
// By transferring the values from the old property list,
// the same property-state is kept when switching to another base renderer.
mitk::RenderWindowLayerUtilities::TransferRenderWindowProperties(node, baseRenderer, oldBaseRenderer);
// Delete the relevant renderer-specific properties for the node using the old base renderer.
mitk::RenderWindowLayerUtilities::DeleteRenderWindowProperties(node, oldBaseRenderer);
}
}
this->Initialize();
}
void QmitkSynchronizedNodeSelectionWidget::SetSelectAll(bool selectAll)
{
if (selectAll == m_Controls.selectionModeCheckBox->isChecked())
{
// no need to do something
return;
}
m_Controls.selectionModeCheckBox->setChecked(selectAll);
}
bool QmitkSynchronizedNodeSelectionWidget::GetSelectAll() const
{
return m_Controls.selectionModeCheckBox->isChecked();
}
void QmitkSynchronizedNodeSelectionWidget::SetSynchronized(bool synchronize)
{
if (synchronize == this->IsSynchronized())
{
// no need to do something
return;
}
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
auto dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNull())
{
return;
}
if (synchronize)
{
// set the base renderer of the model to nullptr, such that global properties are used
m_StorageModel->SetCurrentRenderer(nullptr);
// If the model is synchronized,
// we know that the model was not synchronized before.
// That means that all nodes use renderer-specific properties,
// but now all nodes need global properties.
// Thus we need to remove the renderer-specific properties of all nodes of the
// datastorage.
auto allNodes = dataStorage->GetAll();
for (auto& node : *allNodes)
{
// For helper / hidden nodes:
// If the node predicate does not match, do not remove the renderer-specific property
// This is relevant for the crosshair data nodes, which are only visible inside their
// corresponding render window.
if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
{
// Delete the relevant renderer-specific properties for the node using the current base renderer.
mitk::RenderWindowLayerUtilities::DeleteRenderWindowProperties(node, baseRenderer);
}
}
}
else
{
// set the base renderer of the model to current base renderer, such that renderer-specific properties are used
m_StorageModel->SetCurrentRenderer(baseRenderer);
// If the model is not synchronized anymore,
// we know that the model was synchronized before.
// That means that all nodes use global / default properties,
// but now all nodes need renderer-specific properties.
// Thus we need to modify the renderer-specific properties of all nodes of the
// datastorage:
// - hide those nodes, which are not part of the newly selected nodes.
// - keep the property values of those nodes, which are part of the new selection AND
// have been selected before
auto currentNodeSelection = this->GetCurrentInternalSelection();
auto allNodes = dataStorage->GetAll();
for (auto& node : *allNodes)
{
// check if the node is part of the current selection
auto finding = std::find(std::begin(currentNodeSelection), std::end(currentNodeSelection), node);
if (finding != std::end(currentNodeSelection)) // node found / part of the current selection
{
// Set the relevant renderer-specific properties for the node using the curent base renderer.
// By transferring the values from the global / default property list,
// the same property-state is kept when switching to non-synchronized mode.
mitk::RenderWindowLayerUtilities::TransferRenderWindowProperties(node, baseRenderer, nullptr);
}
else
{
// If the node is not part of the selection, unset the relevant renderer-specific properties.
// This will unset the "visible" and "layer" property for the renderer-specific property list and
// hide the node for this renderer.
// ATTENTION: This is required, since the synchronized property needs to be overwritten
// to make sure that the visibility is correctly set for the specific base renderer.
this->DeselectNode(node);
}
}
}
// Since the synchronization might lead to a different node order depending on the layer properties, the render window
// needs to be updated.
// Explicitly request an update since a renderer-specific property change does not mark the node as modified.
// see https://phabricator.mitk.org/T22322
mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
}
bool QmitkSynchronizedNodeSelectionWidget::IsSynchronized() const
{
return m_StorageModel->GetCurrentRenderer().IsNull();
}
void QmitkSynchronizedNodeSelectionWidget::OnModelUpdated()
{
m_Controls.tableView->resizeRowsToContents();
m_Controls.tableView->resizeColumnsToContents();
}
void QmitkSynchronizedNodeSelectionWidget::OnSelectionModeChanged(bool selectAll)
{
emit SelectionModeChanged(selectAll);
if (selectAll)
{
this->SelectAll();
}
}
void QmitkSynchronizedNodeSelectionWidget::OnEditSelection()
{
QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(this);
dialog->SetDataStorage(m_DataStorage.Lock());
dialog->SetNodePredicate(m_NodePredicate);
dialog->SetCurrentSelection(m_StorageModel->GetCurrentSelection());
dialog->SetSelectionMode(QAbstractItemView::MultiSelection);
m_Controls.changeSelectionButton->setChecked(true);
if (dialog->exec())
{
m_Controls.selectionModeCheckBox->setChecked(false);
emit SelectionModeChanged(false);
auto selectedNodes = dialog->GetSelectedNodes();
this->HandleChangeOfInternalSelection(selectedNodes);
}
m_Controls.changeSelectionButton->setChecked(false);
delete dialog;
}
void QmitkSynchronizedNodeSelectionWidget::OnTableClicked(const QModelIndex& index)
{
if (!index.isValid() || m_StorageModel.get() != index.model())
{
return;
}
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
QVariant dataNodeVariant = index.data(QmitkDataNodeRole);
auto dataNode = dataNodeVariant.value<mitk::DataNode::Pointer>();
if (index.column() == 1) // node visibility column
{
bool visibiliy = index.data(Qt::EditRole).toBool();
m_StorageModel->setData(index, QVariant(!visibiliy), Qt::EditRole);
return;
}
if (index.column() == 2) // reinit node column
{
this->ReinitNode(dataNode);
return;
}
if (index.column() == 3) // remove node column
{
this->RemoveFromInternalSelection(dataNode);
return;
}
}
void QmitkSynchronizedNodeSelectionWidget::SetUpConnections()
{
connect(m_StorageModel.get(), &QmitkRenderWindowDataNodeTableModel::ModelUpdated,
this, &QmitkSynchronizedNodeSelectionWidget::OnModelUpdated);
connect(m_Controls.selectionModeCheckBox, &QCheckBox::clicked,
this, &QmitkSynchronizedNodeSelectionWidget::OnSelectionModeChanged);
connect(m_Controls.changeSelectionButton, &QPushButton::clicked,
this, &QmitkSynchronizedNodeSelectionWidget::OnEditSelection);
connect(m_Controls.tableView, &QTableView::clicked,
this, &QmitkSynchronizedNodeSelectionWidget::OnTableClicked);
}
+void QmitkSynchronizedNodeSelectionWidget::SetSelection(const NodeList& newSelection)
+{
+ this->HandleChangeOfInternalSelection(newSelection);
+ m_Controls.selectionModeCheckBox->setChecked(false);
+}
+
void QmitkSynchronizedNodeSelectionWidget::Initialize()
{
auto baseRenderer = m_BaseRenderer.Lock();
auto dataStorage = m_DataStorage.Lock();
m_StorageModel->SetDataStorage(dataStorage);
m_StorageModel->SetCurrentRenderer(baseRenderer);
if (baseRenderer.IsNull() || dataStorage.IsNull())
{
m_Controls.selectionModeCheckBox->setEnabled(false);
m_Controls.changeSelectionButton->setEnabled(false);
// reset the model if no data storage is defined
m_StorageModel->removeRows(0, m_StorageModel->rowCount());
return;
}
// Use the new data storage / node predicate to correctly set the list of
// currently selected data nodes for the model.
// If a new data storage or node predicate has been defined,
// we switch to the "selectAll" mode and synchronize the selection for simplicity.
// enable UI
m_Controls.selectionModeCheckBox->setEnabled(true);
m_Controls.changeSelectionButton->setEnabled(true);
m_Controls.selectionModeCheckBox->setChecked(true);
// set the base renderer of the model to nullptr, such that global properties are used (synchronized mode)
m_StorageModel->SetCurrentRenderer(nullptr);
}
void QmitkSynchronizedNodeSelectionWidget::UpdateInfo()
{
}
void QmitkSynchronizedNodeSelectionWidget::OnDataStorageChanged()
{
this->Initialize();
}
void QmitkSynchronizedNodeSelectionWidget::OnNodePredicateChanged()
{
this->Initialize();
}
void QmitkSynchronizedNodeSelectionWidget::ReviseSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection)
{
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
bool isSynchronized = this->IsSynchronized();
if (isSynchronized)
{
this->ReviseSynchronizedSelectionChanged(oldInternalSelection, newInternalSelection);
}
else
{
this->ReviseDesynchronizedSelectionChanged(oldInternalSelection, newInternalSelection);
}
// Since a new selection might have a different rendering tree the render windows
// need to be updated.
// Explicitly request an update since a renderer-specific property change does not mark the node as modified.
// see https://phabricator.mitk.org/T22322
mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
}
void QmitkSynchronizedNodeSelectionWidget::OnInternalSelectionChanged()
{
m_StorageModel->SetCurrentSelection(this->GetCurrentInternalSelection());
}
bool QmitkSynchronizedNodeSelectionWidget::AllowEmissionOfSelection(const NodeList& /*emissionCandidates*/) const
{
return this->IsSynchronized();
}
void QmitkSynchronizedNodeSelectionWidget::OnNodeAddedToStorage(const mitk::DataNode* node)
{
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
// For helper / hidden nodes
if (m_NodePredicate.IsNotNull() && !m_NodePredicate->CheckNode(node))
{
// If the node predicate does not match, do not add the node to the current selection.
// Leave the visibility as it is.
return;
}
// The selection mode determines if we want to show all nodes from the data storage
// or use a local selected list of nodes.
// We need to hide each new incoming data node, if we use a local selection,
// since we do not want to show / select newly added nodes immediately.
// We need to add the incoming node to our selection, if the selection mode check box
// is checked.
// We want to add the incoming node to our selection, if the node is a child node
// of an already selected node.
// Nodes added to the selection will be made visible.
if (m_Controls.selectionModeCheckBox->isChecked() || this->IsParentNodeSelected(node))
{
auto currentSelection = this->GetCurrentInternalSelection();
// Check if the nodes is already part of the internal selection.
// That can happen if another render window already added the new node and sent out the new, updated
// selection to be synchronized.
auto finding = std::find(std::begin(currentSelection), std::end(currentSelection), node);
if (finding != std::end(currentSelection)) // node found
{
// node already part of the selection
return;
}
currentSelection.append(const_cast<mitk::DataNode*>(node));
// This function will call 'QmitkSynchronizedNodeSelectionWidget::ReviseSelectionChanged'
// which will take care of the visibility-property for newly added node.
this->HandleChangeOfInternalSelection(currentSelection);
}
else
{
// If the widget is in "local-selection" state (selectionModeCheckBox unchecked),
// the new incoming node needs to be hid.
// Here it depends on the synchronization-state which properties need
// to be modified.
if (this->IsSynchronized())
{
// If the node will not be part of the new selection, hide the node.
const_cast<mitk::DataNode*>(node)->SetVisibility(false);
}
else
{
// If the widget is not synchronized, all nodes use renderer-specific properties.
// Thus we need to modify the renderer-specific properties of the node:
// - hide the node, which is not part of the selection
this->DeselectNode(const_cast<mitk::DataNode*>(node));
}
}
}
void QmitkSynchronizedNodeSelectionWidget::OnNodeModified(const itk::Object* caller, const itk::EventObject& event)
{
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
if (!itk::ModifiedEvent().CheckEvent(&event))
{
return;
}
auto node = dynamic_cast<const mitk::DataNode*>(caller);
if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(node))
{
auto currentSelection = this->GetCurrentInternalSelection();
// check if the node to be modified is part of the current selection
auto finding = std::find(std::begin(currentSelection), std::end(currentSelection), node);
if (finding == std::end(currentSelection)) // node not found
{
// node not part of the selection
return;
}
// We know that the node is relevant, but we don't know if the node modification was relevant
// for the rendering. We just request an update here.
// Explicitly request an update since a renderer-specific property change does not mark the node as modified.
// see https://phabricator.mitk.org/T22322
mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow());
m_StorageModel->UpdateModelData();
}
}
void QmitkSynchronizedNodeSelectionWidget::ReviseSynchronizedSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection)
{
// If the model is synchronized, all nodes use global / default properties.
// Thus we need to modify the global properties of the selection:
// - a) show those nodes, which are part of the new selection AND have not been
// selected before
// - b) keep the property values of those nodes, which are part of the new selection AND
// have been selected before
// - c) hide those nodes, which are part of the old selection AND
// have not been newly selected
for (auto& node : newInternalSelection)
{
// check if the node is part of the old selection
auto finding = std::find(std::begin(oldInternalSelection), std::end(oldInternalSelection), node);
if (finding == std::end(oldInternalSelection)) // node not found
{
// If the node is part of the new selection and was not already part of the old selection,
// set the relevant renderer-specific properties.
// This will set the "visible" property for the global / default property list
// and show the node for this renderer.
node->SetVisibility(true); // item a)
}
// else: item b): node that was already selected before does not need to be modified
}
for (auto& node : oldInternalSelection)
{
// check if the node is part of the new selection
auto finding = std::find(std::begin(newInternalSelection), std::end(newInternalSelection), node);
if (finding == std::end(newInternalSelection)) // node not found
{
// If the node is not part of the new selection, hide the node.
node->SetVisibility(false); // item c)
}
// else: item b): node that was already selected before does not need to be modified
}
}
void QmitkSynchronizedNodeSelectionWidget::ReviseDesynchronizedSelectionChanged(const NodeList& oldInternalSelection, NodeList& newInternalSelection)
{
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
// If the model is not synchronized, all nodes need renderer-specific properties.
// Thus we need to modify the renderer-specific properties of the selection:
// - a) set the renderer-specific properties of those nodes, which are part of the new selection AND
// have not been selected before (see 'SelectNode')
// - b) show those nodes, which are part of the new selection AND have not been
// selected before
// - c) keep the property values of those nodes, which are part of the new selection AND
// have been selected before
// - d) hide those nodes, which are part of the old selection AND
// have not been newly selected
// - e) set the renderer-specific properties of those nodes, which are part of the old selection AND
// have not been newly selected, to denote which nodes are selected
for (auto& node : newInternalSelection)
{
// check if the node is part of the old selection
auto finding = std::find(std::begin(oldInternalSelection), std::end(oldInternalSelection), node);
if (finding == std::end(oldInternalSelection)) // node not found
{
// If the node is part of the new selection and was not already part of the old selection,
// set the relevant renderer-specific properties.
// This will set the "visible" and "layer" property for the renderer-specific property list
// such that the global / default property list values are overwritten
mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(node, baseRenderer); // item a)
// Explicitly set the visibility to true for selected nodes to show them in the render window.
node->SetVisibility(true, baseRenderer); // item b)
}
// else: item c): node that was already selected before does not need to be modified
}
for (auto& node : oldInternalSelection)
{
// check if the node is part of the new selection
auto finding = std::find(std::begin(newInternalSelection), std::end(newInternalSelection), node);
if (finding == std::end(newInternalSelection)) // node not found
{
// If the node is not part of the new selection, unset the relevant renderer-specific properties.
// This will unset the "visible" and "layer" property for the renderer-specific property list and
// hide the node for this renderer.
// ATTENTION: This is required, since the synchronized global property needs to be overwritten
// to make sure that the visibility is correctly set for the specific base renderer.
this->DeselectNode(node); // item d) and e)
}
// else: item c): node that was already selected before does not need to be modified
}
}
void QmitkSynchronizedNodeSelectionWidget::ReinitNode(const mitk::DataNode* dataNode)
{
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
auto selectedImage = dynamic_cast<mitk::Image*>(dataNode->GetData());
if (nullptr == selectedImage)
{
return;
}
auto boundingBoxPredicate = mitk::NodePredicateNot::New(
mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false), baseRenderer));
if (!boundingBoxPredicate->CheckNode(dataNode))
{
return;
}
mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), selectedImage->GetTimeGeometry());
}
void QmitkSynchronizedNodeSelectionWidget::RemoveFromInternalSelection(mitk::DataNode* dataNode)
{
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
if (this->IsSynchronized())
{
// If the model is synchronized, all nodes use global / default properties.
// Thus we need to modify the global property of the node.
// Explicitly set the visibility to false for unselected nodes to hide them in the render window.
dataNode->SetVisibility(false);
}
m_Controls.selectionModeCheckBox->setChecked(false);
emit SelectionModeChanged(false);
this->RemoveNodeFromSelection(dataNode);
}
bool QmitkSynchronizedNodeSelectionWidget::IsParentNodeSelected(const mitk::DataNode* dataNode) const
{
auto dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNull())
{
return false;
}
auto currentSelection = this->GetCurrentInternalSelection();
auto parentNodes = dataStorage->GetSources(dataNode, m_NodePredicate, false);
for (auto it = parentNodes->Begin(); it != parentNodes->End(); ++it)
{
const mitk::DataNode* parentNode = it->Value();
auto finding = std::find(std::begin(currentSelection), std::end(currentSelection), parentNode);
if (finding != std::end(currentSelection)) // parent node found
{
// at least one parent node is part of the selection
return true;
}
}
return false;
}
void QmitkSynchronizedNodeSelectionWidget::DeselectNode(mitk::DataNode* dataNode)
{
auto baseRenderer = m_BaseRenderer.Lock();
if (baseRenderer.IsNull())
{
return;
}
if (nullptr == dataNode)
{
return;
}
if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(dataNode))
{
// If the node should not be part of the selection, set the relevant renderer-specific properties.
// This will set the "visible" and "layer" property for the renderer-specific property list,
// such that the global / default property list values are overwritten.
mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(dataNode, baseRenderer);
// Explicitly set the visibility to false for the node to hide them in the render window.
dataNode->SetVisibility(false, baseRenderer);
}
}
void QmitkSynchronizedNodeSelectionWidget::SelectAll()
{
auto dataStorage = m_DataStorage.Lock();
if (dataStorage.IsNull())
{
return;
}
auto allNodes = m_NodePredicate ? dataStorage->GetSubset(m_NodePredicate) : dataStorage->GetAll();
NodeList currentSelection;
for (auto& node : *allNodes)
{
currentSelection.append(node);
}
this->HandleChangeOfInternalSelection(currentSelection);
}
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index fee5a07e50..968dd7a6a0 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,244 +1,247 @@
/*============================================================================
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 "QmitkMxNMultiWidgetEditor.h"
#include <mitkCoreServices.h>
#include <mitkIPreferencesService.h>
#include <mitkIPreferences.h>
#include <berryIWorkbenchPage.h>
#include <berryIWorkbenchPartConstants.h>
#include <berryUIException.h>
// mxn multi widget editor plugin
#include "QmitkMultiWidgetDecorationManager.h"
// mitk qt widgets module
#include <QmitkMxNMultiWidget.h>
#include <QmitkInteractionSchemeToolBar.h>
#include <QmitkMultiWidgetConfigurationToolBar.h>
// qt
#include <QHBoxLayout>
const QString QmitkMxNMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.mxnmultiwidget";
struct QmitkMxNMultiWidgetEditor::Impl final
{
Impl();
~Impl() = default;
QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
QmitkMultiWidgetConfigurationToolBar* m_ConfigurationToolBar;
};
QmitkMxNMultiWidgetEditor::Impl::Impl()
: m_InteractionSchemeToolBar(nullptr)
, m_ConfigurationToolBar(nullptr)
{
// nothing here
}
//////////////////////////////////////////////////////////////////////////
// QmitkMxNMultiWidgetEditor
//////////////////////////////////////////////////////////////////////////
QmitkMxNMultiWidgetEditor::QmitkMxNMultiWidgetEditor()
: QmitkAbstractMultiWidgetEditor()
, m_Impl(std::make_unique<Impl>())
{
// nothing here
}
QmitkMxNMultiWidgetEditor::~QmitkMxNMultiWidgetEditor()
{
GetSite()->GetPage()->RemovePartListener(this);
}
berry::IPartListener::Events::Types QmitkMxNMultiWidgetEditor::GetPartEventTypes() const
{
return Events::CLOSED | Events::OPENED | Events::HIDDEN | Events::VISIBLE;
}
void QmitkMxNMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->ActivateMenuWidget(false);
}
}
}
void QmitkMxNMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->EnableCrosshair();
multiWidget->ActivateMenuWidget(true);
}
}
}
void QmitkMxNMultiWidgetEditor::PartHidden(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->ActivateMenuWidget(false);
}
}
}
void QmitkMxNMultiWidgetEditor::PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->ActivateMenuWidget(true);
}
}
}
void QmitkMxNMultiWidgetEditor::OnLayoutSet(int row, int column)
{
const auto &multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
QmitkAbstractMultiWidgetEditor::OnLayoutSet(row, column);
multiWidget->EnableCrosshair();
}
}
void QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
{
const auto &multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return;
}
if (mitk::InteractionSchemeSwitcher::PACSStandard == scheme)
{
m_Impl->m_InteractionSchemeToolBar->setVisible(true);
}
else
{
m_Impl->m_InteractionSchemeToolBar->setVisible(false);
}
QmitkAbstractMultiWidgetEditor::OnInteractionSchemeChanged(scheme);
}
//////////////////////////////////////////////////////////////////////////
// PRIVATE
//////////////////////////////////////////////////////////////////////////
void QmitkMxNMultiWidgetEditor::SetFocus()
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->setFocus();
}
}
void QmitkMxNMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
{
QHBoxLayout *layout = new QHBoxLayout(parent);
layout->setContentsMargins(0, 0, 0, 0);
auto* preferences = this->GetPreferences();
auto multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
multiWidget = new QmitkMxNMultiWidget(parent);
// create left toolbar: interaction scheme toolbar to switch how the render window navigation behaves in PACS mode
if (nullptr == m_Impl->m_InteractionSchemeToolBar)
{
m_Impl->m_InteractionSchemeToolBar = new QmitkInteractionSchemeToolBar(parent);
layout->addWidget(m_Impl->m_InteractionSchemeToolBar);
}
m_Impl->m_InteractionSchemeToolBar->SetInteractionEventHandler(multiWidget->GetInteractionEventHandler());
multiWidget->SetDataStorage(GetDataStorage());
multiWidget->InitializeMultiWidget();
SetMultiWidget(multiWidget);
connect(static_cast<QmitkMxNMultiWidget*>(multiWidget), &QmitkMxNMultiWidget::LayoutChanged,
this, &QmitkMxNMultiWidgetEditor::OnLayoutChanged);
}
layout->addWidget(multiWidget);
// create right toolbar: configuration toolbar to change the render window widget layout
if (nullptr == m_Impl->m_ConfigurationToolBar)
{
m_Impl->m_ConfigurationToolBar = new QmitkMultiWidgetConfigurationToolBar(multiWidget);
+ m_Impl->m_ConfigurationToolBar->SetDataStorage(GetDataStorage());
layout->addWidget(m_Impl->m_ConfigurationToolBar);
}
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LayoutSet,
this, &QmitkMxNMultiWidgetEditor::OnLayoutSet);
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::Synchronized,
this, &QmitkMxNMultiWidgetEditor::OnSynchronize);
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::InteractionSchemeChanged,
this, &QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged);
+ connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::SetDataBasedLayout,
+ static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::SetDataBasedLayout);
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::SaveLayout,
static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::SaveLayout, Qt::DirectConnection);
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LoadLayout,
static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::LoadLayout);
GetSite()->GetPage()->AddPartListener(this);
OnPreferencesChanged(preferences);
}
void QmitkMxNMultiWidgetEditor::OnPreferencesChanged(const mitk::IPreferences* preferences)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return;
}
// update decoration preferences
//m_Impl->m_MultiWidgetDecorationManager->DecorationPreferencesChanged(preferences);
int crosshairGapSize = preferences->GetInt("crosshair gap size", 32);
multiWidget->SetCrosshairGap(crosshairGapSize);
// zooming and panning preferences
bool constrainedZooming = preferences->GetBool("Use constrained zooming and panning", true);
mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
bool PACSInteractionScheme = preferences->GetBool("PACS like mouse interaction", false);
OnInteractionSchemeChanged(PACSInteractionScheme ?
mitk::InteractionSchemeSwitcher::PACSStandard :
mitk::InteractionSchemeSwitcher::MITKStandard);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkMxNMultiWidgetEditor::OnLayoutChanged()
{
FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
}