diff --git a/Modules/ModuleList.cmake b/Modules/ModuleList.cmake index 641e2370b6..d558488b7b 100644 --- a/Modules/ModuleList.cmake +++ b/Modules/ModuleList.cmake @@ -1,77 +1,76 @@ # The entries in the mitk_modules list must be # ordered according to their dependencies. set(MITK_MODULES Core CommandLine CoreCmdApps AppUtil LegacyIO DataTypesExt Annotation LegacyGL AlgorithmsExt MapperExt DICOM DICOMQI DICOMTesting SceneSerializationBase PlanarFigure ImageDenoising ImageExtraction SceneSerialization Gizmo GraphAlgorithms Multilabel Chart ImageStatistics ContourModel SurfaceInterpolation Segmentation QtWidgets QtWidgetsExt ImageStatisticsUI SegmentationUI MatchPointRegistration MatchPointRegistrationUI Classification OpenIGTLink IGTBase IGT CameraCalibration OpenCL OpenCVVideoSupport QtOverlays ToFHardware ToFProcessing ToFUI US USUI DICOMUI Remeshing Python QtPython Persistence OpenIGTLinkUI IGTUI RT RTUI IOExt XNAT TubeGraph BoundingShape - RenderWindowManager RenderWindowManagerUI SemanticRelations SemanticRelationsUI CEST BasicImageProcessing ModelFit ModelFitUI Pharmacokinetics PharmacokineticsUI DICOMPM REST RESTService DICOMweb ) diff --git a/Modules/QtWidgets/CMakeLists.txt b/Modules/QtWidgets/CMakeLists.txt index 7d4c22415b..8800bae003 100644 --- a/Modules/QtWidgets/CMakeLists.txt +++ b/Modules/QtWidgets/CMakeLists.txt @@ -1,8 +1,8 @@ MITK_CREATE_MODULE( INCLUDE_DIRS PRIVATE resource # for xpm includes DEPENDS MitkPlanarFigure MitkAnnotation PACKAGE_DEPENDS - PUBLIC VTK|GUISupportQt+RenderingQt Qt5|Widgets+OpenGL+Core + PUBLIC VTK|GUISupportQt+RenderingQt Qt5|Widgets+OpenGL+Core CTK|CTKWidgets ) add_subdirectory(test) diff --git a/Modules/QtWidgets/files.cmake b/Modules/QtWidgets/files.cmake index ff8a6a8204..c5f1d77a71 100644 --- a/Modules/QtWidgets/files.cmake +++ b/Modules/QtWidgets/files.cmake @@ -1,137 +1,155 @@ file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*") set(CPP_FILES QmitkAbstractDataStorageModel.cpp QmitkAbstractMultiWidget.cpp QmitkAbstractNodeSelectionWidget.cpp QmitkApplicationCursor.cpp QmitkDataStorageComboBox.cpp QmitkDataStorageDefaultListModel.cpp QmitkDataStorageHistoryModel.cpp QmitkDataStorageListModel.cpp QmitkDataStorageTableModel.cpp QmitkDataStorageSimpleTreeModel.cpp QmitkDataStorageTreeModel.cpp QmitkDataStorageTreeModelInternalItem.cpp QmitkDnDDataNodeWidget.cpp QmitkFileReaderOptionsDialog.cpp QmitkFileReaderWriterOptionsWidget.cpp QmitkFileWriterOptionsDialog.cpp QmitkInteractionSchemeToolBar.cpp QmitkIOUtil.cpp QmitkLevelWindowPresetDefinitionDialog.cpp QmitkLevelWindowRangeChangeDialog.cpp QmitkLevelWindowWidgetContextMenu.cpp QmitkLevelWindowWidget.cpp QmitkLineEditLevelWindowWidget.cpp QmitkMemoryUsageIndicatorView.cpp QmitkMimeTypes.cpp QmitkMultiWidgetConfigurationToolBar.cpp QmitkMultiWidgetLayoutManager.cpp QmitkMultiWidgetLayoutSelectionWidget.cpp QmitkNodeDescriptor.cpp QmitkColoredNodeDescriptor.cpp QmitkNodeDescriptorManager.cpp QmitkProgressBar.cpp QmitkPropertiesTableEditor.cpp QmitkPropertiesTableModel.cpp QmitkPropertyDelegate.cpp QmitkRegisterClasses.cpp QmitkRenderingManager.cpp + QmitkRenderWindowDataStorageTreeModel.cpp QmitkRenderingManagerFactory.cpp QmitkRenderWindow.cpp QmitkRenderWindowMenu.cpp + QmitkRenderWindowUtilityWidget.cpp QmitkRenderWindowWidget.cpp + QmitkRenderWindowContextDataStorageInspector.cpp + mitkRenderWindowLayerController.cpp + mitkRenderWindowLayerUtilities.cpp + mitkRenderWindowViewDirectionController.cpp QmitkServiceListWidget.cpp QmitkSliderLevelWindowWidget.cpp + QmitkSliderNavigatorWidget.cpp QmitkStdMultiWidget.cpp + QmitkStepperAdapter.cpp QmitkMxNMultiWidget.cpp QmitkDataStorageComboBoxWithSelectNone.cpp QmitkDataStorageFilterProxyModel.cpp QmitkPropertyItem.cpp QmitkPropertyItemDelegate.cpp QmitkPropertyItemModel.cpp QmitkStyleManager.cpp QmitkAbstractDataStorageInspector.cpp QmitkDataStorageFavoriteNodesInspector.cpp QmitkDataStorageListInspector.cpp QmitkDataStorageTreeInspector.cpp QmitkDataStorageSelectionHistoryInspector.cpp QmitkModelViewSelectionConnector.cpp mitkIDataStorageInspectorProvider.cpp mitkQtWidgetsActivator.cpp mitkDataStorageInspectorGenerator.cpp QmitkOverlayWidget.cpp QmitkSimpleTextOverlayWidget.cpp QmitkNodeDetailsDialog.cpp ) set(MOC_H_FILES include/QmitkAbstractDataStorageModel.h include/QmitkAbstractMultiWidget.h include/QmitkAbstractNodeSelectionWidget.h include/QmitkDataStorageComboBox.h include/QmitkDataStorageTableModel.h include/QmitkDataStorageTreeModel.h include/QmitkDataStorageSimpleTreeModel.h include/QmitkDataStorageDefaultListModel.h include/QmitkDnDDataNodeWidget.h include/QmitkFileReaderOptionsDialog.h include/QmitkFileReaderWriterOptionsWidget.h include/QmitkFileWriterOptionsDialog.h include/QmitkInteractionSchemeToolBar.h include/QmitkLevelWindowPresetDefinitionDialog.h include/QmitkLevelWindowRangeChangeDialog.h include/QmitkLevelWindowWidgetContextMenu.h include/QmitkLevelWindowWidget.h include/QmitkLineEditLevelWindowWidget.h include/QmitkMemoryUsageIndicatorView.h include/QmitkMultiWidgetConfigurationToolBar.h include/QmitkMultiWidgetLayoutManager.h include/QmitkMultiWidgetLayoutSelectionWidget.h include/QmitkNodeDescriptor.h include/QmitkColoredNodeDescriptor.h include/QmitkNodeDescriptorManager.h include/QmitkProgressBar.h include/QmitkPropertiesTableEditor.h include/QmitkPropertyDelegate.h include/QmitkRenderingManager.h include/QmitkRenderWindow.h + include/QmitkRenderWindowDataStorageTreeModel.h include/QmitkRenderWindowMenu.h + include/QmitkRenderWindowUtilityWidget.h include/QmitkRenderWindowWidget.h + include/QmitkRenderWindowContextDataStorageInspector.h + include/mitkRenderWindowLayerController.h + include/mitkRenderWindowLayerUtilities.h + include/mitkRenderWindowViewDirectionController.h include/QmitkServiceListWidget.h include/QmitkSliderLevelWindowWidget.h + include/QmitkSliderNavigatorWidget.h include/QmitkStdMultiWidget.h include/QmitkMxNMultiWidget.h + include/QmitkStepperAdapter.h include/QmitkDataStorageComboBoxWithSelectNone.h include/QmitkPropertyItemDelegate.h include/QmitkPropertyItemModel.h include/QmitkAbstractDataStorageInspector.h include/QmitkDataStorageFavoriteNodesInspector.h include/QmitkDataStorageListInspector.h include/QmitkDataStorageTreeInspector.h include/QmitkDataStorageHistoryModel.h include/QmitkDataStorageSelectionHistoryInspector.h include/QmitkModelViewSelectionConnector.h include/QmitkOverlayWidget.h include/QmitkSimpleTextOverlayWidget.h include/QmitkNodeDetailsDialog.h ) set(UI_FILES src/QmitkFileReaderOptionsDialog.ui src/QmitkFileWriterOptionsDialog.ui src/QmitkLevelWindowPresetDefinition.ui src/QmitkLevelWindowWidget.ui src/QmitkLevelWindowRangeChange.ui src/QmitkMemoryUsageIndicator.ui src/QmitkMultiWidgetLayoutSelectionWidget.ui + src/QmitkRenderWindowContextDataStorageInspector.ui src/QmitkServiceListWidgetControls.ui + src/QmitkSliderNavigator.ui src/QmitkDataStorageListInspector.ui src/QmitkDataStorageTreeInspector.ui src/QmitkDataStorageSelectionHistoryInspector.ui ) set(QRC_FILES resource/Qmitk.qrc ) diff --git a/Modules/QtWidgets/include/QmitkRenderWindowContextDataStorageInspector.h b/Modules/QtWidgets/include/QmitkRenderWindowContextDataStorageInspector.h new file mode 100644 index 0000000000..5f07548423 --- /dev/null +++ b/Modules/QtWidgets/include/QmitkRenderWindowContextDataStorageInspector.h @@ -0,0 +1,91 @@ +/*============================================================================ + +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 QMITKRENDERWINDOWCONTEXTDATASTORAGEINSPECTOR_H +#define QMITKRENDERWINDOWCONTEXTDATASTORAGEINSPECTOR_H + +// qt widgets module +#include "MitkQtWidgetsExports.h" +#include "ui_QmitkRenderWindowContextDataStorageInspector.h" + +// render window manager module +#include +#include + +// qt widgets module +#include + +// mitk core +#include + +/** +* The 'QmitkRenderWindowContextDataStorageInspector' offers a GUI to manipulate the base renderer / render windows of the MITK workbench. +* +* In order to use this widget, a (e.g.) plugin has to set the controlled renderer, which will be forwarded to +* a render window view direction controller. +*/ +class MITKQTWIDGETS_EXPORT QmitkRenderWindowContextDataStorageInspector : public QmitkAbstractDataStorageInspector +{ + Q_OBJECT + +public: + + QmitkRenderWindowContextDataStorageInspector(QWidget* parent = nullptr, mitk::BaseRenderer* renderer = nullptr); + + // override from 'QmitkAbstractDataStorageInspector' + /** + * @brief See 'QmitkAbstractDataStorageInspector' + */ + QAbstractItemView* GetView() override; + /** + * @brief See 'QmitkAbstractDataStorageInspector' + */ + const QAbstractItemView* GetView() const override; + /** + * @brief See 'QmitkAbstractDataStorageInspector' + */ + void SetSelectionMode(SelectionMode mode) override; + /** + * @brief See 'QmitkAbstractDataStorageInspector' + */ + SelectionMode GetSelectionMode() const override; + + QItemSelectionModel* GetDataNodeSelectionModel() const; + +Q_SIGNALS: + + void ReinitAction(QList selectedNodes); + void ResetAction(QList selectedNodes); + +private Q_SLOTS: + + void ModelRowsInserted(const QModelIndex& parent, int start, int end); + + void ResetRenderer(); + + void OnContextMenuRequested(const QPoint& pos); + void OnReinit(); + void OnReset(); + +private: + + void Initialize() override; + void SetUpConnections(); + QList GetSelectedNodes(); + + Ui::QmitkRenderWindowContextDataStorageInspector m_Controls; + + std::unique_ptr m_StorageModel; + std::unique_ptr m_RenderWindowLayerController; +}; + +#endif // QMITKRENDERWINDOWCONTEXTDATASTORAGEINSPECTOR_H diff --git a/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageTreeModel.h b/Modules/QtWidgets/include/QmitkRenderWindowDataStorageTreeModel.h similarity index 96% rename from Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageTreeModel.h rename to Modules/QtWidgets/include/QmitkRenderWindowDataStorageTreeModel.h index 776e38304a..fb9d537e44 100644 --- a/Modules/RenderWindowManagerUI/include/QmitkRenderWindowDataStorageTreeModel.h +++ b/Modules/QtWidgets/include/QmitkRenderWindowDataStorageTreeModel.h @@ -1,132 +1,132 @@ /*============================================================================ 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 QMITKDATASTORAGERENDERWINDOWTREEMODEL_H #define QMITKDATASTORAGERENDERWINDOWTREEMODEL_H // render window manager UI model -#include "MitkRenderWindowManagerUIExports.h" +#include "MitkQtWidgetsExports.h" // render window manager module #include "mitkRenderWindowLayerController.h" #include "mitkRenderWindowLayerUtilities.h" //mitk core #include // qt widgets module #include #include /* * @brief The 'QmitkRenderWindowDataStorageTreeModel' is a tree model derived from the 'QmitkAbstractDataStorageModel'. */ -class MITKRENDERWINDOWMANAGERUI_EXPORT QmitkRenderWindowDataStorageTreeModel : public QmitkAbstractDataStorageModel +class MITKQTWIDGETS_EXPORT QmitkRenderWindowDataStorageTreeModel : public QmitkAbstractDataStorageModel { Q_OBJECT public: QmitkRenderWindowDataStorageTreeModel(QObject* parent = nullptr); // override from 'QmitkAbstractDataStorageModel' /** * @brief See 'QmitkAbstractDataStorageModel' */ void DataStorageChanged() override; /** * @brief See 'QmitkAbstractDataStorageModel' */ void NodePredicateChanged() override; /** * @brief See 'QmitkAbstractDataStorageModel' */ void NodeAdded(const mitk::DataNode* node) override; /** * @brief See 'QmitkAbstractDataStorageModel' */ void NodeChanged(const mitk::DataNode* node) override; /** * @brief See 'QmitkAbstractDataStorageModel' */ void NodeRemoved(const mitk::DataNode* node) override; // override from 'QAbstractItemModel' QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const override; QModelIndex parent(const QModelIndex& parent) const override; int rowCount(const QModelIndex& parent = QModelIndex()) const override; int columnCount(const QModelIndex& parent = QModelIndex()) const override; QVariant data(const QModelIndex& index, int role) const override; bool setData(const QModelIndex& index, const QVariant& value, int role = Qt::EditRole) override; Qt::ItemFlags flags(const QModelIndex& index) const override; Qt::DropActions supportedDropActions() const override; Qt::DropActions supportedDragActions() const override; QStringList mimeTypes() const override; QMimeData* mimeData(const QModelIndexList& indexes) const override; bool dropMimeData(const QMimeData* data, Qt::DropAction action, int row, int column, const QModelIndex& parent) override; void SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer); void SetCurrentRenderer(mitk::BaseRenderer* baseRenderer); mitk::BaseRenderer::Pointer GetCurrentRenderer() const; private: void ResetTree(); void UpdateModelData(); /** * @brief Adjust the layer property according to the current tree. * The function will set the "layer" property of each underlying data node so that it fits the * the actual hierarchy represented by the current tree. */ void AdjustLayerProperty(); /** * @brief Fill a vector of tree items in a depth-first order (child-first). */ void TreeToVector(QmitkDataStorageTreeModelInternalItem* parent, std::vector& treeAsVector) const; /** * @brief Add the given data node to the tree of the given renderer. * The given renderer specifies the "layer"-property that is used for adding the new tree item * to the tree. The "layer"-property may be different for each renderer resulting in a * different tree for each renderer. * * @param dataNode The data node that should be added. * @param renderer The base renderer to which the data node should be added. */ void AddNodeInternal(const mitk::DataNode* dataNode, const mitk::BaseRenderer* renderer); /** * @brief Remove the tree item that contains the given data node. Removing an item may * leave the child items of the removed item without a parent. In this case * the children have to be moved inside the tree so the tree has to be rebuild * according to the current status of the data storage. * * @param dataNode The data node that should be removed. */ void RemoveNodeInternal(const mitk::DataNode* dataNode); mitk::DataNode* GetParentNode(const mitk::DataNode* node) const; QmitkDataStorageTreeModelInternalItem* GetItemByIndex(const QModelIndex& index) const; QModelIndex GetIndexByItem(QmitkDataStorageTreeModelInternalItem* item) const; std::unique_ptr m_RenderWindowLayerController; mitk::RenderWindowLayerUtilities::RendererVector m_ControlledRenderer; QmitkDataStorageTreeModelInternalItem* m_Root; mitk::WeakPointer m_BaseRenderer; }; #endif // QMITKDATASTORAGERENDERWINDOWTREEMODEL_H diff --git a/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h new file mode 100644 index 0000000000..56502e704d --- /dev/null +++ b/Modules/QtWidgets/include/QmitkRenderWindowUtilityWidget.h @@ -0,0 +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 QMITKRENDERWINDOWUTILITYWIDGET_H +#define QMITKRENDERWINDOWUTILITYWIDGET_H + +// qt widgets module +#include "MitkQtWidgetsExports.h" +#include "QmitkSliderNavigatorWidget.h" +#include "QmitkStepperAdapter.h" +#include "QmitkRenderWindow.h" +#include "QmitkRenderWindowContextDataStorageInspector.h" +#include "mitkRenderWindowViewDirectionController.h" + +// mitk core +#include "mitkDataStorage.h" + +// qt +#include +#include +#include +#include + +class MITKQTWIDGETS_EXPORT QmitkRenderWindowUtilityWidget : public QWidget +{ + Q_OBJECT + +public: + QmitkRenderWindowUtilityWidget( + QWidget* parent = nullptr, + QmitkRenderWindow* renderWindow = nullptr, + mitk::DataStorage* dataStorage = nullptr + ); + + ~QmitkRenderWindowUtilityWidget() override; + + void SetInvertedSliceNavigation(bool inverted); + +Q_SIGNALS: + + void ReinitAction(QList selectedNodes); + void ResetAction(QList selectedNodes); + +private: + + QHBoxLayout* m_Layout; + QMenuBar* m_MenuBar; + + QmitkRenderWindow* m_RenderWindow; + mitk::DataStorage* m_DataStorage; + + QmitkRenderWindowContextDataStorageInspector* m_RenderWindowInspector; + QmitkSliderNavigatorWidget* m_SliceNavigator; + QmitkStepperAdapter* m_StepperAdapter; + std::unique_ptr m_RenderWindowViewDirectionController; + QComboBox* m_ViewDirectionSelector; + + void ChangeViewDirection(const QString& viewDirection); +}; + +#endif // QMITKRENDERWINDOWUTILITYWIDGET_H diff --git a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h index f72268056c..22e62fc3d6 100644 --- a/Modules/QtWidgets/include/QmitkRenderWindowWidget.h +++ b/Modules/QtWidgets/include/QmitkRenderWindowWidget.h @@ -1,114 +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 // qt widgets module #include "MitkQtWidgetsExports.h" #include "QmitkRenderWindow.h" +#include "QmitkRenderWindowUtilityWidget.h" // mitk core #include #include #include // qt #include -#include #include 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); + mitk::DataStorage* dataStorage = nullptr, + bool windowControls = false); ~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 SetGradientBackgroundColors(const mitk::Color& upper, const mitk::Color& lower); void ShowGradientBackground(bool enable); std::pair 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 AddPlanesToDataStorage(); void RemovePlanesFromDataStorage(); void SetCrosshairPosition(const mitk::Point3D& newPosition); mitk::Point3D GetCrosshairPosition() const; void SetGeometry(const itk::EventObject& event); +private Q_SLOTS: + + void OnReinitAction(QList selectedNodes); + void OnResetAction(QList selectedNodes); + private: void InitializeGUI(); void InitializeDecorations(); + void ComputeInvertedSliceNavigation(); QString m_WidgetName; - QHBoxLayout* m_Layout; + QVBoxLayout* m_Layout; mitk::DataStorage* m_DataStorage; QmitkRenderWindow* m_RenderWindow; mitk::CrosshairManager::Pointer m_CrosshairManager; std::pair m_GradientBackgroundColors; mitk::Color m_DecorationColor; vtkSmartPointer m_CornerAnnotation; + QmitkRenderWindowUtilityWidget* m_UtilityWidget; + + bool m_WindowControls; + }; #endif // QMITKRENDERWINDOWWIDGET_H diff --git a/Modules/QtWidgetsExt/include/QmitkSliderNavigatorWidget.h b/Modules/QtWidgets/include/QmitkSliderNavigatorWidget.h similarity index 94% rename from Modules/QtWidgetsExt/include/QmitkSliderNavigatorWidget.h rename to Modules/QtWidgets/include/QmitkSliderNavigatorWidget.h index 76a054de7f..bdc105e109 100644 --- a/Modules/QtWidgetsExt/include/QmitkSliderNavigatorWidget.h +++ b/Modules/QtWidgets/include/QmitkSliderNavigatorWidget.h @@ -1,122 +1,122 @@ /*============================================================================ 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 QMITKSLIDERNAVIGATORWIDGET_H_ #define QMITKSLIDERNAVIGATORWIDGET_H_ -#include "MitkQtWidgetsExtExports.h" #include "ui_QmitkSliderNavigator.h" +#include "MitkQtWidgetsExports.h" #include #include #include -class MITKQTWIDGETSEXT_EXPORT QmitkSliderNavigatorWidget : public QWidget, public Ui::QmitkSliderNavigator +class MITKQTWIDGETS_EXPORT QmitkSliderNavigatorWidget : public QWidget, public Ui::QmitkSliderNavigator { Q_OBJECT public: QmitkSliderNavigatorWidget(QWidget *parent = nullptr, Qt::WindowFlags f = nullptr); QString GetLabelUnit(); /** * \brief Converts the passed value to a QString representation. * * If the value exceeds a certain maximum, "INF" (for "infinity") is displayed * instead. */ QString ClippedValueToString(float value); /** * \brief Returns range-minimum (displayed as label left of slider if enabled) */ QString GetMinValueLabel(); QString GetMaxValueLabel(); int GetPos(); bool GetInverseDirection() const; bool GetInvertedControls() const; public slots: /** * \brief Updates the slider with the recent changes applied to the navigator. * * Intended to be called via event mechanism, e.g. if the connected * mitk::Stepper is modified. */ void Refetch(); void SetStepper(mitk::Stepper *stepper); void ShowLabels(bool show); /** * \brief En-/disables displaying of the unit label (range will be displayed * without unit if enabled). */ void ShowLabelUnit(bool show); void SetPos(int val); void SetInverseDirection(bool inverseDirection); void SetInvertedControls(bool invertedControls); protected slots: void slider_valueChanged(double); /** * \brief Set range minimum and maximum (displayed as labels left and right * of slider if enabled) */ void SetLabelValues(float min, float max); void SetLabelValuesValid(bool minValid, bool maxValid); /** * \brief Set range unit (e.g. mm or ms) which will be displayed below range * labels if enabled. */ void SetLabelUnit(const char *unit); /** * \brief Configure slider with labels according to range and unit settings */ void SetLabels(); void spinBox_valueChanged(double); protected: bool m_HasLabelUnit; bool m_MaxValueValid; bool m_MinValueValid; QString m_LabelUnit; mitk::Stepper::Pointer m_Stepper; bool m_InRefetch; bool m_HasLabels; float m_MinValue; float m_MaxValue; bool m_InverseDirection; bool m_InvertedControls; }; #endif diff --git a/Modules/QtWidgetsExt/include/QmitkStepperAdapter.h b/Modules/QtWidgets/include/QmitkStepperAdapter.h similarity index 92% rename from Modules/QtWidgetsExt/include/QmitkStepperAdapter.h rename to Modules/QtWidgets/include/QmitkStepperAdapter.h index 403e2370e5..afe8d05515 100644 --- a/Modules/QtWidgetsExt/include/QmitkStepperAdapter.h +++ b/Modules/QtWidgets/include/QmitkStepperAdapter.h @@ -1,74 +1,74 @@ /*============================================================================ 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 QMITKSTEPPERADAPTER_H_HEADER_INCLUDED_C1E77191 #define QMITKSTEPPERADAPTER_H_HEADER_INCLUDED_C1E77191 -#include "MitkQtWidgetsExtExports.h" #include "itkCommand.h" #include "itkObject.h" #include "mitkStepper.h" #include "qobject.h" +#include "MitkQtWidgetsExports.h" //##Documentation //## @brief Helper class to connect Qt-based navigators to instances of Stepper //## //## The constructor has to be provided with the \a Navigator //## that wants to use the \a Stepper. The \a Navigator has to define the //## slots \a Refetch() and \a SetStepper(mitk::Stepper *). \a SetStepper will be //## called only once to pass the \a Stepper to the \a Navigator. When the values of //## the \a Stepper changes, \a Refetch() will be called. The \a Navigator can than //## ask the \a Stepper for its new values. //## \warning The \a Navigator has to be aware that it might have caused the changes //## of the \a Stepper itself. So take care that no infinite recursion is created! //## @ingroup NavigationControl -class MITKQTWIDGETSEXT_EXPORT QmitkStepperAdapter : public QObject +class MITKQTWIDGETS_EXPORT QmitkStepperAdapter : public QObject { Q_OBJECT public: QmitkStepperAdapter(QObject *navigator, mitk::Stepper *stepper, const char *name); ~QmitkStepperAdapter() override; void SetStepper(mitk::Stepper *stepper) { this->SendStepper(stepper); this->Refetch(); } - class MITKQTWIDGETSEXT_EXPORT ItkEventListener : public itk::Command + class ItkEventListener : public itk::Command { public: mitkClassMacroItkParent(ItkEventListener, itk::Command); ItkEventListener(QmitkStepperAdapter *receiver) : m_Receiver(receiver){ }; void Execute(itk::Object *, const itk::EventObject &) override { emit m_Receiver->Refetch(); }; void Execute(const itk::Object *, const itk::EventObject &) override { emit m_Receiver->Refetch(); }; protected: QmitkStepperAdapter *m_Receiver; }; signals: void signal_dummy(); void Refetch(); void SendStepper(mitk::Stepper *); protected: mitk::Stepper::Pointer m_Stepper; long m_ObserverTag; friend class QmitkStepperAdapter::ItkEventListener; ItkEventListener::Pointer m_ItkEventListener; }; #endif diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h b/Modules/QtWidgets/include/mitkRenderWindowLayerController.h similarity index 98% rename from Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h rename to Modules/QtWidgets/include/mitkRenderWindowLayerController.h index d8fffebf2d..58f7e37929 100644 --- a/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h +++ b/Modules/QtWidgets/include/mitkRenderWindowLayerController.h @@ -1,174 +1,174 @@ /*============================================================================ 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 MITKRENDERWINDOWLAYERCONTROLLER_H #define MITKRENDERWINDOWLAYERCONTROLLER_H -// render window manager module -#include "MitkRenderWindowManagerExports.h" +// qt widgets module +#include "MitkQtWidgetsExports.h" #include "mitkRenderWindowLayerUtilities.h" // mitk core #include #include #include namespace mitk { /** * The RenderWindowLayerController is used to manipulate the 'layer', 'fixedLayer' and 'visible' property of a given data node. * The 'layer' property is used to denote the layer level of a data node. Data from nodes on higher layer level are rendered * on top of data from nodes on lower layer level. It can be changed using the 'MoveNode*'-functions. * * To view the data of a data node only in a specific renderer, the "InsertLayerNode'-function should be used. It inserts the * given node into the specified renderer and sets the corresponding properties. * To hide the data in the common renderer view (all renderer), the 'HideDataNodeInAllRenderer'-function can be used. * Inserting and showing a data node in a specific renderer / render window, will overwrite the properties of the common renderer view. * * For more information about the data node properties for specific renderer, see mitk::DataNode- and mitk::PropertyList-classes. * * Functions with 'mitk::BaseRenderer* renderer' have 'nullptr' as their default argument. Using the nullptr * these functions operate on all base renderer. Giving a specific base renderer will modify the node only for the given renderer. */ - class MITKRENDERWINDOWMANAGER_EXPORT RenderWindowLayerController + class MITKQTWIDGETS_EXPORT RenderWindowLayerController { public: RenderWindowLayerController(); /** * @brief Set the data storage on which to work. */ void SetDataStorage(DataStorage::Pointer dataStorage); /** * @brief Set the controlled base renderer. */ void SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer); // wrapper functions to modify the layer order / visibility of render window data /** * @brief Set the given node as the base node of the given renderer. * * @param dataNode The data node whose layer is to be modified. * @param renderer Pointer to the renderer instance for which the data node property should be modified. * If it is a nullptr (default) all controlled renderer will be affected. */ void SetBaseDataNode(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** * @brief Insert the given data node at the specified layer for the given renderer. * * @param dataNode The data node that should be inserted. * @param layer The layer value for the "layer" property of the data node (insertion level). "layer = RenderWindowLayerUtilities::TOP_LAYER_INDEX" (default) inserts the given data node at the top of the node stack (topmost layer). * @param renderer Pointer to the renderer instance for which the data node should be inserted. * If it is a nullptr (default) all controlled renderer will be affected. * * @post After a successful call, the "fixedLayer" and "visibility" property will be true and the "layer" property will be set correctly. */ void InsertLayerNode(DataNode* dataNode, int layer = RenderWindowLayerUtilities::TOP_LAYER_INDEX, const BaseRenderer* renderer = nullptr); /** * @brief Remove the given data node for the given renderer. * * @param dataNode The data node that should be removed. * @param renderer Pointer to the renderer instance for which the data node should be removed. * If it is a nullptr (default) all controlled renderer will be affected. * * @post After a successful call, the "fixedLayer" and "visibility" property will be false and the "layer" property will be deleted. */ void RemoveLayerNode(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** * @brief Move the data node to the given layer. This will change only the "layer" property. * * @param dataNode The data node that should be moved. * @param newLayer * @param renderer Pointer to the renderer instance for which the data node should be moved. * If it is a nullptr (default) all controlled renderer will be affected. */ bool MoveNodeToPosition(DataNode* dataNode, int newLayer, const BaseRenderer* renderer = nullptr); /** * @brief Set the node in the given renderer as the topmost layer. This will change only the "layer" property. * * @param dataNode The data node that should be moved. * @param renderer Pointer to the renderer instance for which the data node should be moved. * If it is a nullptr (default) all controlled renderer will be affected. */ bool MoveNodeToFront(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** * @brief Set the node in the given renderer as the lowermost layer. This will change only the "layer" property. * * @param dataNode The data node that should be moved. * @param renderer Pointer to the renderer instance for which the data node should be moved. * If it is a nullptr (default) all controlled renderer will be affected. */ bool MoveNodeToBack(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** * @brief Move the node in the given renderer one layer down. This will change only the "layer" property. * * @param dataNode The data node that should be moved. * @param renderer Pointer to the renderer instance for which the data node should be moved. * If it is a nullptr (default) all controlled renderer will be affected. */ bool MoveNodeUp(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** * @brief Move the node in the given renderer one layer up. This will change only the "layer" property. * * @param dataNode The data node that should be moved. * @param renderer Pointer to the renderer instance for which the data node should be moved. * If it is a nullptr (default) all controlled renderer will be affected. */ bool MoveNodeDown(DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** * @brief Set the visibility of the given data node for the given renderer. * * @param visibility Boolean to set the "visible" property of the given data node. * @param dataNode The data node that should be moved. * @param renderer Pointer to the renderer instance for which the data node should be modified. * If it is a nullptr (default) all controlled renderer will be affected. * * @post After a successful call , the "visibility" property will be set to the "visibility" value. */ void SetVisibilityOfDataNode(bool visibility, DataNode* dataNode, const BaseRenderer* renderer = nullptr); /** * @brief Hide the given data node by setting the "visible" property of the data node for * all controlled renderer to false. * Later setting the "visible" property of the data node for a certain renderer will overwrite * the same property of the common renderer. * * @param dataNode The data node that should be hid. * * @post After a successful call , the "visibility" property will be set to the false. */ void HideDataNodeInAllRenderer(const DataNode* dataNode); /** * @brief Reset the given render window: * If "onlyVisibility = true": set all data nodes for the given render window to invisible, except for the base node. * If "onlyVisibility = false": remove all data nodes from the render window, except for the base node. * * @param onlyVisibility Boolean to define the reset mode. * @param renderer Pointer to the renderer instance for which the data node should be reset. * If it is a nullptr (default) all controlled renderer will be affected. * * @post After a successful call , the "visibility" property will be set to the "false" value (except for the base node). * If "onlyVisibility = false": additionally the "fixedLayer" property will be false and the "layer" property will be deleted. */ void ResetRenderer(bool onlyVisibility = true, const BaseRenderer* renderer = nullptr); private: void InsertLayerNodeInternal(DataNode* dataNode, int layer, const BaseRenderer* renderer = nullptr); DataStorage::Pointer m_DataStorage; RenderWindowLayerUtilities::RendererVector m_ControlledRenderer; }; } // namespace mitk #endif // MITKRENDERWINDOWLAYERCONTROLLER_H diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h b/Modules/QtWidgets/include/mitkRenderWindowLayerUtilities.h similarity index 87% rename from Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h rename to Modules/QtWidgets/include/mitkRenderWindowLayerUtilities.h index c87efddf12..914c9007a5 100644 --- a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h +++ b/Modules/QtWidgets/include/mitkRenderWindowLayerUtilities.h @@ -1,75 +1,75 @@ /*============================================================================ 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 MITKRENDERWINDOWLAYERUTILITIES_H #define MITKRENDERWINDOWLAYERUTILITIES_H -// render window manager module -#include "MitkRenderWindowManagerExports.h" +// qt widgets module +#include "MitkQtWidgetsExports.h" // mitk core #include #include #include #include /** * @brief Render window layer helper functions to retrieve the currently valid layer stack */ namespace mitk { namespace RenderWindowLayerUtilities { typedef std::vector RendererVector; typedef std::map> LayerStack; /** * The base data node of a renderer is supposed to be on layer 0 (zero), which should be the lowest layer in a render window. */ const int BASE_LAYER_INDEX = 0; /** * The top layer index, denoting that no valid (positive) layer index is given and therefore the index should be resolved into the topmost layer index. */ const int TOP_LAYER_INDEX = -1; /** * @brief Return the stack of layers of the given renderer as std::map, which guarantees ordering of the layers. * Stacked layers are only included if they have their "fixedLayer" property set to true and their "layer" property set. * * If "renderer" = nullptr: a layer stack won't be created and an empty "LayerStack" will be returned. * If "withBaseNode" = true: include the base node in the layer stack, if existing. * If "withBaseNode" = false: exclude the base node from the layer stack. * * @param dataStorage Pointer to a data storage instance whose data nodes should be checked and possibly be included. * @param renderer Pointer to the renderer instance for which the layer stack should be generated. * @param withBaseNode Boolean to decide whether the base node should be included in or excluded from the layer stack. */ - MITKRENDERWINDOWMANAGER_EXPORT LayerStack GetLayerStack(const DataStorage* dataStorage, const BaseRenderer* renderer, bool withBaseNode); + MITKQTWIDGETS_EXPORT LayerStack GetLayerStack(const DataStorage* dataStorage, const BaseRenderer* renderer, bool withBaseNode); /** * @brief Helper function to get a node predicate that can be used to filter render window specific data nodes. * * The data nodes must not be 'helper objects'. The must have set a 'fixed layer' property for the given renderer. */ - MITKRENDERWINDOWMANAGER_EXPORT NodePredicateAnd::Pointer GetRenderWindowPredicate(const BaseRenderer* renderer); + MITKQTWIDGETS_EXPORT NodePredicateAnd::Pointer GetRenderWindowPredicate(const BaseRenderer* renderer); /** * @brief Set renderer-specific properties to mark a data node as 'managed by the specific renderer'. * In order for a renderer to manage a data node, the 'fixedLayer' property has to be set for the given renderer. * Additionally, the 'visible' and the 'layer' property are set and allow to individually render a set of nodes * with a specific renderer. * The last two mentioned properties are set so that they initially have the same value as the corresponding * global property. */ - MITKRENDERWINDOWMANAGER_EXPORT void SetRenderWindowProperties(mitk::DataNode* dataNode, const BaseRenderer* renderer); + MITKQTWIDGETS_EXPORT void SetRenderWindowProperties(mitk::DataNode* dataNode, const BaseRenderer* renderer); } // namespace RenderWindowLayerUtilities } // namespace mitk #endif // MITKRENDERWINDOWLAYERUTILITIES_H diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h b/Modules/QtWidgets/include/mitkRenderWindowViewDirectionController.h similarity index 95% rename from Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h rename to Modules/QtWidgets/include/mitkRenderWindowViewDirectionController.h index 2224b41fe4..576dc1d889 100644 --- a/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h +++ b/Modules/QtWidgets/include/mitkRenderWindowViewDirectionController.h @@ -1,82 +1,82 @@ /*============================================================================ 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 MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H #define MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H -// render window manager module -#include "MitkRenderWindowManagerExports.h" +// qt widgets module +#include "MitkQtWidgetsExports.h" #include "mitkRenderWindowLayerUtilities.h" // mitk core #include #include namespace mitk { /** * The RenderWindowViewDirectionController is used to manipulate the 'sliceNavigationController' of a given base renderer. * The 'sliceNavigationController' is used to set the view direction / camera perspective of a base renderer. * The view direction can be changed to 'mitk::SliceNavigationController::Axial', 'mitk::SliceNavigationController::Coronal' * or 'mitk::SliceNavigationController::Sagittal'. * * Functions with 'mitk::BaseRenderer* renderer' have 'nullptr' as their default argument. Using the nullptr * these functions operate on all base renderer. Giving a specific base renderer will modify the view direction only for the given renderer. */ - class MITKRENDERWINDOWMANAGER_EXPORT RenderWindowViewDirectionController + class MITKQTWIDGETS_EXPORT RenderWindowViewDirectionController { public: using ViewDirection = mitk::SliceNavigationController::ViewDirection; RenderWindowViewDirectionController(); /** * @brief Set the data storage on which to work. */ void SetDataStorage(DataStorage::Pointer dataStorage); /** * @brief Set the controlled base renderer. */ void SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer); // wrapper functions to modify the view direction /** * @brief Set the view direction for the given renderer (nullptr = all renderer) * @param viewDirection The view direction that should be used for this renderer as a string. * Currently "axial", "coronal" and "sagittal" is supported. * @param renderer Pointer to the renderer instance for which the view direction should be changed. * If it is a nullptr (default) all controlled renderer will be affected. */ void SetViewDirectionOfRenderer(const std::string& viewDirection, BaseRenderer* renderer = nullptr); /** * @brief Set the view direction for the given renderer (nullptr = all renderer) * @param viewDirection The view direction that should be used for this renderer. * @param renderer Pointer to the renderer instance for which the view direction should be changed. * If it is a nullptr (default) nothing happens. */ void SetViewDirectionOfRenderer(ViewDirection viewDirection, BaseRenderer* renderer = nullptr); /** * @brief Reinitialize the given renderer with the currently visible nodes. * @param renderer Pointer to the renderer instance for which the view direction should be changed. * If it is a nullptr (default) all controlled renderer will be affected. */ void InitializeViewByBoundingObjects(const BaseRenderer* renderer); private: DataStorage::Pointer m_DataStorage; RenderWindowLayerUtilities::RendererVector m_ControlledRenderer; }; } // namespace mitk #endif // MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp index 3409c04ce2..f66d3c6ad0 100644 --- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp +++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp @@ -1,348 +1,348 @@ /*============================================================================ 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" #include "QmitkRenderWindowWidget.h" // mitk core #include #include #include // qt #include #include QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent, Qt::WindowFlags f/* = 0*/, const QString& multiWidgetName/* = "mxnmulti"*/) : QmitkAbstractMultiWidget(parent, f, multiWidgetName) , m_TimeNavigationController(nullptr) , m_CrosshairVisibility(false) { m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController(); } QmitkMxNMultiWidget::~QmitkMxNMultiWidget() { auto allRenderWindows = this->GetRenderWindows(); for (auto& renderWindow : allRenderWindows) { m_TimeNavigationController->Disconnect(renderWindow->GetSliceNavigationController()); } } void QmitkMxNMultiWidget::InitializeMultiWidget() { SetLayout(1, 1); SetDisplayActionEventHandler(std::make_unique()); auto displayActionEventHandler = GetDisplayActionEventHandler(); if (nullptr != displayActionEventHandler) { displayActionEventHandler->InitActions(); } } void QmitkMxNMultiWidget::Synchronize(bool synchronized) { if (synchronized) { SetDisplayActionEventHandler(std::make_unique()); } else { SetDisplayActionEventHandler(std::make_unique()); } 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::BaseRenderer::ViewDirection& /*viewDirection*/) const { // currently no mapping between view directions 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::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) { RenderWindowWidgetPointer renderWindowWidget; if (widgetName.isNull()) { renderWindowWidget = GetActiveRenderWindowWidget(); } else { renderWindowWidget = GetRenderWindowWidget(widgetName); } if (nullptr != renderWindowWidget) { renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition); renderWindowWidget->SetCrosshairPosition(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()) { 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(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(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(sender()); if (nullptr == renderWindow) { return; } mitk::RenderingManager::GetInstance()->InitializeViewByBoundingObjects(renderWindow->GetRenderWindow(), 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; } } mitk::SliceNavigationController* QmitkMxNMultiWidget::GetTimeNavigationController() { return m_TimeNavigationController; } void QmitkMxNMultiWidget::AddPlanesToDataStorage() { auto renderWindowWidgets = this->GetRenderWindowWidgets(); for (const auto& renderWindowWidget : renderWindowWidgets) { renderWindowWidget.second->AddPlanesToDataStorage(); } } void QmitkMxNMultiWidget::RemovePlanesFromDataStorage() { auto renderWindowWidgets = this->GetRenderWindowWidgets(); for (const auto& renderWindowWidget : renderWindowWidgets) { renderWindowWidget.second->RemovePlanesFromDataStorage(); } } ////////////////////////////////////////////////////////////////////////// // 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(); } void QmitkMxNMultiWidget::RemoveRenderWindowWidget() { auto renderWindowWidgets = this->GetRenderWindowWidgets(); auto iterator = renderWindowWidgets.find(this->GetNameFromIndex(this->GetNumberOfRenderWindowWidgets() - 1)); if (iterator == renderWindowWidgets.end()) { return; } // disconnect each signal of this render window widget RenderWindowWidgetPointer renderWindowWidgetToRemove = iterator->second; m_TimeNavigationController->Disconnect(renderWindowWidgetToRemove->GetSliceNavigationController()); QmitkAbstractMultiWidget::RemoveRenderWindowWidget(); } ////////////////////////////////////////////////////////////////////////// // 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); } void QmitkMxNMultiWidget::CreateRenderWindowWidget() { // create the render window widget and connect signal / slot QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets()); - RenderWindowWidgetPointer renderWindowWidget = std::make_shared(this, renderWindowWidgetName, GetDataStorage()); + RenderWindowWidgetPointer renderWindowWidget = std::make_shared(this, renderWindowWidgetName, GetDataStorage(), true); renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString()); AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget); auto renderWindow = renderWindowWidget->GetRenderWindow(); 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); // connect time navigation controller to react on geometry time events with the render window's slice naviation controller m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow->GetSliceNavigationController()); // reverse connection between the render window's slice navigation controller and the time navigation controller renderWindow->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController); } diff --git a/Modules/QtWidgets/src/QmitkRenderWindowContextDataStorageInspector.cpp b/Modules/QtWidgets/src/QmitkRenderWindowContextDataStorageInspector.cpp new file mode 100644 index 0000000000..3758aaaa10 --- /dev/null +++ b/Modules/QtWidgets/src/QmitkRenderWindowContextDataStorageInspector.cpp @@ -0,0 +1,157 @@ +/*============================================================================ + +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. + +============================================================================*/ + +// render window manager UI module +#include "QmitkRenderWindowContextDataStorageInspector.h" + +#include +#include + +// qt +#include +#include + +QmitkRenderWindowContextDataStorageInspector::QmitkRenderWindowContextDataStorageInspector( + QWidget* parent /* =nullptr */, + mitk::BaseRenderer* renderer /* = nullptr */) + : QmitkAbstractDataStorageInspector(parent) +{ + m_Controls.setupUi(this); + + mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer{ renderer }; + + // initialize the render window layer controller and the render window view direction controller + m_RenderWindowLayerController = std::make_unique(); + m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer); + + m_StorageModel = std::make_unique(this); + m_StorageModel->SetControlledRenderer(controlledRenderer); + + m_Controls.renderWindowTreeView->setModel(m_StorageModel.get()); + m_Controls.renderWindowTreeView->setHeaderHidden(true); + m_Controls.renderWindowTreeView->setEditTriggers(QAbstractItemView::NoEditTriggers); + m_Controls.renderWindowTreeView->setSelectionBehavior(QAbstractItemView::SelectRows); + m_Controls.renderWindowTreeView->setSelectionMode(QAbstractItemView::ExtendedSelection); + m_Controls.renderWindowTreeView->setAlternatingRowColors(true); + m_Controls.renderWindowTreeView->setDragEnabled(true); + m_Controls.renderWindowTreeView->setDropIndicatorShown(true); + m_Controls.renderWindowTreeView->setAcceptDrops(true); + m_Controls.renderWindowTreeView->setContextMenuPolicy(Qt::CustomContextMenu); + + connect(m_Controls.renderWindowTreeView, &QTreeView::customContextMenuRequested, + this, &QmitkRenderWindowContextDataStorageInspector::OnContextMenuRequested); + + SetUpConnections(); + + if (nullptr == renderer) + { + return; + } + + m_StorageModel->SetCurrentRenderer(renderer); +} + +QAbstractItemView* QmitkRenderWindowContextDataStorageInspector::GetView() +{ + return m_Controls.renderWindowTreeView; +} + +const QAbstractItemView* QmitkRenderWindowContextDataStorageInspector::GetView() const +{ + return m_Controls.renderWindowTreeView; +} + +void QmitkRenderWindowContextDataStorageInspector::SetSelectionMode(SelectionMode mode) +{ + m_Controls.renderWindowTreeView->setSelectionMode(mode); +} + +QmitkRenderWindowContextDataStorageInspector::SelectionMode QmitkRenderWindowContextDataStorageInspector::GetSelectionMode() const +{ + return m_Controls.renderWindowTreeView->selectionMode(); +} + +QItemSelectionModel* QmitkRenderWindowContextDataStorageInspector::GetDataNodeSelectionModel() const +{ + return m_Controls.renderWindowTreeView->selectionModel(); +} + +void QmitkRenderWindowContextDataStorageInspector::Initialize() +{ + auto dataStorage = m_DataStorage.Lock(); + + if (dataStorage.IsNull()) + return; + + m_StorageModel->SetDataStorage(dataStorage); + m_StorageModel->SetNodePredicate(m_NodePredicate); + + m_RenderWindowLayerController->SetDataStorage(dataStorage); + + m_Connector->SetView(m_Controls.renderWindowTreeView); +} + +void QmitkRenderWindowContextDataStorageInspector::SetUpConnections() +{ + connect(m_StorageModel.get(), &QAbstractItemModel::rowsInserted, this, &QmitkRenderWindowContextDataStorageInspector::ModelRowsInserted); +} + +void QmitkRenderWindowContextDataStorageInspector::ModelRowsInserted(const QModelIndex& parent, int /*start*/, int /*end*/) +{ + m_Controls.renderWindowTreeView->setExpanded(parent, true); +} + +void QmitkRenderWindowContextDataStorageInspector::ResetRenderer() +{ + m_RenderWindowLayerController->ResetRenderer(true, m_StorageModel->GetCurrentRenderer()); + m_Controls.renderWindowTreeView->clearSelection(); +} + +void QmitkRenderWindowContextDataStorageInspector::OnContextMenuRequested(const QPoint& pos) +{ + QMenu contextMenu; + contextMenu.addAction(tr("Reinit with node"), this, &QmitkRenderWindowContextDataStorageInspector::OnReinit); + contextMenu.addAction(tr("Reset to node geometry"), this, &QmitkRenderWindowContextDataStorageInspector::OnReset); + + contextMenu.exec(this->mapToGlobal(pos)); +} + +void QmitkRenderWindowContextDataStorageInspector::OnReinit() +{ + auto nodes = this->GetSelectedNodes(); + emit ReinitAction(nodes); +} + +void QmitkRenderWindowContextDataStorageInspector::OnReset() +{ + auto nodes = this->GetSelectedNodes(); + emit ResetAction(nodes); +} + +QList QmitkRenderWindowContextDataStorageInspector::GetSelectedNodes() +{ + auto baseRenderer = m_StorageModel->GetCurrentRenderer(); + + QList nodes; + QModelIndexList selectedIndexes = this->GetDataNodeSelectionModel()->selectedIndexes(); + for (const auto& index : qAsConst(selectedIndexes)) + { + QVariant qvariantDataNode = m_StorageModel->data(index, QmitkDataNodeRole); + if (qvariantDataNode.canConvert()) + { + mitk::DataNode* dataNode = qvariantDataNode.value(); + nodes.insert(nodes.size(), dataNode); + } + } + + return nodes; +} diff --git a/Modules/QtWidgets/src/QmitkRenderWindowContextDataStorageInspector.ui b/Modules/QtWidgets/src/QmitkRenderWindowContextDataStorageInspector.ui new file mode 100644 index 0000000000..bfed98a9a7 --- /dev/null +++ b/Modules/QtWidgets/src/QmitkRenderWindowContextDataStorageInspector.ui @@ -0,0 +1,43 @@ + + + QmitkRenderWindowContextDataStorageInspector + + + + 0 + 0 + 340 + 246 + + + + + 0 + 0 + + + + + 0 + 0 + + + + Render window manager + + + + + + Render window overview + + + + + + + + + + + diff --git a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp b/Modules/QtWidgets/src/QmitkRenderWindowDataStorageTreeModel.cpp similarity index 98% rename from Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp rename to Modules/QtWidgets/src/QmitkRenderWindowDataStorageTreeModel.cpp index 70a3d1c434..a97f95f694 100644 --- a/Modules/RenderWindowManagerUI/src/QmitkRenderWindowDataStorageTreeModel.cpp +++ b/Modules/QtWidgets/src/QmitkRenderWindowDataStorageTreeModel.cpp @@ -1,600 +1,607 @@ /*============================================================================ 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. ============================================================================*/ // render window manager UI module #include "QmitkRenderWindowDataStorageTreeModel.h" // mitk core #include // qt widgets module #include "QmitkCustomVariants.h" #include "QmitkEnums.h" #include "QmitkMimeTypes.h" #include "QmitkNodeDescriptorManager.h" QmitkRenderWindowDataStorageTreeModel::QmitkRenderWindowDataStorageTreeModel(QObject* parent /*= nullptr*/) : QmitkAbstractDataStorageModel(parent) , m_Root(nullptr) { m_RenderWindowLayerController = std::make_unique(); ResetTree(); } void QmitkRenderWindowDataStorageTreeModel::DataStorageChanged() { m_RenderWindowLayerController->SetDataStorage(m_DataStorage.Lock()); ResetTree(); UpdateModelData(); } void QmitkRenderWindowDataStorageTreeModel::NodePredicateChanged() { ResetTree(); UpdateModelData(); } void QmitkRenderWindowDataStorageTreeModel::NodeAdded(const mitk::DataNode* node) { for (const auto renderer : m_ControlledRenderer) { // add the node to each render window mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(const_cast(node), renderer); } auto baseRenderer = m_BaseRenderer.Lock(); if (baseRenderer.IsNotNull()) { AddNodeInternal(node, baseRenderer); } } void QmitkRenderWindowDataStorageTreeModel::NodeChanged(const mitk::DataNode* node) { auto item = m_Root->Find(node); if (nullptr != item) { auto parentItem = item->GetParent(); // as the root node should not be removed one should always have a parent item if (nullptr == parentItem) { return; } auto index = createIndex(item->GetIndex(), 0, item); emit dataChanged(index, index); } } void QmitkRenderWindowDataStorageTreeModel::NodeRemoved(const mitk::DataNode* node) { RemoveNodeInternal(node); } QModelIndex QmitkRenderWindowDataStorageTreeModel::index(int row, int column, const QModelIndex& parent) const { auto item = GetItemByIndex(parent); if (nullptr != item) { item = item->GetChild(row); } if (nullptr == item) { return QModelIndex(); } return createIndex(row, column, item); } QModelIndex QmitkRenderWindowDataStorageTreeModel::parent(const QModelIndex& parent) const { auto item = GetItemByIndex(parent); if (nullptr != item) { item = item->GetParent(); } if(nullptr == item) { return QModelIndex(); } if (item == m_Root) { return QModelIndex(); } return createIndex(item->GetIndex(), 0, item); } int QmitkRenderWindowDataStorageTreeModel::rowCount(const QModelIndex& parent /*= QModelIndex()*/) const { auto item = GetItemByIndex(parent); if (nullptr == item) { return 0; } return item->GetChildCount(); } int QmitkRenderWindowDataStorageTreeModel::columnCount(const QModelIndex&/* parent = QModelIndex()*/) const { if (0 == m_Root->GetChildCount()) { // no items stored, no need to display columns return 0; } return 1; } QVariant QmitkRenderWindowDataStorageTreeModel::data(const QModelIndex& index, int role) const { auto baseRenderer = m_BaseRenderer.Lock(); if (baseRenderer.IsNull()) { return QVariant(); } if (!index.isValid() || this != index.model()) { return QVariant(); } auto item = GetItemByIndex(index); if (nullptr == item) { return QVariant(); } auto dataNode = item->GetDataNode(); if (nullptr == dataNode) { return QVariant(); } if (Qt::CheckStateRole == role) { bool visibility = false; dataNode->GetVisibility(visibility, baseRenderer); if (visibility) { return Qt::Checked; } else { return Qt::Unchecked; } } else if (Qt::DisplayRole == role) { return QVariant(QString::fromStdString(dataNode->GetName())); } else if (Qt::ToolTipRole == role) { return QVariant("Name of the data node."); } else if (Qt::DecorationRole == role) { QmitkNodeDescriptor* nodeDescriptor = QmitkNodeDescriptorManager::GetInstance()->GetDescriptor(dataNode); return nodeDescriptor->GetIcon(dataNode); } else if (Qt::UserRole == role || QmitkDataNodeRawPointerRole == role) { // user role always returns a reference to the data node, // which can be used to modify the data node in the data storage return QVariant::fromValue(dataNode); } else if (QmitkDataNodeRole == role) { return QVariant::fromValue(mitk::DataNode::Pointer(dataNode)); } return QVariant(); } bool QmitkRenderWindowDataStorageTreeModel::setData(const QModelIndex& index, const QVariant& value, int role /*= Qt::EditRole*/) { auto baseRenderer = m_BaseRenderer.Lock(); if (baseRenderer.IsNull()) { return false; } if (!index.isValid() || this != index.model()) { return false; } auto item = GetItemByIndex(index); if (nullptr == item) { return false; } auto dataNode = item->GetDataNode(); if (nullptr == dataNode) { return false; } if (Qt::EditRole == role && !value.toString().isEmpty()) { dataNode->SetName(value.toString().toStdString().c_str()); emit dataChanged(index, index); return true; } if (Qt::CheckStateRole == role) { Qt::CheckState newCheckState = static_cast(value.toInt()); bool isVisible = newCheckState; dataNode->SetVisibility(isVisible, baseRenderer); emit dataChanged(index, index); mitk::RenderingManager::GetInstance()->RequestUpdate(baseRenderer->GetRenderWindow()); return true; } return false; } Qt::ItemFlags QmitkRenderWindowDataStorageTreeModel::flags(const QModelIndex& index) const { if (this != index.model()) { return Qt::NoItemFlags; } if (!index.isValid()) { return Qt::ItemIsDropEnabled; } auto item = GetItemByIndex(index); if (nullptr == item) { return Qt::NoItemFlags; } const auto dataNode = item->GetDataNode(); if (m_NodePredicate.IsNull() || m_NodePredicate->CheckNode(dataNode)) { return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled; } return Qt::NoItemFlags; } Qt::DropActions QmitkRenderWindowDataStorageTreeModel::supportedDropActions() const { return Qt::CopyAction | Qt::MoveAction; } Qt::DropActions QmitkRenderWindowDataStorageTreeModel::supportedDragActions() const { return Qt::CopyAction | Qt::MoveAction; } QStringList QmitkRenderWindowDataStorageTreeModel::mimeTypes() const { QStringList types = QAbstractItemModel::mimeTypes(); types << QmitkMimeTypes::DataNodePtrs; return types; } QMimeData* QmitkRenderWindowDataStorageTreeModel::mimeData(const QModelIndexList& indexes) const { QMimeData* mimeData = new QMimeData(); QByteArray encodedData; QDataStream stream(&encodedData, QIODevice::WriteOnly); for (const auto& index : indexes) { if (index.isValid()) { auto dataNode = data(index, QmitkDataNodeRawPointerRole).value(); stream << reinterpret_cast(dataNode); } } mimeData->setData(QmitkMimeTypes::DataNodePtrs, encodedData); return mimeData; } bool QmitkRenderWindowDataStorageTreeModel::dropMimeData(const QMimeData* data, Qt::DropAction action, int /*row*/, int /*column*/, const QModelIndex& parent) { auto baseRenderer = m_BaseRenderer.Lock(); if (baseRenderer.IsNull()) { return false; } if (action == Qt::IgnoreAction) { return true; } if (!data->hasFormat(QmitkMimeTypes::DataNodePtrs)) { return false; } if (!parent.isValid()) { return false; } int layer = -1; auto dataNode = this->data(parent, QmitkDataNodeRawPointerRole).value(); if (nullptr != dataNode) { dataNode->GetIntProperty("layer", layer, baseRenderer); } auto dataNodeList = QmitkMimeTypes::ToDataNodePtrList(data); for (const auto& dataNode : qAsConst(dataNodeList)) { m_RenderWindowLayerController->MoveNodeToPosition(dataNode, layer, baseRenderer); } ResetTree(); UpdateModelData(); AdjustLayerProperty(); return true; } void QmitkRenderWindowDataStorageTreeModel::SetControlledRenderer(mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer) { m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer); m_ControlledRenderer = controlledRenderer; ResetTree(); auto dataStorage = m_DataStorage.Lock(); if (dataStorage.IsNull()) { return; } for (const auto& renderer : controlledRenderer) { if (nullptr == renderer) { continue; } auto allDataNodes = dataStorage->GetAll(); for (const auto& dataNode : *allDataNodes) { // add the node to each render window mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(dataNode, renderer); } } } void QmitkRenderWindowDataStorageTreeModel::SetCurrentRenderer(mitk::BaseRenderer* baseRenderer) { if (m_BaseRenderer == baseRenderer) { return; } // base renderer changed // reset tree to build a new renderer-specific item hierarchy m_BaseRenderer = baseRenderer; ResetTree(); UpdateModelData(); } mitk::BaseRenderer::Pointer QmitkRenderWindowDataStorageTreeModel::GetCurrentRenderer() const { return m_BaseRenderer.Lock(); } void QmitkRenderWindowDataStorageTreeModel::ResetTree() { beginResetModel(); if (nullptr != m_Root) { m_Root->Delete(); } mitk::DataNode::Pointer rootDataNode = mitk::DataNode::New(); rootDataNode->SetName("Data Storage"); m_Root = new QmitkDataStorageTreeModelInternalItem(rootDataNode); endResetModel(); } void QmitkRenderWindowDataStorageTreeModel::UpdateModelData() { auto dataStorage = m_DataStorage.Lock(); if (dataStorage.IsNotNull()) { auto baseRenderer = m_BaseRenderer.Lock(); if (baseRenderer.IsNotNull()) { + auto allDataNodes = dataStorage->GetAll(); + for (const auto& dataNode : *allDataNodes) + { + // add the node to each render window + mitk::RenderWindowLayerUtilities::SetRenderWindowProperties(dataNode, baseRenderer); + } + mitk::NodePredicateAnd::Pointer combinedNodePredicate = mitk::RenderWindowLayerUtilities::GetRenderWindowPredicate(baseRenderer); auto filteredDataNodes = dataStorage->GetSubset(combinedNodePredicate); for (const auto& dataNode : *filteredDataNodes) { AddNodeInternal(dataNode, baseRenderer); } } } } void QmitkRenderWindowDataStorageTreeModel::AdjustLayerProperty() { auto baseRenderer = m_BaseRenderer.Lock(); if (baseRenderer.IsNull()) { return; } std::vector treeAsVector; TreeToVector(m_Root, treeAsVector); int i = treeAsVector.size() - 1; for (auto it = treeAsVector.begin(); it != treeAsVector.end(); ++it) { auto dataNode = (*it)->GetDataNode(); dataNode->SetIntProperty("layer", i, baseRenderer); --i; } } void QmitkRenderWindowDataStorageTreeModel::TreeToVector(QmitkDataStorageTreeModelInternalItem* parent, std::vector& treeAsVector) const { QmitkDataStorageTreeModelInternalItem* item; for (int i = 0; i < parent->GetChildCount(); ++i) { item = parent->GetChild(i); TreeToVector(item, treeAsVector); treeAsVector.push_back(item); } } void QmitkRenderWindowDataStorageTreeModel::AddNodeInternal(const mitk::DataNode* dataNode, const mitk::BaseRenderer* renderer) { if (nullptr == dataNode || m_DataStorage.IsExpired() || nullptr != m_Root->Find(dataNode)) { return; } // find out if we have a root node auto parentItem = m_Root; QModelIndex index; auto parentDataNode = GetParentNode(dataNode); if (nullptr != parentDataNode) // no top level data node { parentItem = m_Root->Find(parentDataNode); if (nullptr == parentItem) { // parent node not contained in the tree; add it NodeAdded(parentDataNode); parentItem = m_Root->Find(parentDataNode); if (nullptr == parentItem) { // could not find and add the parent tree; abort return; } } // get the index of this parent with the help of the grand parent index = createIndex(parentItem->GetIndex(), 0, parentItem); } int firstRowWithASiblingBelow = 0; int nodeLayer = -1; dataNode->GetIntProperty("layer", nodeLayer, renderer); for (const auto& siblingItem : parentItem->GetChildren()) { int siblingLayer = -1; auto siblingNode = siblingItem->GetDataNode(); if (nullptr != siblingNode) { siblingNode->GetIntProperty("layer", siblingLayer, renderer); } if (nodeLayer > siblingLayer) { break; } ++firstRowWithASiblingBelow; } beginInsertRows(index, firstRowWithASiblingBelow, firstRowWithASiblingBelow); auto newNode = new QmitkDataStorageTreeModelInternalItem(const_cast(dataNode)); parentItem->InsertChild(newNode, firstRowWithASiblingBelow); endInsertRows(); } void QmitkRenderWindowDataStorageTreeModel::RemoveNodeInternal(const mitk::DataNode* dataNode) { if (nullptr == dataNode || nullptr == m_Root) { return; } auto item = m_Root->Find(dataNode); if (nullptr == item) { return; } auto parentItem = item->GetParent(); auto parentIndex = GetIndexByItem(parentItem); auto children = item->GetChildren(); beginRemoveRows(parentIndex, item->GetIndex(), item->GetIndex()); parentItem->RemoveChild(item); delete item; endRemoveRows(); if (!children.empty()) { // rebuild tree because children could not be at the top level ResetTree(); UpdateModelData(); } } mitk::DataNode* QmitkRenderWindowDataStorageTreeModel::GetParentNode(const mitk::DataNode* node) const { mitk::DataNode* dataNode = nullptr; auto dataStorage = m_DataStorage.Lock(); if (dataStorage.IsNull()) { return dataNode; } auto sources = dataStorage->GetSources(node); if (sources->empty()) { return dataNode; } return sources->front(); } QmitkDataStorageTreeModelInternalItem* QmitkRenderWindowDataStorageTreeModel::GetItemByIndex(const QModelIndex& index) const { if (index.isValid()) { return static_cast(index.internalPointer()); } return m_Root; } QModelIndex QmitkRenderWindowDataStorageTreeModel::GetIndexByItem(QmitkDataStorageTreeModelInternalItem* item) const { if (item == m_Root) { return QModelIndex(); } return createIndex(item->GetIndex(), 0, item); } diff --git a/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp new file mode 100644 index 0000000000..0e035960a8 --- /dev/null +++ b/Modules/QtWidgets/src/QmitkRenderWindowUtilityWidget.cpp @@ -0,0 +1,95 @@ +/*============================================================================ + +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 + +QmitkRenderWindowUtilityWidget::QmitkRenderWindowUtilityWidget( + QWidget* parent/* = nullptr */, + QmitkRenderWindow* renderWindow/* = nullptr */, + mitk::DataStorage* dataStorage/* = nullptr */) + : m_Layout(nullptr) + , m_MenuBar(nullptr) + , m_RenderWindow(renderWindow) + , m_DataStorage(dataStorage) + , m_RenderWindowInspector(nullptr) + , m_SliceNavigator(nullptr) + , m_StepperAdapter(nullptr) + , m_ViewDirectionSelector(nullptr) +{ + m_Layout = new QHBoxLayout(this); + m_Layout->setMargin(0); + + auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->GetVtkRenderWindow()); + auto* sliceNavigationController = m_RenderWindow->GetSliceNavigationController(); + m_RenderWindowInspector = new QmitkRenderWindowContextDataStorageInspector(parent, baseRenderer); + m_RenderWindowInspector->SetDataStorage(m_DataStorage); + m_RenderWindowInspector->setObjectName(QStringLiteral("m_RenderWindowManipulatorWidget")); + connect(m_RenderWindowInspector, &QmitkRenderWindowContextDataStorageInspector::ReinitAction, + this, &QmitkRenderWindowUtilityWidget::ReinitAction); + connect(m_RenderWindowInspector, &QmitkRenderWindowContextDataStorageInspector::ResetAction, + this, &QmitkRenderWindowUtilityWidget::ResetAction); + + m_MenuBar = new QMenuBar(this); + m_MenuBar->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred); + auto menu = m_MenuBar->addMenu("Data"); + QWidgetAction* newAct = new QWidgetAction(menu); + newAct->setDefaultWidget(m_RenderWindowInspector); + menu->addAction(newAct); + m_Layout->addWidget(m_MenuBar); + + m_SliceNavigator = new QmitkSliderNavigatorWidget(this); + m_StepperAdapter = + new QmitkStepperAdapter(m_SliceNavigator, sliceNavigationController->GetSlice(), "sliceNavigator"); + m_Layout->addWidget(m_SliceNavigator); + + mitk::RenderWindowLayerUtilities::RendererVector controlledRenderer{ baseRenderer }; + m_RenderWindowViewDirectionController = std::make_unique(); + m_RenderWindowViewDirectionController->SetControlledRenderer(controlledRenderer); + m_RenderWindowViewDirectionController->SetDataStorage(dataStorage); + + m_ViewDirectionSelector = new QComboBox(this); + QStringList viewDirections{ "axial", "coronal", "sagittal"}; + m_ViewDirectionSelector->insertItems(0, viewDirections); + connect(m_ViewDirectionSelector, &QComboBox::currentTextChanged, this, &QmitkRenderWindowUtilityWidget::ChangeViewDirection); + auto viewDirection = sliceNavigationController->GetDefaultViewDirection(); + switch (viewDirection) + { + case mitk::SliceNavigationController::Axial: + m_ViewDirectionSelector->setCurrentIndex(0); + break; + case mitk::SliceNavigationController::Coronal: + m_ViewDirectionSelector->setCurrentIndex(1); + break; + case mitk::SliceNavigationController::Sagittal: + m_ViewDirectionSelector->setCurrentIndex(2); + break; + default: + break; + } + m_Layout->addWidget(m_ViewDirectionSelector); +} + +QmitkRenderWindowUtilityWidget::~QmitkRenderWindowUtilityWidget() +{ +} + +void QmitkRenderWindowUtilityWidget::SetInvertedSliceNavigation(bool inverted) +{ + m_SliceNavigator->SetInverseDirection(inverted); +} + +void QmitkRenderWindowUtilityWidget::ChangeViewDirection(const QString& viewDirection) +{ + m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString()); +} diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp index c7b0872bbd..5741cf6dfe 100644 --- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp +++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp @@ -1,264 +1,413 @@ /*============================================================================ 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" +#include +#include +#include + +// itk +#include + // vtk #include #include QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/, const QString& widgetName/* = ""*/, - mitk::DataStorage* dataStorage/* = nullptr*/) + mitk::DataStorage* dataStorage/* = nullptr*/, + bool windowControls/* = false */) : QFrame(parent) , m_WidgetName(widgetName) , m_DataStorage(dataStorage) , m_RenderWindow(nullptr) , m_CrosshairManager(nullptr) + , m_UtilityWidget(nullptr) + , m_WindowControls(windowControls) { this->InitializeGUI(); } QmitkRenderWindowWidget::~QmitkRenderWindowWidget() { auto sliceNavigationController = m_RenderWindow->GetSliceNavigationController(); if (nullptr != sliceNavigationController) { sliceNavigationController->SetCrosshairEvent.RemoveListener( mitk::MessageDelegate1( this, &QmitkRenderWindowWidget::SetCrosshairPosition)); } } 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); } m_CrosshairManager->SetDataStorage(m_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::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); this->RequestUpdate(); } bool QmitkRenderWindowWidget::GetCrosshairVisibility() { return m_CrosshairManager->GetCrosshairVisibility(); } void QmitkRenderWindowWidget::SetCrosshairGap(unsigned int gapSize) { m_CrosshairManager->SetCrosshairGap(gapSize); } void QmitkRenderWindowWidget::AddPlanesToDataStorage() { m_CrosshairManager->AddPlanesToDataStorage(); } void QmitkRenderWindowWidget::RemovePlanesFromDataStorage() { m_CrosshairManager->RemovePlanesFromDataStorage(); } void QmitkRenderWindowWidget::InitializeGUI() { - m_Layout = new QHBoxLayout(this); + m_Layout = new QVBoxLayout(this); m_Layout->setMargin(0); 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::BaseRenderer::ViewDirection::SAGITTAL); auto sliceNavigationController = m_RenderWindow->GetSliceNavigationController(); sliceNavigationController->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal); + if (m_WindowControls) + { + m_UtilityWidget = new QmitkRenderWindowUtilityWidget(this, m_RenderWindow, m_DataStorage); + m_Layout->addWidget(m_UtilityWidget); + connect(m_UtilityWidget, &QmitkRenderWindowUtilityWidget::ReinitAction, + this, &QmitkRenderWindowWidget::OnReinitAction); + connect(m_UtilityWidget, &QmitkRenderWindowUtilityWidget::ResetAction, + this, &QmitkRenderWindowWidget::OnResetAction); + } + m_Layout->addWidget(m_RenderWindow); // set colors and corner annotation InitializeDecorations(); // use crosshair manager m_CrosshairManager = mitk::CrosshairManager::New(m_DataStorage, m_RenderWindow->GetRenderer()); sliceNavigationController->SetCrosshairEvent.AddListener( mitk::MessageDelegate1( this, &QmitkRenderWindowWidget::SetCrosshairPosition)); // finally add observer, after all relevant objects have been created / initialized sliceNavigationController->ConnectGeometrySendEvent(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::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; } auto sliceNavigationController = m_RenderWindow->GetSliceNavigationController(); - const auto* inputWorldTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry(); - m_CrosshairManager->ComputeOrientedTimeGeometries(inputWorldTimeGeometry); + const auto* inputTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry(); + m_CrosshairManager->ComputeOrientedTimeGeometries(inputTimeGeometry); + + if (m_WindowControls) + { + this->ComputeInvertedSliceNavigation(); + } + +} + +void QmitkRenderWindowWidget::ComputeInvertedSliceNavigation() +{ + auto sliceNavigationController = m_RenderWindow->GetSliceNavigationController(); + auto viewDirection = sliceNavigationController->GetViewDirection(); + unsigned int axis = 0; + switch (viewDirection) + { + case mitk::SliceNavigationController::Original: + return; + case mitk::SliceNavigationController::Axial: + { + axis = 2; + break; + } + case mitk::SliceNavigationController::Coronal: + { + axis = 1; + break; + } + case mitk::SliceNavigationController::Sagittal: + { + axis = 0; + break; + } + } + + const auto* inputTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry(); + const mitk::BaseGeometry* rendererGeometry = m_RenderWindow->GetRenderer()->GetCurrentWorldGeometry(); + + // todo: check timepoint / timestep + mitk::TimeStepType timeStep = sliceNavigationController->GetTime()->GetPos(); + mitk::BaseGeometry::ConstPointer geometry = inputTimeGeometry->GetGeometryForTimeStep(timeStep); + + 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_UtilityWidget->SetInvertedSliceNavigation(referenceGeometryAxisInverted != rendererZAxisInverted); } + +void QmitkRenderWindowWidget::OnReinitAction(QList selectedNodes) +{ + if (selectedNodes.empty()) + { + return; + } + + auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow()); + auto boundingBoxPredicate = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false), baseRenderer)); + mitk::DataStorage::SetOfObjects::Pointer nodes = mitk::DataStorage::SetOfObjects::New(); + for (const auto& dataNode : selectedNodes) + { + if (boundingBoxPredicate->CheckNode(dataNode)) + { + nodes->InsertElement(nodes->Size(), dataNode); + } + } + + if (nodes->empty()) + { + return; + } + + if (1 == nodes->Size()) + { + auto selectedImage = dynamic_cast(nodes->ElementAt(0)->GetData()); + + if (nullptr != selectedImage) + { + mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), selectedImage->GetTimeGeometry()); + return; + } + } + + auto boundingGeometry = m_DataStorage->ComputeBoundingGeometry3D(nodes, "visible", baseRenderer); + mitk::RenderingManager::GetInstance()->InitializeView(baseRenderer->GetRenderWindow(), boundingGeometry); +} + +void QmitkRenderWindowWidget::OnResetAction(QList selectedNodes) +{ + if (selectedNodes.empty()) + { + return; + } + + auto selectedImage = dynamic_cast(selectedNodes.front()->GetData()); + if (nullptr == selectedImage) + { + return; + } + + const mitk::TimeGeometry* referenceGeometry = selectedImage->GetTimeGeometry(); + 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 auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint(); + if (referenceGeometry->IsValidTimePoint(currentTimePoint)) + { + imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint); + } + + auto* baseRenderer = mitk::BaseRenderer::GetInstance(m_RenderWindow->renderWindow()); + renderingManager->InitializeView(baseRenderer->GetRenderWindow(), referenceGeometry, false); + + // reset position and time step + this->SetCrosshairPosition(currentPosition); + renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep); +} \ No newline at end of file diff --git a/Modules/QtWidgetsExt/src/QmitkSliderNavigator.ui b/Modules/QtWidgets/src/QmitkSliderNavigator.ui similarity index 100% rename from Modules/QtWidgetsExt/src/QmitkSliderNavigator.ui rename to Modules/QtWidgets/src/QmitkSliderNavigator.ui diff --git a/Modules/QtWidgetsExt/src/QmitkSliderNavigatorWidget.cpp b/Modules/QtWidgets/src/QmitkSliderNavigatorWidget.cpp similarity index 100% rename from Modules/QtWidgetsExt/src/QmitkSliderNavigatorWidget.cpp rename to Modules/QtWidgets/src/QmitkSliderNavigatorWidget.cpp diff --git a/Modules/QtWidgetsExt/src/QmitkStepperAdapter.cpp b/Modules/QtWidgets/src/QmitkStepperAdapter.cpp similarity index 100% rename from Modules/QtWidgetsExt/src/QmitkStepperAdapter.cpp rename to Modules/QtWidgets/src/QmitkStepperAdapter.cpp diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp b/Modules/QtWidgets/src/mitkRenderWindowLayerController.cpp similarity index 100% rename from Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp rename to Modules/QtWidgets/src/mitkRenderWindowLayerController.cpp diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp b/Modules/QtWidgets/src/mitkRenderWindowLayerUtilities.cpp similarity index 100% rename from Modules/RenderWindowManager/src/mitkRenderWindowLayerUtilities.cpp rename to Modules/QtWidgets/src/mitkRenderWindowLayerUtilities.cpp diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp b/Modules/QtWidgets/src/mitkRenderWindowViewDirectionController.cpp similarity index 100% rename from Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp rename to Modules/QtWidgets/src/mitkRenderWindowViewDirectionController.cpp diff --git a/Modules/QtWidgetsExt/files.cmake b/Modules/QtWidgetsExt/files.cmake index daddbc0809..8bbfea3d04 100644 --- a/Modules/QtWidgetsExt/files.cmake +++ b/Modules/QtWidgetsExt/files.cmake @@ -1,101 +1,96 @@ file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*") set(CPP_FILES qclickablelabel.cpp QmitkAboutDialog.cpp QmitkBasePropertyView.cpp QmitkBoolPropertyWidget.cpp QmitkBoundingObjectWidget.cpp QmitkCallbackFromGUIThread.cpp QmitkColorPropertyEditor.cpp QmitkColorPropertyView.cpp QmitkColorTransferFunctionCanvas.cpp QmitkCrossWidget.cpp QmitkEditPointDialog.cpp QmitkEnumerationPropertyWidget.cpp QmitkFFmpegWriter.cpp QmitkFileChooser.cpp QmitkGnuplotWidget.cpp QmitkHistogram.cpp QmitkHotkeyLineEdit.cpp QmitkModulesDialog.cpp QmitkModuleTableModel.cpp QmitkNumberPropertyEditor.cpp QmitkNumberPropertySlider.cpp QmitkNumberPropertyView.cpp QmitkPiecewiseFunctionCanvas.cpp QmitkPlotDialog.cpp QmitkPlotWidget.cpp QmitkPointListModel.cpp QmitkPointListView.cpp QmitkPointListWidget.cpp QmitkPrimitiveMovieNavigatorWidget.cpp QmitkPropertyViewFactory.cpp QmitkSliceWidget.cpp - QmitkSliderNavigatorWidget.cpp QmitkStandardViews.cpp - QmitkStepperAdapter.cpp QmitkStringPropertyEditor.cpp QmitkStringPropertyOnDemandEdit.cpp QmitkStringPropertyView.cpp QmitkTransferFunctionCanvas.cpp QmitkTransferFunctionGeneratorWidget.cpp QmitkTransferFunctionWidget.cpp QmitkUGCombinedRepresentationPropertyWidget.cpp QmitkVideoBackground.cpp QtWidgetsExtRegisterClasses.cpp ) set(MOC_H_FILES include/qclickablelabel.h include/QmitkAboutDialog.h include/QmitkBasePropertyView.h include/QmitkBoolPropertyWidget.h include/QmitkBoundingObjectWidget.h include/QmitkCallbackFromGUIThread.h include/QmitkColorPropertyEditor.h include/QmitkColorPropertyView.h include/QmitkColorTransferFunctionCanvas.h include/QmitkCrossWidget.h include/QmitkEditPointDialog.h include/QmitkEnumerationPropertyWidget.h include/QmitkFFmpegWriter.h include/QmitkFileChooser.h include/QmitkGnuplotWidget.h include/QmitkHotkeyLineEdit.h include/QmitkNumberPropertyEditor.h include/QmitkNumberPropertySlider.h include/QmitkNumberPropertyView.h include/QmitkPiecewiseFunctionCanvas.h include/QmitkPlotWidget.h include/QmitkPointListModel.h include/QmitkPointListView.h include/QmitkPointListWidget.h include/QmitkPrimitiveMovieNavigatorWidget.h include/QmitkSliceWidget.h - include/QmitkSliderNavigatorWidget.h include/QmitkStandardViews.h - include/QmitkStepperAdapter.h include/QmitkStringPropertyEditor.h include/QmitkStringPropertyOnDemandEdit.h include/QmitkStringPropertyView.h include/QmitkTransferFunctionCanvas.h include/QmitkTransferFunctionGeneratorWidget.h include/QmitkTransferFunctionWidget.h include/QmitkUGCombinedRepresentationPropertyWidget.h include/QmitkVideoBackground.h ) set(UI_FILES src/QmitkAboutDialogGUI.ui src/QmitkGnuplotWidget.ui src/QmitkPrimitiveMovieNavigatorWidget.ui src/QmitkSliceWidget.ui - src/QmitkSliderNavigator.ui src/QmitkTransferFunctionGeneratorWidget.ui src/QmitkTransferFunctionWidget.ui ) set(QRC_FILES resource/QtWidgetsExt.qrc ) diff --git a/Modules/QtWidgetsExt/include/QmitkSliceWidget.h b/Modules/QtWidgetsExt/include/QmitkSliceWidget.h index be216bdaf2..9f8f8a7a57 100644 --- a/Modules/QtWidgetsExt/include/QmitkSliceWidget.h +++ b/Modules/QtWidgetsExt/include/QmitkSliceWidget.h @@ -1,90 +1,91 @@ /*============================================================================ 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 QMITKSLICEWIDGET_H_ #define QMITKSLICEWIDGET_H_ #include "MitkQtWidgetsExtExports.h" #include "ui_QmitkSliceWidget.h" #include "QmitkRenderWindow.h" #include "mitkDataStorage.h" #include "mitkSliceNavigationController.h" +#include "QmitkSliderNavigatorWidget.h" #include "mitkSlicedGeometry3D.h" #include "mitkStandaloneDataStorage.h" #include class MITKQTWIDGETSEXT_EXPORT QmitkSliceWidget : public QWidget, public Ui::QmitkSliceWidgetUi { Q_OBJECT public: QmitkSliceWidget(QWidget *parent = nullptr, const char *name = nullptr, Qt::WindowFlags f = nullptr); mitk::VtkPropRenderer *GetRenderer(); QFrame *GetSelectionFrame(); void UpdateGL(); void mousePressEvent(QMouseEvent *e) override; void setPopUpEnabled(bool b); void SetDataStorage(mitk::StandaloneDataStorage::Pointer storage); mitk::StandaloneDataStorage *GetDataStorage(); QmitkSliderNavigatorWidget *GetNavigatorWidget(); bool IsLevelWindowEnabled(); QmitkRenderWindow *GetRenderWindow(); mitk::SliceNavigationController *GetSliceNavigationController() const; mitk::CameraRotationController *GetCameraRotationController() const; mitk::BaseController *GetController() const; public slots: void SetData(mitk::DataStorage::SetOfObjects::ConstIterator it); void SetData(mitk::DataStorage::SetOfObjects::ConstIterator it, mitk::SliceNavigationController::ViewDirection view); void SetData(mitk::DataNode::Pointer node); void SetData(mitk::DataNode::Pointer node, mitk::SliceNavigationController::ViewDirection view); void InitWidget(mitk::SliceNavigationController::ViewDirection viewDirection); void wheelEvent(QWheelEvent *e) override; void ChangeView(QAction *val); void SetLevelWindowEnabled(bool enable); protected: QmitkRenderWindow *m_RenderWindow; mitk::SliceNavigationController::ViewDirection m_View; private: bool popUpEnabled; mitk::VtkPropRenderer::Pointer m_Renderer; mitk::SlicedGeometry3D::Pointer m_SlicedGeometry; mitk::StandaloneDataStorage::Pointer m_DataStorage; QMenu *popUp; }; #endif diff --git a/Modules/RenderWindowManager/CMakeLists.txt b/Modules/RenderWindowManager/CMakeLists.txt deleted file mode 100644 index f2a2a480bc..0000000000 --- a/Modules/RenderWindowManager/CMakeLists.txt +++ /dev/null @@ -1,3 +0,0 @@ -MITK_CREATE_MODULE( - DEPENDS MitkCore -) diff --git a/Modules/RenderWindowManager/files.cmake b/Modules/RenderWindowManager/files.cmake deleted file mode 100644 index 8d8bb99f84..0000000000 --- a/Modules/RenderWindowManager/files.cmake +++ /dev/null @@ -1,11 +0,0 @@ -set(H_FILES - include/mitkRenderWindowLayerController.h - include/mitkRenderWindowViewDirectionController.h - include/mitkRenderWindowLayerUtilities.h -) - -set(CPP_FILES - mitkRenderWindowLayerController.cpp - mitkRenderWindowViewDirectionController.cpp - mitkRenderWindowLayerUtilities.cpp -) diff --git a/Modules/RenderWindowManagerUI/CMakeLists.txt b/Modules/RenderWindowManagerUI/CMakeLists.txt index 7f5d63fa95..01d4a01d6d 100644 --- a/Modules/RenderWindowManagerUI/CMakeLists.txt +++ b/Modules/RenderWindowManagerUI/CMakeLists.txt @@ -1,4 +1,4 @@ MITK_CREATE_MODULE( - DEPENDS MitkQtWidgets MitkRenderWindowManager + DEPENDS MitkQtWidgets PACKAGE_DEPENDS PUBLIC Qt5|Core ) diff --git a/Modules/RenderWindowManagerUI/files.cmake b/Modules/RenderWindowManagerUI/files.cmake index bb0d58e96c..1637b1a861 100644 --- a/Modules/RenderWindowManagerUI/files.cmake +++ b/Modules/RenderWindowManagerUI/files.cmake @@ -1,21 +1,18 @@ set(H_FILES include/QmitkRenderWindowDataStorageInspector.h include/QmitkRenderWindowDataStorageListModel.h - include/QmitkRenderWindowDataStorageTreeModel.h ) set(CPP_FILES QmitkRenderWindowDataStorageInspector.cpp QmitkRenderWindowDataStorageListModel.cpp - QmitkRenderWindowDataStorageTreeModel.cpp ) set(MOC_H_FILES include/QmitkRenderWindowDataStorageInspector.h include/QmitkRenderWindowDataStorageListModel.h - include/QmitkRenderWindowDataStorageTreeModel.h ) set(UI_FILES src/QmitkRenderWindowDataStorageInspector.ui ) diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/CMakeLists.txt b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/CMakeLists.txt index 311da29037..8cc91e9666 100644 --- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/CMakeLists.txt +++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/CMakeLists.txt @@ -1,7 +1,7 @@ project(org_mitk_gui_qt_mxnmultiwidgeteditor) mitk_create_plugin( EXPORT_DIRECTIVE MXNMULTIWIDGETEDITOR_EXPORT EXPORTED_INCLUDE_SUFFIXES src - MODULE_DEPENDS MitkQtWidgets MitkRenderWindowManager + MODULE_DEPENDS MitkQtWidgets ) diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/CMakeLists.txt b/Plugins/org.mitk.gui.qt.renderwindowmanager/CMakeLists.txt index c7fa4849a9..061028e463 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/CMakeLists.txt +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/CMakeLists.txt @@ -1,7 +1,7 @@ project(org_mitk_gui_qt_renderwindowmanager) mitk_create_plugin( EXPORT_DIRECTIVE RENDERWINDOWMANAGER_EXPORT EXPORTED_INCLUDE_SUFFIXES src - MODULE_DEPENDS MitkQtWidgetsExt MitkRenderWindowManager MitkRenderWindowManagerUI + MODULE_DEPENDS MitkQtWidgetsExt MitkQtWidgets MitkRenderWindowManagerUI )