diff --git a/Modules/ModuleList.cmake b/Modules/ModuleList.cmake index 329ee2a9fa..9f5111da1b 100644 --- a/Modules/ModuleList.cmake +++ b/Modules/ModuleList.cmake @@ -1,82 +1,83 @@ # The entries in the mitk_modules list must be # ordered according to their dependencies. set(mitk_modules Core CommandLine AppUtil DCMTesting RDF LegacyIO DataTypesExt Overlays LegacyGL AlgorithmsExt MapperExt DICOMReader DICOMReaderServices DICOMTesting SceneSerializationBase PlanarFigure ImageDenoising ImageExtraction ImageStatistics LegacyAdaptors SceneSerialization Gizmo GraphAlgorithms Multilabel ContourModel SurfaceInterpolation Segmentation PlanarFigureSegmentation OpenViewCore QtWidgets QtWidgetsExt QtWidgetsWeb QmlItems SegmentationUI DiffusionImaging GPGPU OpenIGTLink IGTBase IGT CameraCalibration RigidRegistration RigidRegistrationUI DeformableRegistration DeformableRegistrationUI OpenCL OpenCVVideoSupport QtOverlays ToFHardware ToFProcessing ToFUI US USUI DicomUI Simulation Remeshing Python QtPython Persistence OpenIGTLinkUI IGTUI VtkShaders DicomRT RTUI IOExt XNAT TubeGraph BiophotonicsHardware Classification TumorInvasionAnalysis MatchPointRegistration MatchPointRegistrationUI BoundingShape RenderWindowManager + RenderWindowManagerUI ) if(MITK_ENABLE_PIC_READER) list(APPEND mitk_modules IpPicSupportIO) endif() diff --git a/Modules/RenderWindowManager/include/QmitkRenderWindowDataModel.h b/Modules/RenderWindowManager/include/QmitkRenderWindowDataModel.h index c16f7cd1ad..ae9a9562dc 100644 --- a/Modules/RenderWindowManager/include/QmitkRenderWindowDataModel.h +++ b/Modules/RenderWindowManager/include/QmitkRenderWindowDataModel.h @@ -1,68 +1,69 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef QMITKRENDERWINDOWDATAMODEL_H #define QMITKRENDERWINDOWDATAMODEL_H // render window manager module #include "MitkRenderWindowManagerExports.h" #include "mitkRenderWindowLayerUtilities.h" //mitk core #include #include // qt #include /* * @brief This class extends the 'QAbstractTableModel' to meet the specific requirements of the QmitkRenderWindowDataModel. */ class MITKRENDERWINDOWMANAGER_EXPORT QmitkRenderWindowDataModel : public QAbstractTableModel { Q_OBJECT public: QmitkRenderWindowDataModel(QObject* parent = nullptr); ~QmitkRenderWindowDataModel(); ////////////////////////////////////////////////////////////////////////// /// overridden functions from QAbstractItemModel ////////////////////////////////////////////////////////////////////////// virtual Qt::ItemFlags flags(const QModelIndex &index) const override; virtual QVariant data(const QModelIndex &index, int role) const override; virtual QVariant headerData(int section, Qt::Orientation orientation, int role) const override; virtual int rowCount(const QModelIndex &parent = QModelIndex()) const override; virtual int columnCount(const QModelIndex &parent = QModelIndex()) const override; virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override; ////////////////////////////////////////////////////////////////////////// /// end override ///////////////////////////////////////////////////////////////////////// void SetDataStorage(mitk::DataStorage::Pointer dataStorage); void SetCurrentRenderer(std::string rendererName); + mitk::BaseRenderer* GetCurrentRenderer() const { return m_BaseRenderer.GetPointer(); } void DataChanged(const mitk::DataNode* dataNode); private: mitk::DataStorage::Pointer m_DataStorage; mitk::BaseRenderer::Pointer m_BaseRenderer; RenderWindowLayerUtilities::LayerStack m_TempLayerStack; }; #endif // QMITKRENDERWINDOWDATAMODEL_H diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h b/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h index d956dcb101..42dff60ae9 100644 --- a/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h +++ b/Modules/RenderWindowManager/include/mitkRenderWindowLayerController.h @@ -1,166 +1,169 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MITKRENDERWINDOWLAYERCONTROLLER_H #define MITKRENDERWINDOWLAYERCONTROLLER_H // render window manager module #include "MitkRenderWindowManagerExports.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. * - * Functions with 'const mitk::BaseRenderer* renderer' have 'nullptr' as their default argument. Using the nullptr - * these functions operate on all base renderer. + * 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 { public: - typedef std::vector RendererVector; RenderWindowLayerController(); /** * @brief Set the data storage on which to work. */ void SetDataStorage(DataStorage::Pointer dataStorage); - DataStorage::Pointer GetDataStorage() { return m_DataStorage; }; - /** - * @brief Set the controlled base renderer by specifying the corresponding render windows. - */ - void SetControlledRenderer(const RenderingManager::RenderWindowVector &renderWindows); /** * @brief Set the controlled base renderer. */ - void SetControlledRenderer(RendererVector controlledRenderer); - RendererVector GetControlledRenderer() { return m_ControlledRenderer; }; + 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 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. */ void 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. */ void 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. */ void 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. */ void 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 visiblity, 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 visibility 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; - RendererVector m_ControlledRenderer; + RenderWindowLayerUtilities::RendererVector m_ControlledRenderer; }; } // namespace mitk #endif // MITKRENDERWINDOWLAYERCONTROLLER_H diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h b/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h index aaa4ab0877..e119c43c10 100644 --- a/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h +++ b/Modules/RenderWindowManager/include/mitkRenderWindowLayerUtilities.h @@ -1,59 +1,61 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MITKRENDERWINDOWLAYERUTILITIES_H #define MITKRENDERWINDOWLAYERUTILITIES_H // render window manager module #include "MitkRenderWindowManagerExports.h" // mitk core +#include #include #include /** * @brief Render window layer helper functions to retrieve the currently valid layer stack */ 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 mitk::DataStorage* dataStorage, const mitk::BaseRenderer* renderer, bool withBaseNode); } // namespace RenderWindowLayerUtilities #endif // MITKRENDERWINDOWLAYERUTILITIES_H diff --git a/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h b/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h index 75a70dd124..40752c35d4 100644 --- a/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h +++ b/Modules/RenderWindowManager/include/mitkRenderWindowViewDirectionController.h @@ -1,70 +1,74 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H #define MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H -// render window manager +// render window manager module #include "MitkRenderWindowManagerExports.h" +#include "mitkRenderWindowLayerUtilities.h" -// mitk +// 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 changed to 'mitk::SliceNavigationController::Axial', 'mitk::SliceNavigationController::Frontal' + * 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 node only for the given renderer. */ class MITKRENDERWINDOWMANAGER_EXPORT RenderWindowViewDirectionController { public: - typedef std::vector RendererVector; - RenderWindowViewDirectionController(); - virtual ~RenderWindowViewDirectionController(); /** - * @brief set the data storage on which to work + * @brief Set the data storage on which to work. */ void SetDataStorage(DataStorage::Pointer dataStorage); - DataStorage::Pointer GetDataStorage() { return m_DataStorage; }; - /** - * @brief set the controlled base renderer by specifying the corresponding render windows - */ - void SetControlledRenderer(const RenderingManager::RenderWindowVector &renderWindows); /** - * @brief set the controlled base renderer + * @brief Set the controlled base renderer. */ - void SetControlledRenderer(RendererVector controlledRenderer); - RendererVector GetControlledRenderer() { return m_ControlledRenderer; }; + void SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer); // wrapper functions to modify the view direction /** - * @brief set the view direction for the given renderer (nullptr = all renderer) + * @brief Set the view direction for the given renderer (nullptr = all renderer) + * @param viewDirection The view direction that should be used for this renderer. + * 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) nothing happens. The view direction can not be changed + * for all controlled renderer at the moment. */ void SetViewDirectionOfRenderer(const std::string &viewDirection, BaseRenderer* renderer = nullptr); private: void InitializeViewByBoundingObjects(const BaseRenderer* renderer); DataStorage::Pointer m_DataStorage; - RendererVector m_ControlledRenderer; + RenderWindowLayerUtilities::RendererVector m_ControlledRenderer; }; } // namespace mitk #endif // MITKRENDERWINDOWVIEWDIRECTIONCONTROLLER_H diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp index a0d365099c..fb04926ab6 100644 --- a/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp +++ b/Modules/RenderWindowManager/src/mitkRenderWindowLayerController.cpp @@ -1,497 +1,481 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ // render window manager module #include "mitkRenderWindowLayerController.h" -// mitk core -#include "mitkRenderingManager.h" - mitk::RenderWindowLayerController::RenderWindowLayerController() : m_DataStorage(nullptr) { - SetControlledRenderer(RenderingManager::GetInstance()->GetAllRegisteredRenderWindows()); + // nothing here } void mitk::RenderWindowLayerController::SetDataStorage(DataStorage::Pointer dataStorage) { if (m_DataStorage != dataStorage) { // set the new data storage m_DataStorage = dataStorage; } } -void mitk::RenderWindowLayerController::SetControlledRenderer(const RenderingManager::RenderWindowVector &renderWindows) -{ - BaseRenderer* baseRenderer = nullptr; - for (const auto &renderWindow : renderWindows) - { - baseRenderer = BaseRenderer::GetInstance(renderWindow); - if (nullptr != baseRenderer) - { - m_ControlledRenderer.push_back(baseRenderer); - } - } -} - -void mitk::RenderWindowLayerController::SetControlledRenderer(RendererVector controlledRenderer) +void mitk::RenderWindowLayerController::SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer) { if (m_ControlledRenderer != controlledRenderer) { // set the new set of controlled renderer m_ControlledRenderer = controlledRenderer; } } void mitk::RenderWindowLayerController::SetBaseDataNode(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // set the data node as base data node in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { SetBaseDataNode(dataNode, renderer); } } } else { // get the layer stack with the base data node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, true); if (!stackedLayers.empty()) { // see if base layer exists RenderWindowLayerUtilities::LayerStack::iterator layerStackIterator = stackedLayers.find(RenderWindowLayerUtilities::BASE_LAYER_INDEX); if (layerStackIterator != stackedLayers.end()) { // remove the current base data node from the current renderer layerStackIterator->second->GetPropertyList(renderer)->DeleteProperty("layer"); layerStackIterator->second->SetBoolProperty("fixedLayer", false, renderer); layerStackIterator->second->SetVisibility(false, renderer); } } // "RenderWindowLayerUtilities::BASE_LAYER_INDEX" indicates the base data node --> set as new background dataNode->SetIntProperty("layer", RenderWindowLayerUtilities::BASE_LAYER_INDEX, renderer); dataNode->SetBoolProperty("fixedLayer", true, renderer); dataNode->SetVisibility(true, renderer); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } } void mitk::RenderWindowLayerController::InsertLayerNode(DataNode* dataNode, int layer /*= RenderWindowLayerUtilities::TOP_LAYER_INDEX*/, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // insert data node in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { InsertLayerNode(dataNode, layer, renderer); } } } else { if (RenderWindowLayerUtilities::BASE_LAYER_INDEX == layer) { // "RenderWindowLayerUtilities::BASE_LAYER_INDEX" indicates the base data node --> set as new background (overwrite current base node if needed) SetBaseDataNode(dataNode, renderer); } else { InsertLayerNodeInternal(dataNode, layer, renderer); } } } void mitk::RenderWindowLayerController::InsertLayerNodeInternal(DataNode* dataNode, int newLayer, const BaseRenderer* renderer /*= nullptr*/) { dataNode->SetBoolProperty("fixedLayer", true, renderer); dataNode->SetVisibility(true, renderer); // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (stackedLayers.empty()) { // no layer stack for the current renderer if (RenderWindowLayerUtilities::TOP_LAYER_INDEX == newLayer) { // set given layer as first layer above base layer (= 1) newLayer = 1; // alternatively: no layer stack for the current renderer -> insert as background node //SetBaseDataNode(dataNode, renderer); } } else { if (RenderWindowLayerUtilities::TOP_LAYER_INDEX == newLayer) { // get the first value (highest int-key -> topmost layer) // +1 indicates inserting the node above the topmost layer newLayer = stackedLayers.begin()->first + 1; } else { // see if layer is already taken RenderWindowLayerUtilities::LayerStack::iterator layerStackIterator = stackedLayers.find(newLayer); for (; layerStackIterator != stackedLayers.end(); ++layerStackIterator) { // move data nodes after the new layer one layer up layerStackIterator->second->SetIntProperty("layer", layerStackIterator->first + 1, renderer); } } } // update data storage (the "data node model") dataNode->SetIntProperty("layer", newLayer, renderer); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } void mitk::RenderWindowLayerController::RemoveLayerNode(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // remove data node from all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { RemoveLayerNode(dataNode, renderer); } } } else { // "remove" node from the renderer list dataNode->GetPropertyList(renderer)->DeleteProperty("layer"); dataNode->SetBoolProperty("fixedLayer", false, renderer); dataNode->SetVisibility(false, renderer); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } } void mitk::RenderWindowLayerController::MoveNodeToFront(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // move data node to front in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { MoveNodeToFront(dataNode, renderer); } } } else { // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (!stackedLayers.empty()) { // get the first value (highest int-key -> topmost layer) int topmostLayer = stackedLayers.begin()->first; // get the current layer value of the given data node int currentLayer; bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer); if (wasFound && currentLayer < topmostLayer) { // move the current data node above the current topmost layer dataNode->SetIntProperty("layer", topmostLayer+1, renderer); } // else: data node has no layer information or is already the topmost layer node } // else: do not work with empty layer stack } } void mitk::RenderWindowLayerController::MoveNodeToBack(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // move data node to back in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { MoveNodeToBack(dataNode, renderer); } } } else { // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (!stackedLayers.empty()) { // get the last value (lowest int-key) // cannot be the base layer as the base node was excluded by the 'GetLayerStack'-function int lowermostLayer = stackedLayers.rbegin()->first; // get the current layer value of the given data node int currentLayer; bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer); if (wasFound && currentLayer > lowermostLayer) { // move the current data node to the current lowermost layer dataNode->SetIntProperty("layer", lowermostLayer, renderer); // move all other data nodes one layer up for (auto& layer : stackedLayers) { if (layer.second != dataNode && layer.first < currentLayer) { layer.second->SetIntProperty("layer", layer.first + 1, renderer); } // else: current data node has already been moved to the lowermost layer } } // else: data node has no layer information or is already the lowermost layer node } // else: do not work with empty layer stack } } void mitk::RenderWindowLayerController::MoveNodeUp(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // move data node down in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { MoveNodeUp(dataNode, renderer); } } } else { // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (!stackedLayers.empty()) { // get the current layer value of the given data node int currentLayer; bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer); if (wasFound) { // get the current layer in the map of stacked layers RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIterator = stackedLayers.find(currentLayer); if (layerStackIterator != stackedLayers.end() && layerStackIterator != stackedLayers.begin()) { // found the element in the map, at different position than 'begin' -> // current node is not on the topmost layer and therefore can be moved one layer up // swap the layers of the dataNode and the dataNode on the next higher layer (previous map element) RenderWindowLayerUtilities::LayerStack::const_iterator prevLayerStackIterator = std::prev(layerStackIterator); dataNode->SetIntProperty("layer", prevLayerStackIterator->first, renderer); prevLayerStackIterator->second->SetIntProperty("layer", currentLayer, renderer); //prevLayerStackIterator->second->Modified(); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } // else: layer stack does not contain a layer with the 'currentLayer'data node or // layer is already the topmost layer node } // else: data node has no layer information } // else: do not work with empty layer stack } } void mitk::RenderWindowLayerController::MoveNodeDown(DataNode* dataNode, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // move data node up in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { MoveNodeDown(dataNode, renderer); } } } else { // get the layer stack without the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, false); if (!stackedLayers.empty()) { // get the current layer value of the given data node int currentLayer; bool wasFound = dataNode->GetIntProperty("layer", currentLayer, renderer); if (wasFound) { // get the current layer in the map of stacked layers RenderWindowLayerUtilities::LayerStack::const_iterator layerStackIterator = stackedLayers.find(currentLayer); if (layerStackIterator != stackedLayers.end()) { // found the element in the map ... RenderWindowLayerUtilities::LayerStack::const_iterator nextLayerStackIterator = std::next(layerStackIterator); if (nextLayerStackIterator != stackedLayers.end()) { // ... and found a successor -> // current node is not on the lowermost layer and therefore can be moved one layer down // swap the layers of the dataNode and the dataNode on the next lower layer (next map element) dataNode->SetIntProperty("layer", nextLayerStackIterator->first, renderer); nextLayerStackIterator->second->SetIntProperty("layer", currentLayer, renderer); //nextLayerStackIterator->second->Modified(); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } // else: data node is already the lowermost layer node } // else: layer stack does not contain a layer with the 'currentLayer' } // else: data node has no layer information } // else: do not work with empty layer stack } } void mitk::RenderWindowLayerController::SetVisibilityOfDataNode(bool visibility, DataNode* dataNode, const BaseRenderer* renderer /*=nullptr*/) { if (nullptr == dataNode) { return; } if (nullptr == renderer) { // set visibility of data node in all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { SetVisibilityOfDataNode(visibility, dataNode, renderer); } } } else { dataNode->SetVisibility(visibility, renderer); dataNode->Modified(); mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } } void mitk::RenderWindowLayerController::HideDataNodeInAllRenderer(const DataNode* dataNode) { if (nullptr == dataNode) { return; } for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { dataNode->GetPropertyList(renderer)->SetBoolProperty("visible", false); } } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void mitk::RenderWindowLayerController::ResetRenderer(bool onlyVisibility /*= true*/, const BaseRenderer* renderer /*= nullptr*/) { if (nullptr == renderer) { // reset all controlled renderer for (const auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { ResetRenderer(onlyVisibility, renderer); } } } else { // get the layer stack with the base node of the current renderer RenderWindowLayerUtilities::LayerStack stackedLayers = RenderWindowLayerUtilities::GetLayerStack(m_DataStorage, renderer, true); if (!stackedLayers.empty()) { for (const auto& layer : stackedLayers) { int layerLevel; layer.second->GetIntProperty("layer", layerLevel, renderer); if (RenderWindowLayerUtilities::BASE_LAYER_INDEX == layerLevel) { // set base data node visibility to true layer.second->SetVisibility(true, renderer); } else { // set visibility of all other data nodes to false layer.second->SetVisibility(false, renderer); // modify layer node if (!onlyVisibility) { // clear mode: additionally remove layer node from current renderer layer.second->GetPropertyList(renderer)->DeleteProperty("layer"); layer.second->SetBoolProperty("fixedLayer", false, renderer); } } layer.second->Modified(); } mitk::RenderingManager::GetInstance()->RequestUpdate(renderer->GetRenderWindow()); } } } diff --git a/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp b/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp index 8a5ef4495f..63df9a913e 100644 --- a/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp +++ b/Modules/RenderWindowManager/src/mitkRenderWindowViewDirectionController.cpp @@ -1,130 +1,110 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkRenderWindowViewDirectionController.h" -#include "mitkRenderWindowLayerUtilities.h" // mitk -#include #include #include #include mitk::RenderWindowViewDirectionController::RenderWindowViewDirectionController() : m_DataStorage(nullptr) -{ - SetControlledRenderer(RenderingManager::GetInstance()->GetAllRegisteredRenderWindows()); -} - -mitk::RenderWindowViewDirectionController::~RenderWindowViewDirectionController() { // nothing here } void mitk::RenderWindowViewDirectionController::SetDataStorage(DataStorage::Pointer dataStorage) { if (m_DataStorage != dataStorage) { // set the new data storage m_DataStorage = dataStorage; } } -void mitk::RenderWindowViewDirectionController::SetControlledRenderer(const RenderingManager::RenderWindowVector &renderWindows) -{ - BaseRenderer* baseRenderer = nullptr; - for (const auto &renderWindow : renderWindows) - { - baseRenderer = BaseRenderer::GetInstance(renderWindow); - if (nullptr != baseRenderer) - { - m_ControlledRenderer.push_back(baseRenderer); - } - } -} - -void mitk::RenderWindowViewDirectionController::SetControlledRenderer(RendererVector controlledRenderer) +void mitk::RenderWindowViewDirectionController::SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer) { if (m_ControlledRenderer != controlledRenderer) { // set the new set of controlled renderer m_ControlledRenderer = controlledRenderer; } } void mitk::RenderWindowViewDirectionController::SetViewDirectionOfRenderer(const std::string &viewDirection, BaseRenderer* renderer /*=nullptr*/) { if (nullptr == renderer) { // set visibility of data node in all controlled renderer for (auto& renderer : m_ControlledRenderer) { if (renderer.IsNotNull()) { - SetViewDirectionOfRenderer(viewDirection, renderer); + //SetViewDirectionOfRenderer(viewDirection, renderer); } } } else { mitk::SliceNavigationController* sliceNavigationController = renderer->GetSliceNavigationController(); if ("axial" == viewDirection) { sliceNavigationController->SetDefaultViewDirection(mitk::SliceNavigationController::Axial); } else if ("coronal" == viewDirection) { sliceNavigationController->SetDefaultViewDirection(mitk::SliceNavigationController::Frontal); } else if ("sagittal" == viewDirection) { sliceNavigationController->SetDefaultViewDirection(mitk::SliceNavigationController::Sagittal); } // initialize the views to the bounding geometry InitializeViewByBoundingObjects(renderer); } } void mitk::RenderWindowViewDirectionController::InitializeViewByBoundingObjects(const BaseRenderer* renderer) { if (nullptr == m_DataStorage || nullptr == renderer) { return; } // get all nodes that have not set "includeInBoundingBox" to false mitk::NodePredicateProperty::Pointer includeInBoundingBox = mitk::NodePredicateProperty::New("includeInBoundingBox", mitk::BoolProperty::New(false)); mitk::NodePredicateNot::Pointer notIncludeInBoundingBox = mitk::NodePredicateNot::New(includeInBoundingBox); // get all non-helper objects mitk::NodePredicateProperty::Pointer helperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)); mitk::NodePredicateNot::Pointer notAHelperObject = mitk::NodePredicateNot::New(helperObject); // get all nodes that have a fixed layer for the given renderer mitk::NodePredicateProperty::Pointer fixedLayer = mitk::NodePredicateProperty::New("fixedLayer", mitk::BoolProperty::New(true), renderer); // combine node predicates mitk::NodePredicateAnd::Pointer combinedNodePredicate = mitk::NodePredicateAnd::New(notIncludeInBoundingBox, notAHelperObject, fixedLayer); mitk::DataStorage::SetOfObjects::ConstPointer filteredDataNodes = m_DataStorage->GetSubset(combinedNodePredicate); // calculate bounding geometry of these nodes mitk::TimeGeometry::Pointer bounds = m_DataStorage->ComputeBoundingGeometry3D(filteredDataNodes, "visible", renderer); // initialize the views to the bounding geometry mitk::RenderingManager::GetInstance()->InitializeView(renderer->GetRenderWindow(), bounds); } \ No newline at end of file diff --git a/Modules/RenderWindowManagerUI/CMakeLists.txt b/Modules/RenderWindowManagerUI/CMakeLists.txt new file mode 100644 index 0000000000..f94ad95c26 --- /dev/null +++ b/Modules/RenderWindowManagerUI/CMakeLists.txt @@ -0,0 +1,5 @@ +MITK_CREATE_MODULE( + INCLUDE_DIRS Qmitk + DEPENDS MitkQtWidgets MitkRenderWindowManager + PACKAGE_DEPENDS PUBLIC CTK Qt5|Core +) diff --git a/Modules/RenderWindowManagerUI/files.cmake b/Modules/RenderWindowManagerUI/files.cmake new file mode 100644 index 0000000000..a998c3cf7f --- /dev/null +++ b/Modules/RenderWindowManagerUI/files.cmake @@ -0,0 +1,15 @@ +set(H_FILES + include/QmitkRenderWindowManipulatorWidget.h +) + +set(CPP_FILES + QmitkRenderWindowManipulatorWidget.cpp +) + +set(MOC_H_FILES + include/QmitkRenderWindowManipulatorWidget.h +) + +set(UI_FILES + src/QmitkRenderWindowManipulatorWidget.ui +) \ No newline at end of file diff --git a/Modules/RenderWindowManagerUI/include/QmitkRenderWindowManipulatorWidget.h b/Modules/RenderWindowManagerUI/include/QmitkRenderWindowManipulatorWidget.h new file mode 100644 index 0000000000..65f2d15f3b --- /dev/null +++ b/Modules/RenderWindowManagerUI/include/QmitkRenderWindowManipulatorWidget.h @@ -0,0 +1,103 @@ +/*=================================================================== + +The Medical Imaging Interaction Toolkit (MITK) + +Copyright (c) German Cancer Research Center, +Division of Medical and Biological Informatics. +All rights reserved. + +This software is distributed WITHOUT ANY WARRANTY; without +even the implied warranty of MERCHANTABILITY or FITNESS FOR +A PARTICULAR PURPOSE. + +See LICENSE.txt or http://www.mitk.org for details. + +===================================================================*/ + +#ifndef QMITKRENDERWINDOWMANIPULATORWIDGET_H +#define QMITKRENDERWINDOWMANIPULATORWIDGET_H + +// render window manager UI module +#include "MitkRenderWindowManagerUIExports.h" +#include "ui_QmitkRenderWindowManipulatorWidget.h" + +// render window manager module +#include +#include +#include + +// qt +#include + +/** +* The QmitkRenderWindowManipulatorWidget offers a GUI to manipulate the base renderer / render windows of the MITK workbench. +* The widgets supports adding a layer to an active render window, moving layers up and down, removing layers, +* resetting layers (hiding them) or removing all layers at once. +* +* In order to use this widget, a (e.g.) plugin has to set the controlled renderer, which will be forwarded to +* a render window layer controller and a render window view direction controller. +* The plugin also has to provide a Q_SLOT that is connected to the 'AddLayerButtonClicked'-Q_SIGNAL of this widget. +* This allows for a customized add-layer functionality. +*/ +class MITKRENDERWINDOWMANAGERUI_EXPORT QmitkRenderWindowManipulatorWidget : public QWidget +{ + Q_OBJECT + +public: + + QmitkRenderWindowManipulatorWidget(mitk::DataStorage::Pointer dataStorage, QWidget* parent = nullptr); + /** + * @brief Set the controlled base renderer. + */ + void SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer); + /** + * @brief Set the currently selected render window + * + * @param renderWindowId the text inside the combo box + */ + void SetActiveRenderWindow(const QString &renderWindowId); + /** + * @brief + * + * @param dataNode k + */ + void AddLayer(mitk::DataNode* dataNode); + /** + * @brief + * + * @param dataNode k + */ + void HideDataNodeInAllRenderer(const mitk::DataNode* dataNode); + +protected: + + void SetUpConnections(); + +Q_SIGNALS: + void AddLayerButtonClicked(); + +private Q_SLOTS: + + void RemoveLayer(); + void SetAsBaseLayer(); + + void MoveLayer(const QString &direction); + + void ResetRenderer(); + void ClearRenderer(); + + void ChangeViewDirection(const QString &viewDirection); + +private: + + void Init(); + + Ui::QmitkRenderWindowManipulatorWidget m_Controls; + + mitk::DataStorage::Pointer m_DataStorage; + std::unique_ptr m_RenderWindowDataModel; + std::unique_ptr m_RenderWindowLayerController; + std::unique_ptr m_RenderWindowViewDirectionController; +}; + +#endif // QMITKRENDERWINDOWMANIPULATORWIDGET_H diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.cpp similarity index 53% copy from Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp copy to Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.cpp index 034fd85768..dedca5761f 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp +++ b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.cpp @@ -1,220 +1,193 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ -// render window manager plugin -#include "QmitkRenderWindowManagerView.h" - -// blueberry -#include -#include +// render window manager UI module +#include "QmitkRenderWindowManipulatorWidget.h" // mitk core #include // qt #include #include #include -const std::string QmitkRenderWindowManagerView::VIEW_ID = "org.mitk.views.renderwindowmanager"; +QmitkRenderWindowManipulatorWidget::QmitkRenderWindowManipulatorWidget(mitk::DataStorage::Pointer dataStorage, QWidget* parent /*=nullptr*/) + : m_DataStorage(dataStorage) + , QWidget(parent) +{ + Init(); +} -void QmitkRenderWindowManagerView::SetFocus() +void QmitkRenderWindowManipulatorWidget::SetControlledRenderer(RenderWindowLayerUtilities::RendererVector controlledRenderer) { - m_Controls.radioButtonAxial->setFocus(); + m_RenderWindowLayerController->SetControlledRenderer(controlledRenderer); + m_RenderWindowViewDirectionController->SetControlledRenderer(controlledRenderer); } -void QmitkRenderWindowManagerView::CreateQtPartControl(QWidget* parent) +void QmitkRenderWindowManipulatorWidget::Init() { - // create GUI widgets from the Qt Designer's .ui file - m_Parent = parent; - m_Controls.setupUi(m_Parent); + // create GUI from the Qt Designer's .ui file + m_Controls.setupUi(this); // initialize the render window layer controller and the render window view direction controller - // and set the controller renderer (in constructor) and the data storage + // and set the controller renderer (in constructor) and the data storage m_RenderWindowLayerController = std::make_unique(); m_RenderWindowViewDirectionController = std::make_unique(); - m_RenderWindowLayerController->SetDataStorage(GetDataStorage()); - m_RenderWindowViewDirectionController->SetDataStorage(GetDataStorage()); - mitk::RenderWindowLayerController::RendererVector controlledRenderer = m_RenderWindowLayerController->GetControlledRenderer(); - for (const auto& renderer : controlledRenderer) - { - m_Controls.comboBoxRenderWindowSelection->addItem(renderer->GetName()); - } + m_RenderWindowLayerController->SetDataStorage(m_DataStorage); + m_RenderWindowViewDirectionController->SetDataStorage(m_DataStorage); // create a new model m_RenderWindowDataModel = std::make_unique(this); - m_RenderWindowDataModel->SetDataStorage(GetDataStorage()); - m_RenderWindowDataModel->SetCurrentRenderer(m_Controls.comboBoxRenderWindowSelection->itemText(0).toStdString()); + m_RenderWindowDataModel->SetDataStorage(m_DataStorage); m_Controls.renderWindowTableView->setModel(m_RenderWindowDataModel.get()); m_Controls.renderWindowTableView->setEditTriggers(QAbstractItemView::NoEditTriggers); m_Controls.renderWindowTableView->horizontalHeader()->setStretchLastSection(true); m_Controls.renderWindowTableView->setSelectionBehavior(QAbstractItemView::SelectRows); m_Controls.renderWindowTableView->setSelectionMode(QAbstractItemView::SingleSelection); - //m_VisibilityDelegate = new QmitkVisibilityDelegate(this); - //m_Controls.renderWindowTableView->setItemDelegateForColumn(0, m_VisibilityDelegate); - - m_AddLayerWidget = new QmitkLayerManagerAddLayerWidget(m_Parent); - m_AddLayerWidget->hide(); - m_AddLayerWidget->SetDataStorage(GetDataStorage()); SetUpConnections(); } -void QmitkRenderWindowManagerView::SetUpConnections(void) +void QmitkRenderWindowManipulatorWidget::SetUpConnections() { - connect(m_Controls.comboBoxRenderWindowSelection, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(OnRenderWindowSelectionChanged(const QString&))); - - connect(m_Controls.pushButtonAddLayer, SIGNAL(clicked()), this, SLOT(ShowAddLayerWidget())); + // signal to signal connection + connect(m_Controls.pushButtonAddLayer, SIGNAL(clicked()), this, SIGNAL(AddLayerButtonClicked())); connect(m_Controls.pushButtonRemoveLayer, SIGNAL(clicked()), this, SLOT(RemoveLayer())); connect(m_Controls.pushButtonSetAsBaseLayer, SIGNAL(clicked()), this, SLOT(SetAsBaseLayer())); QSignalMapper* udSignalMapper = new QSignalMapper(this); udSignalMapper->setMapping(m_Controls.pushButtonMoveUp, QString("up")); udSignalMapper->setMapping(m_Controls.pushButtonMoveDown, QString("down")); connect(udSignalMapper, SIGNAL(mapped(const QString&)), this, SLOT(MoveLayer(const QString&))); connect(m_Controls.pushButtonMoveUp, SIGNAL(clicked()), udSignalMapper, SLOT(map())); connect(m_Controls.pushButtonMoveDown, SIGNAL(clicked()), udSignalMapper, SLOT(map())); connect(m_Controls.pushButtonResetRenderer, SIGNAL(clicked()), this, SLOT(ResetRenderer())); connect(m_Controls.pushButtonClearRenderer, SIGNAL(clicked()), this, SLOT(ClearRenderer())); QSignalMapper* changeViewDirectionSignalMapper = new QSignalMapper(this); changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonAxial, QString("axial")); changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonCoronal, QString("coronal")); changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonSagittal, QString("sagittal")); connect(changeViewDirectionSignalMapper, SIGNAL(mapped(const QString&)), this, SLOT(ChangeViewDirection(const QString&))); connect(m_Controls.radioButtonAxial, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); connect(m_Controls.radioButtonCoronal, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); connect(m_Controls.radioButtonSagittal, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); - - connect(m_AddLayerWidget, SIGNAL(LayerToAddSelected(mitk::DataNode*)), this, SLOT(AddLayer(mitk::DataNode*))); } -void QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged(const QString &renderWindowId) +void QmitkRenderWindowManipulatorWidget::SetActiveRenderWindow(const QString &renderWindowId) { std::string currentRendererName = renderWindowId.toStdString(); m_RenderWindowDataModel->SetCurrentRenderer(currentRendererName); mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(currentRendererName); + if (nullptr == selectedRenderer) + { + return; + } + mitk::SliceNavigationController::ViewDirection viewDirection = selectedRenderer->GetSliceNavigationController()->GetDefaultViewDirection(); switch (viewDirection) { case mitk::SliceNavigationController::Axial: m_Controls.radioButtonAxial->setChecked(true); break; case mitk::SliceNavigationController::Frontal: m_Controls.radioButtonCoronal->setChecked(true); break; case mitk::SliceNavigationController::Sagittal: m_Controls.radioButtonSagittal->setChecked(true); break; default: break; } } -void QmitkRenderWindowManagerView::ShowAddLayerWidget() +void QmitkRenderWindowManipulatorWidget::AddLayer(mitk::DataNode* dataNode) { - m_AddLayerWidget->ListLayer(); - m_AddLayerWidget->show(); + m_RenderWindowLayerController->InsertLayerNode(dataNode, -1, m_RenderWindowDataModel->GetCurrentRenderer()); } -void QmitkRenderWindowManagerView::AddLayer(mitk::DataNode* dataNode) +void QmitkRenderWindowManipulatorWidget::HideDataNodeInAllRenderer(const mitk::DataNode* dataNode) { - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - m_RenderWindowLayerController->InsertLayerNode(dataNode, -1, selectedRenderer); + m_RenderWindowLayerController->HideDataNodeInAllRenderer(dataNode); } -void QmitkRenderWindowManagerView::RemoveLayer() +void QmitkRenderWindowManipulatorWidget::RemoveLayer() { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); - mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); + mitk::DataNode* dataNode = m_DataStorage->GetNamedNode(rowData.toString().toStdString()); - m_RenderWindowLayerController->RemoveLayerNode(dataNode, selectedRenderer); + m_RenderWindowLayerController->RemoveLayerNode(dataNode, m_RenderWindowDataModel->GetCurrentRenderer()); m_Controls.renderWindowTableView->clearSelection(); } } -void QmitkRenderWindowManagerView::SetAsBaseLayer() +void QmitkRenderWindowManipulatorWidget::SetAsBaseLayer() { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); - mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); + mitk::DataNode* dataNode = m_DataStorage->GetNamedNode(rowData.toString().toStdString()); - m_RenderWindowLayerController->SetBaseDataNode(dataNode, selectedRenderer); + m_RenderWindowLayerController->SetBaseDataNode(dataNode, m_RenderWindowDataModel->GetCurrentRenderer()); m_Controls.renderWindowTableView->clearSelection(); } } -void QmitkRenderWindowManagerView::MoveLayer(const QString &direction) +void QmitkRenderWindowManipulatorWidget::MoveLayer(const QString &direction) { QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); if (selectedIndex.isValid()) { QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); - mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); + mitk::DataNode* dataNode = m_DataStorage->GetNamedNode(rowData.toString().toStdString()); + const mitk::BaseRenderer* selectedRenderer = m_RenderWindowDataModel->GetCurrentRenderer(); if ("up" == direction) { m_RenderWindowLayerController->MoveNodeUp(dataNode, selectedRenderer); } else { m_RenderWindowLayerController->MoveNodeDown(dataNode, selectedRenderer); } m_Controls.renderWindowTableView->clearSelection(); } } -void QmitkRenderWindowManagerView::ResetRenderer() +void QmitkRenderWindowManipulatorWidget::ResetRenderer() { - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - - m_RenderWindowLayerController->ResetRenderer(true, selectedRenderer); + m_RenderWindowLayerController->ResetRenderer(true, m_RenderWindowDataModel->GetCurrentRenderer()); m_Controls.renderWindowTableView->clearSelection(); } -void QmitkRenderWindowManagerView::ClearRenderer() +void QmitkRenderWindowManipulatorWidget::ClearRenderer() { - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - - m_RenderWindowLayerController->ResetRenderer(false, selectedRenderer); + m_RenderWindowLayerController->ResetRenderer(false, m_RenderWindowDataModel->GetCurrentRenderer()); m_Controls.renderWindowTableView->clearSelection(); } -void QmitkRenderWindowManagerView::ChangeViewDirection(const QString &viewDirection) -{ - mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - - m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString(), selectedRenderer); -} - -void QmitkRenderWindowManagerView::NodeAdded(const mitk::DataNode* node) +void QmitkRenderWindowManipulatorWidget::ChangeViewDirection(const QString &viewDirection) { - // initially set new node as invisible in all render windows - // this way, each single renderer overwrites the common renderer and the node is invisible - // until it is inserted in the node list of a render window - m_RenderWindowLayerController->HideDataNodeInAllRenderer(node); + m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString(), m_RenderWindowDataModel->GetCurrentRenderer()); } diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerControls.ui b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.ui similarity index 87% copy from Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerControls.ui copy to Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.ui index f925772063..01e6a1b05f 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerControls.ui +++ b/Modules/RenderWindowManagerUI/src/QmitkRenderWindowManipulatorWidget.ui @@ -1,122 +1,120 @@ - QmitkRenderWindowManagerControls - + QmitkRenderWindowManipulatorWidget + 0 0 - 386 - 572 + 308 + 246 + + + 0 + 0 + + 0 0 - QmitkRenderWindowManager + Render window manager - - - - -1 - - - Render window overview - - + + - Move up + Add Layer - - + + - Axial - - - true + Remove layer - - + + - Coronal + Set as base layer - - + + - Sagittal + Move up Move down - - + + - Remove layer + Reset render window - - + + - Add Layer + Clear render window - - + + - Set as base layer + Axial + + + true - - + + - Reset render window + Coronal - - + + - Clear render window + Sagittal - diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/CMakeLists.txt b/Plugins/org.mitk.gui.qt.renderwindowmanager/CMakeLists.txt index c04c78bb9b..c7fa4849a9 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 + MODULE_DEPENDS MitkQtWidgetsExt MitkRenderWindowManager MitkRenderWindowManagerUI ) diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/files.cmake b/Plugins/org.mitk.gui.qt.renderwindowmanager/files.cmake index 1bd24a4c92..b6d60fcc37 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/files.cmake +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/files.cmake @@ -1,29 +1,25 @@ set(INTERNAL_CPP_FILES mitkPluginActivator.cpp QmitkRenderWindowManagerView.cpp - QmitkLayerManagerAddLayerWidget.cpp ) set(UI_FILES src/internal/QmitkRenderWindowManagerControls.ui - src/internal/QmitkLayerManagerAddLayerControls.ui ) set(MOC_H_FILES src/internal/mitkPluginActivator.h src/internal/QmitkRenderWindowManagerView.h - src/internal/QmitkLayerManagerAddLayerWidget.h ) set(CACHED_RESOURCE_FILES resources/LayerManager_48.png plugin.xml ) set(QRC_FILES - resources/renderwindowmanager.qrc ) foreach(file ${INTERNAL_CPP_FILES}) set(CPP_FILES ${CPP_FILES} src/internal/${file}) endforeach(file ${INTERNAL_CPP_FILES}) diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/resources/renderwindowmanager.qrc b/Plugins/org.mitk.gui.qt.renderwindowmanager/resources/renderwindowmanager.qrc deleted file mode 100644 index e996d7d2d9..0000000000 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/resources/renderwindowmanager.qrc +++ /dev/null @@ -1,5 +0,0 @@ - - - LayerManager_48.png - - diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerControls.ui b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerControls.ui deleted file mode 100644 index 5581caaa10..0000000000 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerControls.ui +++ /dev/null @@ -1,71 +0,0 @@ - - - QmitkLayerManagerAddLayerControls - - - - 0 - 0 - 459 - 844 - - - - - 0 - 0 - - - - - 0 - 0 - - - - QmitkLayerManagerAddLayer - - - - - - - 0 - 0 - - - - Add layer - - - - - - - 0 - 0 - - - - - 0 - 0 - - - - - - - - Add layer to renderer - - - - - - - - - - - diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerWidget.cpp b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerWidget.cpp deleted file mode 100644 index 7964ad6683..0000000000 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerWidget.cpp +++ /dev/null @@ -1,93 +0,0 @@ -/*=================================================================== - -The Medical Imaging Interaction Toolkit (MITK) - -Copyright (c) German Cancer Research Center, -Division of Medical and Biological Informatics. -All rights reserved. - -This software is distributed WITHOUT ANY WARRANTY; without -even the implied warranty of MERCHANTABILITY or FITNESS FOR -A PARTICULAR PURPOSE. - -See LICENSE.txt or http://www.mitk.org for details. - -===================================================================*/ - -#include "QmitkLayerManagerAddLayerWidget.h" - -#include -#include - -const QString QmitkLayerManagerAddLayerWidget::VIEW_ID = "org.mitk.Widgets.QmitkLayerManagerAddLayer"; - -QmitkLayerManagerAddLayerWidget::QmitkLayerManagerAddLayerWidget(QWidget* parent /*= nullptr*/) - : QWidget(parent, Qt::Window) - , m_DataStorage(nullptr) -{ - Init(); -} - -QmitkLayerManagerAddLayerWidget::~QmitkLayerManagerAddLayerWidget() -{ - // nothing here -} - -void QmitkLayerManagerAddLayerWidget::Init() -{ - m_Controls.setupUi(this); - m_LayerListModel = new QStringListModel(this); - m_Controls.listViewLayers->setModel(m_LayerListModel); - m_Controls.listViewLayers->setEditTriggers(QAbstractItemView::NoEditTriggers); - - connect(m_Controls.pushButtonAddLayer, SIGNAL(clicked()), this, SLOT(AddLayerToRenderer())); - connect(m_Controls.pushButtonAddLayer, SIGNAL(clicked()), this, SLOT(hide())); - - m_Controls.pushButtonAddLayer->setEnabled(false); -} - -void QmitkLayerManagerAddLayerWidget::SetDataStorage(mitk::DataStorage::Pointer dataStorage) -{ - m_DataStorage = dataStorage; -} - -void QmitkLayerManagerAddLayerWidget::ListLayer() -{ - if (m_DataStorage.IsNotNull()) - { - // get the data nodes from the data storage that are not helper objects - mitk::NodePredicateProperty::Pointer helperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)); - mitk::NodePredicateNot::Pointer notAHelperObject = mitk::NodePredicateNot::New(helperObject); - mitk::DataStorage::SetOfObjects::ConstPointer filteredDataNodes = m_DataStorage->GetSubset(notAHelperObject); - - QStringList stringList; - for (mitk::DataStorage::SetOfObjects::ConstIterator it = filteredDataNodes->Begin(); it != filteredDataNodes->End(); ++it) - { - stringList << QString::fromStdString(it->Value()->GetName()); - } - - m_LayerListModel->setStringList(stringList); - - if (stringList.isEmpty()) - { - m_Controls.pushButtonAddLayer->setEnabled(false); - } - else - { - m_Controls.pushButtonAddLayer->setEnabled(true); - } - } -} - -void QmitkLayerManagerAddLayerWidget::AddLayerToRenderer() -{ - QModelIndex selectedIndex = m_Controls.listViewLayers->currentIndex(); - if (selectedIndex.isValid()) - { - int listRow = selectedIndex.row(); - QString dataNodeName = m_LayerListModel->stringList().at(listRow); - mitk::DataNode* dataNode = m_DataStorage->GetNamedNode(dataNodeName.toStdString()); - - emit LayerToAddSelected(dataNode); - } -} diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerWidget.h b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerWidget.h deleted file mode 100644 index 3e1e6bdcdd..0000000000 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkLayerManagerAddLayerWidget.h +++ /dev/null @@ -1,68 +0,0 @@ -/*=================================================================== - -The Medical Imaging Interaction Toolkit (MITK) - -Copyright (c) German Cancer Research Center, -Division of Medical and Biological Informatics. -All rights reserved. - -This software is distributed WITHOUT ANY WARRANTY; without -even the implied warranty of MERCHANTABILITY or FITNESS FOR -A PARTICULAR PURPOSE. - -See LICENSE.txt or http://www.mitk.org for details. - -===================================================================*/ - -#ifndef QMITKLAYERMANAGERADDLAYERWIDGET_H -#define QMITKLAYERMANAGERADDLAYERWIDGET_H - -#include "ui_QmitkLayerManagerAddLayerControls.h" - -// mitk -#include - -// Qt includes -#include -#include -#include - -/** -* @brief -* -*/ -class QmitkLayerManagerAddLayerWidget : public QWidget -{ - Q_OBJECT - -public: - static const QString VIEW_ID; - - QmitkLayerManagerAddLayerWidget(QWidget* parent = nullptr); - ~QmitkLayerManagerAddLayerWidget(); - - /** - * @brief set the data storage of the tree model - * - * @param[in] dataStorage the mitk::DataStorage that should be used - */ - void SetDataStorage(mitk::DataStorage::Pointer dataStorage); - - void ListLayer(); - -public Q_SLOTS: - void AddLayerToRenderer(); - -Q_SIGNALS: - void LayerToAddSelected(mitk::DataNode* dataNode); - -private: - void Init(); - - Ui::QmitkLayerManagerAddLayerControls m_Controls; - - QStringListModel* m_LayerListModel; - mitk::DataStorage::Pointer m_DataStorage; -}; - -#endif // QMITKLAYERMANAGERADDLAYERWIDGET_H diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerControls.ui b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerControls.ui index f925772063..5951ce01ed 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerControls.ui +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerControls.ui @@ -1,122 +1,34 @@ QmitkRenderWindowManagerControls 0 0 386 572 0 0 - QmitkRenderWindowManager + Render window manager plugin -1 - - - - Render window overview - - - - - - - - - - - - Move up - - - - - - - Axial - - - true - - - - - - - Coronal - - - - - - - Sagittal - - - - - - - Move down - - - - - - - Remove layer - - - - - - - Add Layer - - - - - - - Set as base layer - - - - - - - Reset render window - - - - - - - Clear render window - - - - - - diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp index 034fd85768..34f6f27b66 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.cpp @@ -1,220 +1,103 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ // render window manager plugin #include "QmitkRenderWindowManagerView.h" // blueberry #include #include // mitk core #include - -// qt -#include -#include -#include +#include const std::string QmitkRenderWindowManagerView::VIEW_ID = "org.mitk.views.renderwindowmanager"; void QmitkRenderWindowManagerView::SetFocus() { - m_Controls.radioButtonAxial->setFocus(); + // nothing here } void QmitkRenderWindowManagerView::CreateQtPartControl(QWidget* parent) { - // create GUI widgets from the Qt Designer's .ui file - m_Parent = parent; - m_Controls.setupUi(m_Parent); - - // initialize the render window layer controller and the render window view direction controller - // and set the controller renderer (in constructor) and the data storage - m_RenderWindowLayerController = std::make_unique(); - m_RenderWindowViewDirectionController = std::make_unique(); - m_RenderWindowLayerController->SetDataStorage(GetDataStorage()); - m_RenderWindowViewDirectionController->SetDataStorage(GetDataStorage()); - mitk::RenderWindowLayerController::RendererVector controlledRenderer = m_RenderWindowLayerController->GetControlledRenderer(); - for (const auto& renderer : controlledRenderer) + // create GUI widgets + m_Controls.setupUi(parent); + // add custom render window manager UI widget to the 'renderWindowManagerTab' + m_RenderWindowManipulatorWidget = new QmitkRenderWindowManipulatorWidget(GetDataStorage(), parent); + m_RenderWindowManipulatorWidget->setObjectName(QStringLiteral("m_RenderWindowManipulatorWidget")); + m_Controls.verticalLayout->addWidget(m_RenderWindowManipulatorWidget); + + SetControlledRenderer(); + + for (const auto& renderer : m_ControlledRenderer) { m_Controls.comboBoxRenderWindowSelection->addItem(renderer->GetName()); } - // create a new model - m_RenderWindowDataModel = std::make_unique(this); - m_RenderWindowDataModel->SetDataStorage(GetDataStorage()); - m_RenderWindowDataModel->SetCurrentRenderer(m_Controls.comboBoxRenderWindowSelection->itemText(0).toStdString()); + OnRenderWindowSelectionChanged(m_Controls.comboBoxRenderWindowSelection->itemText(0)); - m_Controls.renderWindowTableView->setModel(m_RenderWindowDataModel.get()); - m_Controls.renderWindowTableView->setEditTriggers(QAbstractItemView::NoEditTriggers); - m_Controls.renderWindowTableView->horizontalHeader()->setStretchLastSection(true); - m_Controls.renderWindowTableView->setSelectionBehavior(QAbstractItemView::SelectRows); - m_Controls.renderWindowTableView->setSelectionMode(QAbstractItemView::SingleSelection); - //m_VisibilityDelegate = new QmitkVisibilityDelegate(this); - //m_Controls.renderWindowTableView->setItemDelegateForColumn(0, m_VisibilityDelegate); - - m_AddLayerWidget = new QmitkLayerManagerAddLayerWidget(m_Parent); - m_AddLayerWidget->hide(); - m_AddLayerWidget->SetDataStorage(GetDataStorage()); - - SetUpConnections(); -} - -void QmitkRenderWindowManagerView::SetUpConnections(void) -{ connect(m_Controls.comboBoxRenderWindowSelection, SIGNAL(currentIndexChanged(const QString&)), this, SLOT(OnRenderWindowSelectionChanged(const QString&))); - - connect(m_Controls.pushButtonAddLayer, SIGNAL(clicked()), this, SLOT(ShowAddLayerWidget())); - connect(m_Controls.pushButtonRemoveLayer, SIGNAL(clicked()), this, SLOT(RemoveLayer())); - connect(m_Controls.pushButtonSetAsBaseLayer, SIGNAL(clicked()), this, SLOT(SetAsBaseLayer())); - - QSignalMapper* udSignalMapper = new QSignalMapper(this); - udSignalMapper->setMapping(m_Controls.pushButtonMoveUp, QString("up")); - udSignalMapper->setMapping(m_Controls.pushButtonMoveDown, QString("down")); - connect(udSignalMapper, SIGNAL(mapped(const QString&)), this, SLOT(MoveLayer(const QString&))); - connect(m_Controls.pushButtonMoveUp, SIGNAL(clicked()), udSignalMapper, SLOT(map())); - connect(m_Controls.pushButtonMoveDown, SIGNAL(clicked()), udSignalMapper, SLOT(map())); - - connect(m_Controls.pushButtonResetRenderer, SIGNAL(clicked()), this, SLOT(ResetRenderer())); - connect(m_Controls.pushButtonClearRenderer, SIGNAL(clicked()), this, SLOT(ClearRenderer())); - - QSignalMapper* changeViewDirectionSignalMapper = new QSignalMapper(this); - changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonAxial, QString("axial")); - changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonCoronal, QString("coronal")); - changeViewDirectionSignalMapper->setMapping(m_Controls.radioButtonSagittal, QString("sagittal")); - connect(changeViewDirectionSignalMapper, SIGNAL(mapped(const QString&)), this, SLOT(ChangeViewDirection(const QString&))); - connect(m_Controls.radioButtonAxial, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); - connect(m_Controls.radioButtonCoronal, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); - connect(m_Controls.radioButtonSagittal, SIGNAL(clicked()), changeViewDirectionSignalMapper, SLOT(map())); - - connect(m_AddLayerWidget, SIGNAL(LayerToAddSelected(mitk::DataNode*)), this, SLOT(AddLayer(mitk::DataNode*))); + connect(m_RenderWindowManipulatorWidget, SIGNAL(AddLayerButtonClicked()), this, SLOT(OnAddLayerButtonClicked())); } -void QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged(const QString &renderWindowId) +void QmitkRenderWindowManagerView::SetControlledRenderer() { - std::string currentRendererName = renderWindowId.toStdString(); - m_RenderWindowDataModel->SetCurrentRenderer(currentRendererName); - - mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(currentRendererName); - mitk::SliceNavigationController::ViewDirection viewDirection = selectedRenderer->GetSliceNavigationController()->GetDefaultViewDirection(); - switch (viewDirection) + const mitk::RenderingManager::RenderWindowVector allRegisteredRenderWindows = mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows(); + mitk::BaseRenderer* baseRenderer = nullptr; + for (const auto &renderWindow : allRegisteredRenderWindows) { - case mitk::SliceNavigationController::Axial: - m_Controls.radioButtonAxial->setChecked(true); - break; - case mitk::SliceNavigationController::Frontal: - m_Controls.radioButtonCoronal->setChecked(true); - break; - case mitk::SliceNavigationController::Sagittal: - m_Controls.radioButtonSagittal->setChecked(true); - break; - default: - break; + baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow); + if (nullptr != baseRenderer) + { + m_ControlledRenderer.push_back(baseRenderer); + } } -} - -void QmitkRenderWindowManagerView::ShowAddLayerWidget() -{ - m_AddLayerWidget->ListLayer(); - m_AddLayerWidget->show(); -} - -void QmitkRenderWindowManagerView::AddLayer(mitk::DataNode* dataNode) -{ - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - m_RenderWindowLayerController->InsertLayerNode(dataNode, -1, selectedRenderer); -} - -void QmitkRenderWindowManagerView::RemoveLayer() -{ - QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); - if (selectedIndex.isValid()) - { - QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); - mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - m_RenderWindowLayerController->RemoveLayerNode(dataNode, selectedRenderer); - m_Controls.renderWindowTableView->clearSelection(); - } + m_RenderWindowManipulatorWidget->SetControlledRenderer(m_ControlledRenderer); } -void QmitkRenderWindowManagerView::SetAsBaseLayer() +void QmitkRenderWindowManagerView::OnRenderWindowSelectionChanged(const QString &renderWindowId) { - QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); - if (selectedIndex.isValid()) - { - QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); - mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - - m_RenderWindowLayerController->SetBaseDataNode(dataNode, selectedRenderer); - m_Controls.renderWindowTableView->clearSelection(); - } + m_RenderWindowManipulatorWidget->SetActiveRenderWindow(renderWindowId); } -void QmitkRenderWindowManagerView::MoveLayer(const QString &direction) +void QmitkRenderWindowManagerView::OnAddLayerButtonClicked() { - QModelIndex selectedIndex = m_Controls.renderWindowTableView->currentIndex(); - if (selectedIndex.isValid()) + QList nodes = GetDataManagerSelection(); + for (mitk::DataNode* dataNode : nodes) { - QVariant rowData = m_RenderWindowDataModel->data(selectedIndex, Qt::UserRole); - mitk::DataNode* dataNode = GetDataStorage()->GetNamedNode(rowData.toString().toStdString()); - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - - if ("up" == direction) - { - m_RenderWindowLayerController->MoveNodeUp(dataNode, selectedRenderer); - } - else + if (nullptr != dataNode) { - m_RenderWindowLayerController->MoveNodeDown(dataNode, selectedRenderer); + m_RenderWindowManipulatorWidget->AddLayer(dataNode); + + // get child nodes of the current node + mitk::DataStorage::SetOfObjects::ConstPointer derivedNodes = GetDataStorage()->GetDerivations(dataNode, nullptr, false); + for (mitk::DataStorage::SetOfObjects::ConstIterator it = derivedNodes->Begin(); it != derivedNodes->End(); ++it) + { + m_RenderWindowManipulatorWidget->AddLayer(it->Value()); + } } - m_Controls.renderWindowTableView->clearSelection(); } } -void QmitkRenderWindowManagerView::ResetRenderer() -{ - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - - m_RenderWindowLayerController->ResetRenderer(true, selectedRenderer); - m_Controls.renderWindowTableView->clearSelection(); -} - -void QmitkRenderWindowManagerView::ClearRenderer() -{ - const mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - - m_RenderWindowLayerController->ResetRenderer(false, selectedRenderer); - m_Controls.renderWindowTableView->clearSelection(); -} - -void QmitkRenderWindowManagerView::ChangeViewDirection(const QString &viewDirection) -{ - mitk::BaseRenderer* selectedRenderer = mitk::BaseRenderer::GetByName(m_Controls.comboBoxRenderWindowSelection->currentText().toStdString()); - - m_RenderWindowViewDirectionController->SetViewDirectionOfRenderer(viewDirection.toStdString(), selectedRenderer); -} - void QmitkRenderWindowManagerView::NodeAdded(const mitk::DataNode* node) { // initially set new node as invisible in all render windows - // this way, each single renderer overwrites the common renderer and the node is invisible + // this way, each single renderer overwrites the common render and the node is invisible // until it is inserted in the node list of a render window - m_RenderWindowLayerController->HideDataNodeInAllRenderer(node); -} + m_RenderWindowManipulatorWidget->HideDataNodeInAllRenderer(node); +} \ No newline at end of file diff --git a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h index e5eb6d0aaa..3501b4f94e 100644 --- a/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h +++ b/Plugins/org.mitk.gui.qt.renderwindowmanager/src/internal/QmitkRenderWindowManagerView.h @@ -1,92 +1,79 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef QMITKRENDERWINDOWMANAGERVIEW_H #define QMITKRENDERWINDOWMANAGERVIEW_H // render window manager plugin #include "ui_QmitkRenderWindowManagerControls.h" -#include "QmitkLayerManagerAddLayerWidget.h" -// render window manager module -#include -#include -#include -//#include +// render window manager UI module +#include // blueberry #include // qt #include -#include /** * @brief RenderWindowManager */ class QmitkRenderWindowManagerView : public QmitkAbstractView { Q_OBJECT public: static const std::string VIEW_ID; protected: virtual void SetFocus() override; virtual void CreateQtPartControl(QWidget* parent) override; - void SetUpConnections(); - private Q_SLOTS: /** * @brief called when the user changes the render window selection in the combo box + * + * @param renderWindowId the text inside the combo box */ void OnRenderWindowSelectionChanged(const QString &renderWindowId); - - void ShowAddLayerWidget(); - void AddLayer(mitk::DataNode* dataNode); - void RemoveLayer(); - void SetAsBaseLayer(); - - void MoveLayer(const QString &direction); - - void ResetRenderer(); - void ClearRenderer(); - - void ChangeViewDirection(const QString &viewDirection); + /** + * @brief called when the 'AddLayer'-button of he render window manipulator widget has been pushed + */ + void OnAddLayerButtonClicked(); private: + void SetControlledRenderer(); + /** * @brief set each data node invisible in all render windows, as soon as the node is added to the data storage */ void NodeAdded(const mitk::DataNode* node) override; // the Qt parent of our GUI QWidget* m_Parent; Ui::QmitkRenderWindowManagerControls m_Controls; - std::unique_ptr m_RenderWindowDataModel; - std::unique_ptr m_RenderWindowLayerController; - std::unique_ptr m_RenderWindowViewDirectionController; - QmitkLayerManagerAddLayerWidget* m_AddLayerWidget; + QmitkRenderWindowManipulatorWidget* m_RenderWindowManipulatorWidget; + RenderWindowLayerUtilities::RendererVector m_ControlledRenderer; }; #endif // QMITKRENDERWINDOWMANAGERVIEW_H