diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
index e14078520e..d3bd049a66 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
@@ -1,212 +1,212 @@
/*============================================================================
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 "SimpleRenderWindowView.h"
#include <QmitkRenderWindow.h>
#include "org_mitk_example_gui_customviewer_views_Activator.h"
#include <berryIBerryPreferences.h>
#include <ctkServiceTracker.h>
#include <mitkIRenderingManager.h>
#include <mitkInteractionConst.h>
#include <mitkSliceNavigationController.h>
#include <QVBoxLayout>
#include <mitkPlaneGeometry.h>
/**
* \brief Helper class adapted from QmitkAbstractRenderEditor by defining the correct plugin context.
*
* This helper class adapted from QmitkAbstractRenderEditor provides the rendering manager interface.
*/
// //! [SimpleRenderWindowViewHelper]
class AbstractRenderWindowViewPrivate
{
public:
AbstractRenderWindowViewPrivate()
: m_RenderingManagerInterface(mitk::MakeRenderingManagerInterface(mitk::RenderingManager::GetInstance())),
m_PrefServiceTracker(org_mitk_example_gui_customviewer_views_Activator::GetPluginContext())
// //! [SimpleRenderWindowViewHelper]
{
m_PrefServiceTracker.open();
}
~AbstractRenderWindowViewPrivate() { delete m_RenderingManagerInterface; }
mitk::IRenderingManager *m_RenderingManagerInterface;
ctkServiceTracker<berry::IPreferencesService *> m_PrefServiceTracker;
berry::IBerryPreferences::Pointer m_Prefs;
};
const std::string SimpleRenderWindowView::VIEW_ID = "org.mitk.customviewer.views.simplerenderwindowview";
SimpleRenderWindowView::SimpleRenderWindowView() : m_RenderWindow(nullptr), d(new AbstractRenderWindowViewPrivate)
{
}
SimpleRenderWindowView::~SimpleRenderWindowView()
{
}
QmitkRenderWindow *SimpleRenderWindowView::GetActiveQmitkRenderWindow() const
{
return m_RenderWindow;
}
QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetRenderWindows() const
{
QHash<QString, QmitkRenderWindow *> wnds;
wnds.insert("axial", m_RenderWindow);
return wnds;
}
QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetQmitkRenderWindows() const
{
QHash<QString, QmitkRenderWindow *> wnds;
wnds.insert("axial", m_RenderWindow);
return wnds;
}
QmitkRenderWindow *SimpleRenderWindowView::GetRenderWindow(const QString &id) const
{
if (id == "axial")
{
return m_RenderWindow;
}
return nullptr;
}
QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const QString &id) const
{
if (id == "axial")
{
return m_RenderWindow;
}
return nullptr;
}
-QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection &viewDirection) const
+QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const
{
- if (viewDirection == mitk::BaseRenderer::ViewDirection::AXIAL)
+ if (orientation == mitk::AnatomicalPlane::Axial)
{
return m_RenderWindow;
}
return 0;
}
void SimpleRenderWindowView::SetFocus()
{
m_RenderWindow->setFocus();
}
// //! [SimpleRenderWindowViewCreatePartControl]
void SimpleRenderWindowView::CreateQtPartControl(QWidget *parent)
{
QVBoxLayout *layout = new QVBoxLayout(parent);
layout->setContentsMargins(0, 0, 0, 0);
m_RenderWindow = new QmitkRenderWindow(parent);
layout->addWidget(m_RenderWindow);
mitk::DataStorage::Pointer ds = this->GetDataStorage();
m_RenderWindow->GetRenderer()->SetDataStorage(ds);
this->RequestUpdate();
}
// //! [SimpleRenderWindowViewCreatePartControl]
mitk::IRenderingManager *SimpleRenderWindowView::GetRenderingManager() const
{
// we use the global rendering manager here. This should maybe replaced
// by a local one, managing only the render windows specific for the view
return d->m_RenderingManagerInterface;
}
void SimpleRenderWindowView::RequestUpdate(mitk::RenderingManager::RequestType requestType)
{
if (GetRenderingManager())
GetRenderingManager()->RequestUpdateAll(requestType);
}
void SimpleRenderWindowView::ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType)
{
if (GetRenderingManager())
GetRenderingManager()->ForceImmediateUpdateAll(requestType);
}
void SimpleRenderWindowView::SetReferenceGeometry(const mitk::TimeGeometry* /*referenceGeometry*/, bool /*resetCamera*/)
{
// not implemented
}
bool SimpleRenderWindowView::HasCoupledRenderWindows() const
{
return false;
}
mitk::SliceNavigationController *SimpleRenderWindowView::GetTimeNavigationController() const
{
if (GetRenderingManager())
return GetRenderingManager()->GetTimeNavigationController();
return nullptr;
}
mitk::Point3D SimpleRenderWindowView::GetSelectedPosition(const QString& /*id*/) const
{
const mitk::PlaneGeometry* pg = m_RenderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
if (pg)
{
return pg->GetCenter();
}
else
{
return mitk::Point3D();
}
}
void SimpleRenderWindowView::SetSelectedPosition(const mitk::Point3D&, const QString&)
{
}
mitk::TimePointType SimpleRenderWindowView::GetSelectedTimePoint(const QString& /*id*/) const
{
auto timeNavigator = this->GetTimeNavigationController();
if (nullptr != timeNavigator)
{
return timeNavigator->GetSelectedTimePoint();
}
return 0;
}
void SimpleRenderWindowView::EnableDecorations(bool enable, const QStringList& decorations)
{
if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
{
m_RenderWindow->ActivateMenuWidget(enable);
}
}
bool SimpleRenderWindowView::IsDecorationEnabled(const QString& decoration) const
{
if (decoration == DECORATION_MENU)
{
return m_RenderWindow->GetActivateMenuWidgetFlag();
}
return false;
}
QStringList SimpleRenderWindowView::GetDecorations() const
{
QStringList decorations;
decorations << DECORATION_MENU;
return decorations;
}
diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.h b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.h
index ac3b152408..1c3ff52d3e 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.h
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.h
@@ -1,157 +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.
============================================================================*/
#ifndef SimpleRenderWindowView_H_
#define SimpleRenderWindowView_H_
#include <QmitkAbstractView.h>
#include <berryQtViewPart.h>
#include <mitkIRenderWindowPart.h>
class QmitkRenderWindow;
class AbstractRenderWindowViewPrivate;
/**
* \brief A view class suited for the ViewerPerspective within the custom viewer plug-in.
*
* This view class contributes data node rendering functionality to the ViewerPerspective.
* Being a subclass of QmitkAbstractView, this class yields access to the data storage and
* thus is interconnected with the mitk::QmitkDataManagerView present in the same perspective.
* As a subclass of mitk::IRenderWindowPart, this class provides an instance of QmitkRenderWindow.
* A SimpleRenderWindowView instance is part of the ViewerPerspective for data visualization.
*/
// //! [SimpleRenderWindowViewDeclaration]
class SimpleRenderWindowView : public QmitkAbstractView, public mitk::IRenderWindowPart
// //! [SimpleRenderWindowViewDeclaration]
{
Q_OBJECT
public:
/**
* Standard constructor.
*/
SimpleRenderWindowView();
~SimpleRenderWindowView() override;
/**
* String based view identifier.
*/
static const std::string VIEW_ID;
berryObjectMacro(SimpleRenderWindowView);
// ------------------- mitk::IRenderWindowPart ----------------------
/**
* \see mitk::IRenderWindowPart::GetActiveQmitkRenderWindow()
*/
QmitkRenderWindow *GetActiveQmitkRenderWindow() const override;
QHash<QString, QmitkRenderWindow *> GetRenderWindows() const;
/**
* \see mitk::IRenderWindowPart::GetQmitkRenderWindows()
*/
QHash<QString, QmitkRenderWindow *> GetQmitkRenderWindows() const override;
QmitkRenderWindow *GetRenderWindow(const QString &id) const;
/**
* \see mitk::IRenderWindowPart::GetQmitkRenderWindow(QString)
*/
QmitkRenderWindow *GetQmitkRenderWindow(const QString &id) const override;
/**
- * \see mitk::IRenderWindowPart::GetQmitkRenderWindow(mitk::BaseRenderer::ViewDirection)
+ * \see mitk::IRenderWindowPart::GetQmitkRenderWindow(mitk::AnatomicalPlane)
*/
- QmitkRenderWindow *GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection &viewDirection) const override;
+ QmitkRenderWindow *GetQmitkRenderWindow(const mitk::AnatomicalPlane &orientation) const override;
/**
* \see mitk::QmitkAbstractRenderEditor::GetRenderingManager()
*/
mitk::IRenderingManager *GetRenderingManager() const override;
/**
* \see mitk::QmitkAbstractRenderEditor::RequestUpdate()
*/
void RequestUpdate(
mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) override;
/**
* \see mitk::QmitkAbstractRenderEditor::ForceImmediateUpdate()
*/
void ForceImmediateUpdate(mitk::RenderingManager::RequestType) override;
/**
* \see mitk::IRenderWindowPart::SetReferenceGeometry()
*/
void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
/**
* \see mitk::IRenderWindowPart::HasCoupledRenderWindows
*/
bool HasCoupledRenderWindows() const override;
/**
* \see mitk::IRenderWindowPart::GetTimeNavigationController()
*/
mitk::SliceNavigationController *GetTimeNavigationController() const override;
/**
* \see mitk::IRenderWindowPart::GetSelectionPosition()
*/
mitk::Point3D GetSelectedPosition(const QString& id = QString()) const override;
/**
* \see mitk::IRenderWindowPart::SetSelectedPosition()
*/
void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) override;
/**
* \see mitk::IRenderWindowPart::GetSelectedTimePoint()
*/
mitk::TimePointType GetSelectedTimePoint(const QString& id = QString()) const override;
/**
* \see mitk::IRenderWindowPart::EnableDecorations()
*/
void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) override;
/**
* \see mitk::IRenderWindowPart::IsDecorationEnabled()
*/
bool IsDecorationEnabled(const QString& decoration) const override;
/**
* \see mitk::IRenderWindowPart::GetDecorations()
*/
QStringList GetDecorations() const override;
protected:
void SetFocus() override;
/**
* Creates the QmitkRenderWindow whose renderer is being connected to the view's data storage.
*/
void CreateQtPartControl(QWidget *parent) override;
private:
/**
* The view's render window.
*/
QmitkRenderWindow *m_RenderWindow;
QScopedPointer<AbstractRenderWindowViewPrivate> d;
};
#endif /*SimpleRenderWindowView_H_*/
diff --git a/Modules/Core/include/mitkBaseRenderer.h b/Modules/Core/include/mitkBaseRenderer.h
index 150e690082..f1e053d528 100644
--- a/Modules/Core/include/mitkBaseRenderer.h
+++ b/Modules/Core/include/mitkBaseRenderer.h
@@ -1,482 +1,471 @@
/*============================================================================
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 MITKBASERENDERER_H
#define MITKBASERENDERER_H
#include <mitkDataStorage.h>
#include <mitkPlaneGeometry.h>
#include <mitkPlaneGeometryData.h>
#include <mitkTimeGeometry.h>
#include <mitkCameraController.h>
#include <mitkCameraRotationController.h>
#include <mitkSliceNavigationController.h>
#include <mitkBindDispatcherInteractor.h>
#include <mitkDispatcher.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <map>
#include <set>
namespace mitk
{
class Mapper;
class BaseLocalStorageHandler;
#pragma GCC visibility push(default)
itkEventMacroDeclaration(RendererResetEvent, itk::AnyEvent);
#pragma GCC visibility pop
/*
* \brief Organizes the rendering process
*
* A BaseRenderer contains a reference to a given vtkRenderWindow
* and a corresponding vtkRenderer.
* The BaseRenderer defines which mapper should be used (2D / 3D)
* and which view direction should be rendered.
*
* All existing BaseRenderer are stored in a static variable
* that can be accessed / modified via the static functions.
* VtkPropRenderer is a concrete implementation of a BaseRenderer.
*/
class MITKCORE_EXPORT BaseRenderer : public itk::Object
{
public:
typedef std::map<vtkRenderWindow*, BaseRenderer*> BaseRendererMapType;
static BaseRendererMapType baseRendererMap;
/**
* \brief Defines which kind of mapper (e.g. 2D or 3D) should be used.
*/
enum StandardMapperSlot
{
Standard2D = 1,
Standard3D = 2
};
- /**
- * \brief Defines which view direction should be rendered.
- */
- enum class ViewDirection
- {
- AXIAL = 0,
- SAGITTAL,
- CORONAL,
- THREE_D
- };
-
static BaseRenderer* GetInstance(vtkRenderWindow* renderWindow);
static void AddInstance(vtkRenderWindow* renderWindow, BaseRenderer* baseRenderer);
static void RemoveInstance(vtkRenderWindow* renderWindow);
static BaseRenderer* GetByName(const std::string& name);
static vtkRenderWindow* GetRenderWindowByName(const std::string& name);
/**
* \brief Get a map of specific RenderWindows
*/
static BaseRendererMapType GetSpecificRenderWindows(MapperSlotId mapper);
/**
* \brief Convenience function: Get a map of all 2D RenderWindows
*/
static BaseRendererMapType GetAll2DRenderWindows();
/**
* \brief Convenience function: Get a map of all 3D RenderWindows
*/
static BaseRendererMapType GetAll3DRenderWindows();
mitkClassMacroItkParent(BaseRenderer, itk::Object);
BaseRenderer(const char* name = nullptr, vtkRenderWindow* renderWindow = nullptr);
void RemoveAllLocalStorages();
void RegisterLocalStorageHandler(BaseLocalStorageHandler* lsh);
void UnregisterLocalStorageHandler(BaseLocalStorageHandler* lsh);
virtual void SetDataStorage(DataStorage* storage);
virtual DataStorage::Pointer GetDataStorage() const
{
return m_DataStorage.GetPointer();
}
vtkRenderWindow* GetRenderWindow() const
{
return m_RenderWindow;
}
vtkRenderer* GetVtkRenderer() const
{
return m_VtkRenderer;
}
/**
* \brief Get the dispatcher, which handles events for this base renderer.
*/
Dispatcher::Pointer GetDispatcher() const;
/**
* \brief Set a new size for the render window.
*/
virtual void Resize(int w, int h);
/**
* \brief Initialize the base renderer with a vtk render window.
* Set the new renderer for the camera controller.
*/
virtual void InitRenderer(vtkRenderWindow* renderwindow);
/**
* \brief Set the initial size for the render window.
*/
virtual void InitSize(int w, int h);
virtual void DrawOverlayMouse(Point2D&)
{
MITK_INFO << "BaseRenderer::DrawOverlayMouse() should be in concret implementation OpenGLRenderer." << std::endl;
}
/**
* \brief Set the world time geometry using the given TimeGeometry.
*
* Setting a new world time geometry updates the current world geometry and the
* curent world plane geometry, using the currently selected slice and timestep.
*/
virtual void SetWorldTimeGeometry(const mitk::TimeGeometry* geometry);
itkGetConstObjectMacro(WorldTimeGeometry, TimeGeometry);
/**
* \brief Get the current time-extracted 3D-geometry.
*/
itkGetConstObjectMacro(CurrentWorldGeometry, BaseGeometry);
/**
* \brief Get the current slice-extracted 2D-geometry.
*/
itkGetConstObjectMacro(CurrentWorldPlaneGeometry, PlaneGeometry);
virtual bool SetWorldGeometryToDataStorageBounds()
{
return false;
}
/**
* \brief Set the slice that should be used for geometry extraction.
*
* The slice defines the current slice-extracted 2D-geometry (CurrentWorldPlaneGeometry).
* Setting a new slice will update the current world geometry and the
* curent world plane geometry.
*/
virtual void SetSlice(unsigned int slice);
itkGetConstMacro(Slice, unsigned int);
/**
* \brief Set the timestep that should be used for geometry extraction.
*
* The timestep defines the current time-extracted 3D-geometry (CurrentWorldGeometry).
* Setting a new timestep will update the current world geometry and the
* curent world plane geometry.
*/
virtual void SetTimeStep(unsigned int timeStep);
itkGetConstMacro(TimeStep, unsigned int);
/**
* \brief Get the timestep of a BaseData object which
* exists at the time of the currently displayed content.
*
* Returns -1 if there is no data at the current time.
*/
TimeStepType GetTimeStep(const BaseData* data) const;
/**
* \brief Get the time in ms of the currently display content (geometry).
*/
ScalarType GetTime() const;
/**
* \brief Set the world time geometry using the geometry of the given event.
*
* The function is triggered by a SliceNavigationController::GeometrySendEvent.
*/
virtual void SetGeometry(const itk::EventObject& geometrySliceEvent);
/**
* \brief Set the current world plane geometry using the existing current world geometry.
*
* The function is triggered by a SliceNavigationController::GeometryUpdateEvent.
*/
virtual void UpdateGeometry(const itk::EventObject& geometrySliceEvent);
/**
* \brief Set the current slice using "SetSlice" and update the current world geometry
* and the current world plane geometry.
*
* The function is triggered by a SliceNavigationController::GeometrySliceEvent.
*/
virtual void SetGeometrySlice(const itk::EventObject& geometrySliceEvent);
/**
* \brief Set the current time using "SetTimeStep" and update the current world geometry
* and the current world plane geometry.
*
* The function is triggered by a TimeNavigationController::TimeEvent.
*/
virtual void SetGeometryTime(const itk::EventObject& geometryTimeEvent);
itkGetObjectMacro(CurrentWorldPlaneGeometryNode, DataNode);
/**
* \brief Modify the update time of the current world plane geometry and force reslicing.
*/
void SendUpdateSlice();
/**
* \brief Get timestamp of the update time of the current world plane geometry.
*/
itkGetMacro(CurrentWorldPlaneGeometryUpdateTime, unsigned long);
/**
* \brief Get timestamp of the update time of the current timestep.
*/
itkGetMacro(TimeStepUpdateTime, unsigned long);
/**
* \brief Pick a world coordinate (x,y,z) given a display coordinate (x,y).
*
* \warning Not implemented; has to be overwritten in subclasses.
*/
virtual void PickWorldPoint(const Point2D& diplayPosition, Point3D& worldPosition) const = 0;
/**
* \brief Determines the object (mitk::DataNode) closest to the current
* position by means of picking.
*
* \warning Implementation currently empty for 2D rendering; intended to be
* implemented for 3D renderers.
*/
virtual DataNode* PickObject(const Point2D& /*displayPosition*/, Point3D& /*worldPosition*/) const
{
return nullptr;
}
/**
* \brief Get the currently used mapperID.
*/
itkGetMacro(MapperID, MapperSlotId);
itkGetConstMacro(MapperID, MapperSlotId);
/**
* \brief Set the used mapperID.
*/
virtual void SetMapperID(MapperSlotId id);
virtual int* GetSize() const;
virtual int* GetViewportSize() const;
void SetSliceNavigationController(SliceNavigationController* SlicenavigationController);
itkGetObjectMacro(CameraController, CameraController);
itkGetObjectMacro(SliceNavigationController, SliceNavigationController);
itkGetObjectMacro(CameraRotationController, CameraRotationController);
itkGetMacro(EmptyWorldGeometry, bool);
/**
* \brief Getter/Setter for defining if the displayed region should be shifted
* or rescaled if the render window is resized.
*/
itkGetMacro(KeepDisplayedRegion, bool);
itkSetMacro(KeepDisplayedRegion, bool);
/**
* \brief Return the name of the base renderer
*/
const char* GetName() const
{
return m_Name.c_str();
}
/**
* \brief Return the size in x-direction of the base renderer.
*/
int GetSizeX() const
{
return this->GetSize()[0];
}
/**
* \brief Return the size in y-direction of the base renderer.
*/
int GetSizeY() const
{
return this->GetSize()[1];
}
/**
* \brief Return the bounds of the bounding box of the
* current world geometry (time-extracted 3D-geometry).
*
* If the geometry is empty, the bounds are set to zero.
*/
const double* GetBounds() const;
void RequestUpdate();
void ForceImmediateUpdate();
/**
* \brief Return the number of mappers which are visible and have
* level-of-detail rendering enabled.
*/
unsigned int GetNumberOfVisibleLODEnabledMappers() const;
/**
* \brief Convert a display point to the 3D world index
* using the geometry of the renderWindow.
*/
void DisplayToWorld(const Point2D& displayPoint, Point3D& worldIndex) const;
/**
* \brief Convert a display point to the 2D world index, mapped onto the display plane
* using the geometry of the renderWindow.
*/
void DisplayToPlane(const Point2D& displayPoint, Point2D& planePointInMM) const;
/**
* \brief Convert a 3D world index to the display point
* using the geometry of the renderWindow.
*/
void WorldToDisplay(const Point3D& worldIndex, Point2D& displayPoint) const;
/**
* \brief Convert a 3D world index to the point on the viewport
* using the geometry of the renderWindow.
*/
void WorldToView(const Point3D& worldIndex, Point2D& viewPoint) const;
/**
* \brief Convert a 2D plane coordinate to the display point
* using the geometry of the renderWindow.
*/
void PlaneToDisplay(const Point2D& planePointInMM, Point2D& displayPoint) const;
/**
* \brief Convert a 2D plane coordinate to the point on the viewport
* using the geometry of the renderWindow.
*/
void PlaneToView(const Point2D& planePointInMM, Point2D& viewPoint) const;
double GetScaleFactorMMPerDisplayUnit() const;
Point2D GetDisplaySizeInMM() const;
Point2D GetViewportSizeInMM() const;
Point2D GetOriginInMM() const;
itkGetConstMacro(ConstrainZoomingAndPanning, bool)
virtual void SetConstrainZoomingAndPanning(bool constrain);
protected:
~BaseRenderer() override;
virtual void Update() = 0;
vtkRenderWindow* m_RenderWindow;
vtkRenderer* m_VtkRenderer;
MapperSlotId m_MapperID;
DataStorage::Pointer m_DataStorage;
unsigned long m_LastUpdateTime;
CameraController::Pointer m_CameraController;
CameraRotationController::Pointer m_CameraRotationController;
SliceNavigationController::Pointer m_SliceNavigationController;
void UpdateCurrentGeometries();
virtual void SetCurrentWorldPlaneGeometry(const PlaneGeometry* geometry2d);
virtual void SetCurrentWorldGeometry(const BaseGeometry *geometry);
private:
/**
* \brief Pointer to the current TimeGeometry.
*
* This WorldTimeGeometry is used to extract a SlicedGeometry3D,
* using the current timestep (set via SetTimeStep).
* The time-extracted 3D-geometry is used as the "CurrentWorldgeometry".
* It will be set using the "SetCurrentWorldGeometry"-function.
* A PlaneGeometry can further be extracted using the current slice (set via SetSlice).
* The slice-extracted 2D-geometry is used as the "CurrentWorldPlaneGeometry".
* It will be set using the "SetCurrentWorldPlaneGeometry"-function.
*/
TimeGeometry::ConstPointer m_WorldTimeGeometry;
/**
* \brief Pointer to the current time-extracted 3D-geometry.
*
* This CurrentWorldGeometry is used to define the bounds for this
* BaseRenderer.
* It will be set using the "SetCurrentWorldGeometry"-function.
*/
BaseGeometry::ConstPointer m_CurrentWorldGeometry;
/**
* \brief Pointer to the current slice-extracted 2D-geometry.
*
* This CurrentWorldPlaneGeometry is used to define the maximal
* area (2D manifold) to be rendered in case we are doing 2D-rendering.
* It will be set using the "SetCurrentWorldPlaneGeometry"-function.
*/
PlaneGeometry::Pointer m_CurrentWorldPlaneGeometry;
unsigned int m_Slice;
unsigned int m_TimeStep;
itk::TimeStamp m_CurrentWorldPlaneGeometryUpdateTime;
itk::TimeStamp m_TimeStepUpdateTime;
BindDispatcherInteractor* m_BindDispatcherInteractor;
bool m_KeepDisplayedRegion;
protected:
void PrintSelf(std::ostream& os, itk::Indent indent) const override;
PlaneGeometryData::Pointer m_CurrentWorldPlaneGeometryData;
DataNode::Pointer m_CurrentWorldPlaneGeometryNode;
unsigned long m_CurrentWorldPlaneGeometryTransformTime;
std::string m_Name;
double m_Bounds[6];
bool m_EmptyWorldGeometry;
typedef std::set<Mapper*> LODEnabledMappersType;
unsigned int m_NumberOfVisibleLODEnabledMappers;
std::list<BaseLocalStorageHandler*> m_RegisteredLocalStorageHandlers;
bool m_ConstrainZoomingAndPanning;
};
} // namespace mitk
#endif // MITKBASERENDERER_H
diff --git a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
index 419d27c275..f67e9a53ff 100644
--- a/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkAbstractMultiWidget.h
@@ -1,182 +1,181 @@
/*============================================================================
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 QMITKABSTRACTMULTIWIDGET_H
#define QMITKABSTRACTMULTIWIDGET_H
// mitk qt widgets module
#include "MitkQtWidgetsExports.h"
// mitk core
#include <mitkBaseRenderer.h>
#include <mitkDisplayActionEventHandler.h>
#include <mitkInteractionSchemeSwitcher.h>
#include <mitkPoint.h>
// qt
#include <QWidget>
// c++
#include <map>
#include <memory>
class QmitkMultiWidgetLayoutManager;
class QmitkRenderWindow;
class QmitkRenderWindowWidget;
namespace mitk
{
class DataStorage;
class InteractionEventHandler;
}
/**
* @brief The 'QmitkAbstractMultiWidget' is a 'QWidget' that can be subclassed to display multiple render windows at once.
* Render windows can dynamically be added and removed to change the layout of the multi widget.
* A subclass of this multi widget can be used inside a 'QmitkAbstractMultiWidgetEditor'.
*
* The class uses the 'DisplayActionEventBroadcast' and 'DisplayActionEventHandler' classes to
* load a state machine and set an event configuration.
*
* Using the 'Synchronize' function the user can enable or disable the synchronization of display action events.
* See 'DisplayActionEventFunctions'-class for the different synchronized and non-synchronized functions used.
*/
class MITKQTWIDGETS_EXPORT QmitkAbstractMultiWidget : public QWidget
{
Q_OBJECT
public:
using RenderWindowWidgetPointer = std::shared_ptr<QmitkRenderWindowWidget>;
using RenderWindowWidgetMap = std::map<QString, std::shared_ptr<QmitkRenderWindowWidget>>;
using RenderWindowHash = QHash<QString, QmitkRenderWindow*>;
- using ViewDirection = mitk::BaseRenderer::ViewDirection;
QmitkAbstractMultiWidget(QWidget* parent = 0,
Qt::WindowFlags f = 0,
const QString& multiWidgetName = "multiwidget");
virtual ~QmitkAbstractMultiWidget();
virtual void InitializeMultiWidget() = 0;
virtual void MultiWidgetOpened() { }
virtual void MultiWidgetClosed() { }
virtual void SetDataStorage(mitk::DataStorage* dataStorage);
mitk::DataStorage* GetDataStorage() const;
int GetRowCount() const;
int GetColumnCount() const;
virtual void SetLayout(int row, int column);
virtual void Synchronize(bool) { };
virtual void SetInteractionScheme(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
mitk::InteractionEventHandler* GetInteractionEventHandler();
void SetDisplayActionEventHandler(std::unique_ptr<mitk::DisplayActionEventHandler> displayActionEventHandler);
mitk::DisplayActionEventHandler* GetDisplayActionEventHandler();
RenderWindowWidgetMap GetRenderWindowWidgets() const;
RenderWindowWidgetMap Get2DRenderWindowWidgets() const;
RenderWindowWidgetMap Get3DRenderWindowWidgets() const;
RenderWindowWidgetPointer GetRenderWindowWidget(int row, int column) const;
RenderWindowWidgetPointer GetRenderWindowWidget(const QString& widgetName) const;
RenderWindowWidgetPointer GetRenderWindowWidget(const QmitkRenderWindow* renderWindow) const;
RenderWindowHash GetRenderWindows() const;
QmitkRenderWindow* GetRenderWindow(int row, int column) const;
virtual QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const;
- virtual QmitkRenderWindow* GetRenderWindow(const ViewDirection& viewDirection) const = 0;
+ virtual QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const = 0;
virtual void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget);
RenderWindowWidgetPointer GetActiveRenderWindowWidget() const;
RenderWindowWidgetPointer GetFirstRenderWindowWidget() const;
RenderWindowWidgetPointer GetLastRenderWindowWidget() const;
virtual QString GetNameFromIndex(int row, int column) const;
virtual QString GetNameFromIndex(size_t index) const;
unsigned int GetNumberOfRenderWindowWidgets() const;
void RequestUpdate(const QString& widgetName);
void RequestUpdateAll();
void ForceImmediateUpdate(const QString& widgetName);
void ForceImmediateUpdateAll();
/**
* @brief Set the reference geometry for interaction inside the render windows of the render window part.
*
* The concrete implementation is subclass-specific, no default implementation is provided here.
*
* @param referenceGeometry The reference geometry which is used for updating the
* time geometry inside the render windows.
* @param resetCamera If true, the camera and crosshair will be reset to the default view (centered, no zoom).
* If false, the current crosshair position and the camera zoom will be stored and reset
* after the reference geometry has been updated.
*/
virtual void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) = 0;
/**
* @brief Returns true if the render windows are coupled; false if not.
*
* Render windows are coupled if the slice navigation controller of the render windows
* are connected which means that always the same geometry is used for the render windows.
*/
virtual bool HasCoupledRenderWindows() const = 0;
virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) = 0;
virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const = 0;
virtual void SetCrosshairVisibility(bool visible) = 0;
virtual bool GetCrosshairVisibility() const = 0;
virtual void SetCrosshairGap(unsigned int gapSize) = 0;
virtual void ResetCrosshair() = 0;
virtual void SetWidgetPlaneMode(int mode) = 0;
virtual void ActivateMenuWidget(bool state);
virtual bool IsMenuWidgetEnabled() const;
QmitkMultiWidgetLayoutManager* GetMultiWidgetLayoutManager() const;
signals:
void ActiveRenderWindowChanged();
private slots:
void OnFocusChanged(itk::Object*, const itk::EventObject& event);
protected:
virtual void AddRenderWindowWidget(const QString& widgetName, RenderWindowWidgetPointer renderWindowWidget);
virtual void RemoveRenderWindowWidget();
private:
/**
* @brief This function will be called by the function 'SetLayout' and
* can be implemented and customized in the subclasses.
*/
virtual void SetLayoutImpl() = 0;
/**
* @brief This function will be called by the function 'SetInteractionScheme' and
* can be implemented and customized in the subclasses.
*/
virtual void SetInteractionSchemeImpl() = 0;
struct Impl;
std::unique_ptr<Impl> m_Impl;
};
#endif // QMITKABSTRACTMULTIWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index 42505725a6..83134b4d79 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,109 +1,109 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QMITKMXNMULTIWIDGET_H
#define QMITKMXNMULTIWIDGET_H
// qt widgets module
#include "MitkQtWidgetsExports.h"
#include "QmitkAbstractMultiWidget.h"
/**
* @brief The 'QmitkMxNMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
* Render windows can dynamically be added and removed to change the layout of the multi widget. This
* is done by using the 'SetLayout'-function to define a layout. This will automatically add or remove
* the appropriate number of render window widgets.
*/
class MITKQTWIDGETS_EXPORT QmitkMxNMultiWidget : public QmitkAbstractMultiWidget
{
Q_OBJECT
public:
QmitkMxNMultiWidget(QWidget* parent = nullptr,
Qt::WindowFlags f = 0,
const QString& multiWidgetName = "mxnmulti");
~QmitkMxNMultiWidget();
void InitializeMultiWidget() override;
void Synchronize(bool synchronized) override;
QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
- QmitkRenderWindow* GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
+ QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
/**
* @brief Set the reference geometry for interaction inside the active render windows of the MxNMultiWidget.
*
* @param referenceGeometry The reference geometry which is used for updating the
* time geometry inside the active render window.
* @param resetCamera If true, the camera and crosshair will be reset to the default view (centered, no zoom).
* If false, the current crosshair position and the camera zoom will be stored and reset
* after the reference geometry has been updated.
*/
void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
/**
* @brief Returns true if the render windows are coupled; false if not.
*
* For the MxNMultiWidget the render windows are typically decoupled.
*/
bool HasCoupledRenderWindows() const override;
void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
void SetCrosshairVisibility(bool visible) override;
bool GetCrosshairVisibility() const override;
void SetCrosshairGap(unsigned int gapSize) override;
void ResetCrosshair() override;
void SetWidgetPlaneMode(int userMode) override;
mitk::SliceNavigationController* GetTimeNavigationController();
void AddPlanesToDataStorage();
void RemovePlanesFromDataStorage();
public Q_SLOTS:
// mouse events
void wheelEvent(QWheelEvent* e) override;
void mousePressEvent(QMouseEvent* e) override;
void moveEvent(QMoveEvent* e) override;
Q_SIGNALS:
void WheelMoved(QWheelEvent *);
void Moved();
protected:
void RemoveRenderWindowWidget() override;
private:
void SetLayoutImpl() override;
void SetInteractionSchemeImpl() override { }
void CreateRenderWindowWidget();
mitk::SliceNavigationController* m_TimeNavigationController;
bool m_CrosshairVisibility;
};
#endif // QMITKMXNMULTIWIDGET_H
diff --git a/Modules/QtWidgets/include/QmitkRenderWindowMenu.h b/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
index f0f96cb4db..3adde91d39 100644
--- a/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
+++ b/Modules/QtWidgets/include/QmitkRenderWindowMenu.h
@@ -1,194 +1,194 @@
/*============================================================================
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 QMITKRENDERWINDOWMENU_H
#define QMITKRENDERWINDOWMENU_H
// mitk qtwidgets module
#include "MitkQtWidgetsExports.h"
#include "QmitkMultiWidgetLayoutManager.h"
// mitk core
#include <mitkBaseRenderer.h>
// qt
#include <QAction>
#include <QEvent>
#include <QLabel>
#include <QMenuBar>
#include <QPushButton>
#include <QTimer>
#include <QToolButton>
#include <QWidget>
/**
* \ingroup QmitkModule
* \brief The QmitkRenderWindowMenu is a popup Widget which shows
* up when the mouse cursor enter a QmitkRenderWindow.
* The Menu Widget is located in the right top corner of each
* RenderWindow. It includes different settings. For example
* the layout design can be changed with the setting button. Switching
* between full-screen mode and layout design can be done
* with the full-screen button.
* The popup Widget can be deactivated with ActivateMenuWidget(false) in
* QmitkRenderWindow.
*
* \sa QmitkRenderWindow
*
*/
class MITKQTWIDGETS_EXPORT QmitkRenderWindowMenu : public QWidget
{
Q_OBJECT
public:
- using LayoutIndex = mitk::BaseRenderer::ViewDirection;
+ using LayoutIndex = mitk::AnatomicalPlane;
using LayoutDesign = QmitkMultiWidgetLayoutManager::LayoutDesign;
QmitkRenderWindowMenu(QWidget *parent = nullptr,
Qt::WindowFlags f = nullptr,
mitk::BaseRenderer *b = nullptr);
~QmitkRenderWindowMenu() override;
/*! Return visibility of settings menu. The menu is connected with m_SettingsButton and includes
layout direction (axial, coronal .. ) and layout design (standard layout, 2D images top,
3D bottom ... ). */
bool GetSettingsMenuVisibilty()
{
if (m_LayoutActionsMenu == nullptr)
return false;
else
return m_LayoutActionsMenu->isVisible();
}
/*! Set layout index. Defines layout direction (axial, coronal, sagittal or threeD) of the parent. */
void SetLayoutIndex(LayoutIndex layoutIndex);
/*! Return layout direction of parent (axial, coronal, sagittal or threeD) */
LayoutIndex GetLayoutIndex() { return m_Layout; }
/*! Update list of layout design (standard layout, 2D images top, 3D bottom ..). Set action of current layout design
to disable and all other to enable. */
void UpdateLayoutDesignList(LayoutDesign layoutDesign);
void UpdateCrosshairVisibility(bool visible);
void UpdateCrosshairRotationMode(int mode);
/*! Move menu widget to correct position (right upper corner). E.g. it is necessary when the full-screen mode
is activated.*/
void MoveWidgetToCorrectPos();
void ShowMenu();
void HideMenu();
protected:
/*! Reimplemented from QWidget. The paint event is a request to repaint all or part of a widget.*/
void paintEvent(QPaintEvent *event) override;
void CreateMenuWidget();
/*! Create settings menu which contains layout direction and the different layout designs. */
void CreateSettingsWidget();
/*! Change Icon of full-screen button depending on full-screen mode. */
void ChangeFullScreenIcon();
Q_SIGNALS:
void ResetView(); // == "global reinit"
void CrosshairVisibilityChanged(bool);
// \brief int parameters are enum from QmitkStdMultiWidget
void CrosshairRotationModeChanged(int);
/*! emit signal, when layout design changed by the setting menu.*/
void LayoutDesignChanged(LayoutDesign layoutDesign);
protected Q_SLOTS:
/// this function is continuously called by a timer
/// to do the auto rotation
void AutoRotateNextStep();
/// this function is invoked when the auto-rotate action
/// is clicked
void OnAutoRotationActionTriggered();
void OnTSNumChanged(int);
void OnCrosshairMenuAboutToShow();
void OnCrosshairVisibilityChanged(bool);
void OnCrosshairRotationModeSelected(QAction *);
/*! slot for activating/deactivating the full-screen mode. The slot is connected to the clicked() event of
m_FullScreenButton.
Activating the full-screen maximize the current widget, deactivating restore If layout design changed by the settings
menu, the full-Screen mode is automatically switched to false. */
void OnFullScreenButton(bool checked);
/*! Slot for opening setting menu. The slot is connected to the clicked() event of m_SettingsButton.
The settings menu includes different layout directions (axial, coronal, sagittal and 3D) as well all layout design
(standard layout, 2D images top, 3D bottom ..)*/
void OnLayoutDesignButton(bool checked);
void OnSetLayout(LayoutDesign layoutDesign);
protected:
QToolButton* m_CrosshairModeButton;
QToolButton* m_FullScreenButton;
QToolButton* m_LayoutDesignButton;
QMenu* m_LayoutActionsMenu;
QAction* m_DefaultLayoutAction;
QAction* m_All2DTop3DBottomLayoutAction;
QAction* m_All2DLeft3DRightLayoutAction;
QAction* m_OneBigLayoutAction;
QAction* m_Only2DHorizontalLayoutAction;
QAction* m_Only2DVerticalLayoutAction;
QAction* m_OneTop3DBottomLayoutAction;
QAction* m_OneLeft3DRightLayoutAction;
QAction* m_AllHorizontalLayoutAction;
QAction* m_AllVerticalLayoutAction;
QAction* m_RemoveOneLayoutAction;
QLabel *m_TSLabel;
QMenu *m_CrosshairMenu;
/*! Flag if full-screen mode is activated or deactivated. */
bool m_FullScreenMode;
private:
mitk::BaseRenderer::Pointer m_Renderer;
QTimer* m_AutoRotationTimer;
QWidget *m_Parent;
//memory because mode is set to default for slice num = 1
static unsigned int m_DefaultThickMode;
int m_CrosshairRotationMode;
bool m_CrosshairVisibility;
LayoutIndex m_Layout;
LayoutDesign m_LayoutDesign;
LayoutDesign m_OldLayoutDesign;
};
#endif // QMITKRENDERWINDOWMENU_H
diff --git a/Modules/QtWidgets/include/QmitkStdMultiWidget.h b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
index c9b4e1dceb..505e38c9e4 100644
--- a/Modules/QtWidgets/include/QmitkStdMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkStdMultiWidget.h
@@ -1,169 +1,169 @@
/*============================================================================
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 QMITKSTDMULTIWIDGET_H
#define QMITKSTDMULTIWIDGET_H
// qt widgets module
#include "MitkQtWidgetsExports.h"
#include "QmitkAbstractMultiWidget.h"
/**
* @brief The 'QmitkStdMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
* Render windows are predefined in a 2x2 design with 3 different 2D view planes and a 3D render window.
*/
class MITKQTWIDGETS_EXPORT QmitkStdMultiWidget : public QmitkAbstractMultiWidget
{
Q_OBJECT
public:
QmitkStdMultiWidget(
QWidget *parent = nullptr,
Qt::WindowFlags f = nullptr,
const QString &name = "stdmulti");
~QmitkStdMultiWidget() override;
virtual void InitializeMultiWidget() override;
virtual QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
- virtual QmitkRenderWindow* GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
+ virtual QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
/**
* @brief Set the reference geometry for interaction inside all render windows of the StdMultiWidget.
*
* @param referenceGeometry The reference geometry which is used for updating the
* time geometry inside all four render windows.
* @param resetCamera If true, the camera and crosshair will be reset to the default view (centered, no zoom).
* If false, the current crosshair position and the camera zoom will be stored and reset
* after the reference geometry has been updated.
*/
void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
/**
* @brief Returns true if the render windows are coupled; false if not.
*
* For the StdMultiWidget the render windows are typically coupled.
*/
bool HasCoupledRenderWindows() const override;
virtual void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
virtual const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
virtual void SetCrosshairVisibility(bool) override;
virtual bool GetCrosshairVisibility() const override;
void SetCrosshairGap(unsigned int gapSize) override;
virtual void ResetCrosshair() override;
virtual void SetWidgetPlaneMode(int mode) override;
mitk::SliceNavigationController* GetTimeNavigationController();
void AddPlanesToDataStorage();
void RemovePlanesFromDataStorage();
/**
* @brief Convenience method to get a render window widget.
* @param number of the widget (0-3)
* @return The render window widget
*/
QmitkRenderWindow* GetRenderWindow(unsigned int number) const;
QmitkRenderWindow* GetRenderWindow1() const;
QmitkRenderWindow* GetRenderWindow2() const;
QmitkRenderWindow* GetRenderWindow3() const;
QmitkRenderWindow* GetRenderWindow4() const;
/**
* @brief Convenience method to get a widget plane.
* @param number of the widget plane (1-3)
* @return The widget plane as data node
*/
mitk::DataNode::Pointer GetWidgetPlane(unsigned int number) const;
mitk::DataNode::Pointer GetWidgetPlane1() const;
mitk::DataNode::Pointer GetWidgetPlane2() const;
mitk::DataNode::Pointer GetWidgetPlane3() const;
/**
* @brief SetDecorationColor Set the color of the decoration of the 4 widgets.
*
* This is used to color the frame of the renderwindow and the corner annatation.
* For the first 3 widgets, this color is a property of the helper object nodes
* which contain the respective plane geometry. For widget 4, this is a member,
* since there is no data node for this widget.
*/
void SetDecorationColor(unsigned int widgetNumber, mitk::Color color);
/**
* @brief GetDecorationColorForWidget Get the color for annotation, crosshair and rectangle.
* @param widgetNumber Number of the renderwindow (0-3).
* @return Color in mitk format.
*/
mitk::Color GetDecorationColor(unsigned int widgetNumber);
public Q_SLOTS:
// mouse events
virtual void mousePressEvent(QMouseEvent*) override;
virtual void moveEvent(QMoveEvent* e) override;
virtual void wheelEvent(QWheelEvent* e) override;
void Fit();
void AddDisplayPlaneSubTree();
void EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p);
void SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer = nullptr);
void SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer = nullptr);
Q_SIGNALS:
void NotifyCrosshairVisibilityChanged(bool visible);
void NotifyCrosshairRotationModeChanged(int mode);
void WheelMoved(QWheelEvent *);
void Moved();
private:
virtual void SetLayoutImpl() override;
virtual void SetInteractionSchemeImpl() override { }
void CreateRenderWindowWidgets();
mitk::SliceNavigationController* m_TimeNavigationController;
/**
* @brief The 3 helper objects which contain the plane geometry.
*/
mitk::DataNode::Pointer m_PlaneNode1;
mitk::DataNode::Pointer m_PlaneNode2;
mitk::DataNode::Pointer m_PlaneNode3;
/**
* @brief m_ParentNodeForGeometryPlanes This helper object is added to the datastorage
* and contains the 3 planes for displaying the image geometry (crosshair and 3D planes).
*/
mitk::DataNode::Pointer m_ParentNodeForGeometryPlanes;
/**
* @brief m_DecorationColorWidget4 color for annotation and rectangle of widget 4.
*
* For other widgets1-3, the color is a property of the respective data node.
* There is no node for widget 4, hence, we need an extra member.
*/
mitk::Color m_DecorationColorWidget4;
};
#endif // QMITKSTDMULTIWIDGET_H
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index cdb9bce6f6..b0eafd2806 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,381 +1,381 @@
/*============================================================================
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 <mitkDisplayActionEventFunctions.h>
#include <mitkDisplayActionEventHandlerDesynchronized.h>
#include <mitkDisplayActionEventHandlerSynchronized.h>
// qt
#include <QGridLayout>
#include <QMessageBox>
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<mitk::DisplayActionEventHandlerDesynchronized>());
auto displayActionEventHandler = GetDisplayActionEventHandler();
if (nullptr != displayActionEventHandler)
{
displayActionEventHandler->InitActions();
}
}
void QmitkMxNMultiWidget::Synchronize(bool synchronized)
{
if (synchronized)
{
SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerSynchronized>());
}
else
{
SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
}
auto displayActionEventHandler = GetDisplayActionEventHandler();
if (nullptr != displayActionEventHandler)
{
displayActionEventHandler->InitActions();
}
}
QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
{
if ("axial" == widgetName || "sagittal" == widgetName || "coronal" == widgetName || "3d" == widgetName)
{
return GetActiveRenderWindowWidget()->GetRenderWindow();
}
return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
}
-QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& /*viewDirection*/) const
+QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::AnatomicalPlane& /*orientation*/) const
{
- // currently no mapping between view directions and render windows
+ // currently no mapping between plane orientation and render windows
// simply return the currently active render window
return GetActiveRenderWindowWidget()->GetRenderWindow();
}
void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
{
auto currentActiveRenderWindowWidget = GetActiveRenderWindowWidget();
if (currentActiveRenderWindowWidget == activeRenderWindowWidget)
{
return;
}
// reset the decoration color of the previously active render window widget
if (nullptr != currentActiveRenderWindowWidget)
{
auto decorationColor = currentActiveRenderWindowWidget->GetDecorationColor();
QColor hexColor(decorationColor[0] * 255, decorationColor[1] * 255, decorationColor[2] * 255);
currentActiveRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " +
hexColor.name(QColor::HexRgb) + "; }");
}
// set the new decoration color of the currently active render window widget
if (nullptr != activeRenderWindowWidget)
{
activeRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid #FF6464; }");
}
QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(activeRenderWindowWidget);
}
void QmitkMxNMultiWidget::SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera)
{
auto* renderingManager = mitk::RenderingManager::GetInstance();
mitk::Point3D currentPosition = mitk::Point3D();
unsigned int imageTimeStep = 0;
if (!resetCamera)
{
// store the current position to set it again later, if the camera should not be reset
currentPosition = this->GetSelectedPosition("");
// store the current time step to set it again later, if the camera should not be reset
const auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
if (referenceGeometry->IsValidTimePoint(currentTimePoint))
{
imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
}
}
// initialize active render window
renderingManager->InitializeView(
this->GetActiveRenderWindowWidget()->GetRenderWindow()->GetVtkRenderWindow(), referenceGeometry, resetCamera);
if (!resetCamera)
{
this->SetSelectedPosition(currentPosition, "");
renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
}
}
bool QmitkMxNMultiWidget::HasCoupledRenderWindows() const
{
return false;
}
void QmitkMxNMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName)
{
RenderWindowWidgetPointer renderWindowWidget;
if (widgetName.isNull() || widgetName.isEmpty())
{
renderWindowWidget = GetActiveRenderWindowWidget();
}
else
{
renderWindowWidget = GetRenderWindowWidget(widgetName);
}
if (nullptr != renderWindowWidget)
{
renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
return;
}
MITK_ERROR << "Position can not be set for an unknown render window widget.";
}
const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& widgetName) const
{
RenderWindowWidgetPointer renderWindowWidget;
if (widgetName.isNull() || widgetName.isEmpty())
{
renderWindowWidget = GetActiveRenderWindowWidget();
}
else
{
renderWindowWidget = GetRenderWindowWidget(widgetName);
}
if (nullptr != renderWindowWidget)
{
return renderWindowWidget->GetCrosshairPosition();
}
MITK_ERROR << "Crosshair position can not be retrieved.";
return mitk::Point3D(0.0);
}
void QmitkMxNMultiWidget::SetCrosshairVisibility(bool visible)
{
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return;
}
auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
renderWindowWidget->SetCrosshairVisibility(visible);
}
bool QmitkMxNMultiWidget::GetCrosshairVisibility() const
{
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return false;
}
auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
return renderWindowWidget->GetCrosshairVisibility();
}
void QmitkMxNMultiWidget::SetCrosshairGap(unsigned int gapSize)
{
auto renderWindowWidgets = this->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : renderWindowWidgets)
{
renderWindowWidget.second->SetCrosshairGap(gapSize);
}
}
void QmitkMxNMultiWidget::ResetCrosshair()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return;
}
mitk::RenderingManager::GetInstance()->InitializeViewByBoundingObjects(renderWindow->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<QmitkRenderWindowWidget>(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/QmitkRenderWindow.cpp b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
index 29244be83f..be434f645b 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindow.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindow.cpp
@@ -1,505 +1,505 @@
/*============================================================================
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 "QmitkRenderWindow.h"
#include "mitkInteractionKeyEvent.h"
#include "mitkInternalEvent.h"
#include "mitkMouseDoubleClickEvent.h"
#include "mitkMouseMoveEvent.h"
#include "mitkMousePressEvent.h"
#include "mitkMouseReleaseEvent.h"
#include "mitkMouseWheelEvent.h"
#include <mitkStatusBar.h>
#include <QCursor>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QResizeEvent>
#include <QSurfaceFormat>
#include <QTimer>
#include <QWheelEvent>
#include <QWindow>
#include "QmitkMimeTypes.h"
#include "QmitkRenderWindowMenu.h"
QmitkRenderWindow::QmitkRenderWindow(QWidget *parent, const QString &name, mitk::VtkPropRenderer *)
: QVTKOpenGLNativeWidget(parent)
, m_ResendQtEvents(true)
, m_MenuWidget(nullptr)
, m_MenuWidgetActivated(false)
- , m_LayoutIndex(QmitkRenderWindowMenu::LayoutIndex::AXIAL)
+ , m_LayoutIndex(QmitkRenderWindowMenu::LayoutIndex::Axial)
, m_GeometryViolationWarningOverlay(nullptr)
{
m_InternalRenderWindow = vtkSmartPointer<vtkGenericOpenGLRenderWindow>::New();
m_InternalRenderWindow->SetMultiSamples(0);
m_InternalRenderWindow->SetAlphaBitPlanes(0);
setRenderWindow(m_InternalRenderWindow);
Initialize(name.toStdString().c_str());
setFocusPolicy(Qt::StrongFocus);
setMouseTracking(true);
QSizePolicy sizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
setSizePolicy(sizePolicy);
// setup overlay widget to show a warning message
m_GeometryViolationWarningOverlay = new QmitkSimpleTextOverlayWidget(this);
m_GeometryViolationWarningOverlay->setVisible(false);
m_GeometryViolationWarningOverlay->SetOverlayText(
QStringLiteral("<font class=\"warning\"><p style=\"text-align:center\">Interaction is not possible because the "
"render window is not aligned.</p></center></font>"));
}
QmitkRenderWindow::~QmitkRenderWindow()
{
Destroy(); // Destroy mitkRenderWindowBase
}
void QmitkRenderWindow::SetResendQtEvents(bool resend)
{
m_ResendQtEvents = resend;
}
void QmitkRenderWindow::SetLayoutIndex(QmitkRenderWindowMenu::LayoutIndex layoutIndex)
{
m_LayoutIndex = layoutIndex;
if (nullptr != m_MenuWidget)
{
m_MenuWidget->SetLayoutIndex(layoutIndex);
}
}
QmitkRenderWindowMenu::LayoutIndex QmitkRenderWindow::GetLayoutIndex()
{
if (nullptr != m_MenuWidget)
{
return m_MenuWidget->GetLayoutIndex();
}
else
{
- return QmitkRenderWindowMenu::LayoutIndex::AXIAL;
+ return QmitkRenderWindowMenu::LayoutIndex::Axial;
}
}
void QmitkRenderWindow::UpdateLayoutDesignList(QmitkRenderWindowMenu::LayoutDesign layoutDesign)
{
if (nullptr != m_MenuWidget)
{
m_MenuWidget->UpdateLayoutDesignList(layoutDesign);
}
}
void QmitkRenderWindow::UpdateCrosshairVisibility(bool visible)
{
m_MenuWidget->UpdateCrosshairVisibility(visible);
}
void QmitkRenderWindow::UpdateCrosshairRotationMode(int mode)
{
m_MenuWidget->UpdateCrosshairRotationMode(mode);
}
void QmitkRenderWindow::ActivateMenuWidget(bool state)
{
if (nullptr == m_MenuWidget)
{
m_MenuWidget = new QmitkRenderWindowMenu(this, nullptr, m_Renderer);
m_MenuWidget->SetLayoutIndex(m_LayoutIndex);
}
m_MenuWidgetActivated = state;
if (m_MenuWidgetActivated)
{
connect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
connect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
connect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
}
else
{
disconnect(m_MenuWidget, &QmitkRenderWindowMenu::LayoutDesignChanged, this, &QmitkRenderWindow::LayoutDesignChanged);
disconnect(m_MenuWidget, &QmitkRenderWindowMenu::ResetView, this, &QmitkRenderWindow::ResetView);
disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairVisibilityChanged, this, &QmitkRenderWindow::CrosshairVisibilityChanged);
disconnect(m_MenuWidget, &QmitkRenderWindowMenu::CrosshairRotationModeChanged, this, &QmitkRenderWindow::CrosshairRotationModeChanged);
m_MenuWidget->hide();
}
}
void QmitkRenderWindow::ShowOverlayMessage(bool show)
{
m_GeometryViolationWarningOverlay->setVisible(show);
}
void QmitkRenderWindow::moveEvent(QMoveEvent *event)
{
QVTKOpenGLNativeWidget::moveEvent(event);
// after a move the overlays need to be positioned
emit moved();
}
void QmitkRenderWindow::showEvent(QShowEvent *event)
{
QVTKOpenGLNativeWidget::showEvent(event);
// this singleshot is necessary to have the overlays positioned correctly after initial show
// simple call of moved() is no use here!!
QTimer::singleShot(0, this, SIGNAL(moved()));
}
bool QmitkRenderWindow::event(QEvent* e)
{
mitk::InteractionEvent::Pointer mitkEvent = nullptr;
mitk::Point2D mousePosition;
bool updateStatusBar = false;
switch (e->type())
{
case QEvent::MouseMove:
{
auto me = static_cast<QMouseEvent *>(e);
mousePosition = this->GetMousePosition(me);
mitkEvent = mitk::MouseMoveEvent::New(m_Renderer, mousePosition, GetButtonState(me), GetModifiers(me));
updateStatusBar = true;
break;
}
case QEvent::MouseButtonPress:
{
auto me = static_cast<QMouseEvent *>(e);
mitkEvent = mitk::MousePressEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
break;
}
case QEvent::MouseButtonRelease:
{
auto me = static_cast<QMouseEvent *>(e);
mitkEvent = mitk::MouseReleaseEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
break;
}
case QEvent::MouseButtonDblClick:
{
auto me = static_cast<QMouseEvent *>(e);
mitkEvent = mitk::MouseDoubleClickEvent::New( m_Renderer, GetMousePosition(me), GetButtonState(me), GetModifiers(me), GetEventButton(me));
break;
}
case QEvent::Wheel:
{
auto we = static_cast<QWheelEvent *>(e);
mousePosition = this->GetMousePosition(we);
mitkEvent = mitk::MouseWheelEvent::New(m_Renderer, mousePosition, GetButtonState(we), GetModifiers(we), GetDelta(we));
updateStatusBar = true;
break;
}
case QEvent::KeyPress:
{
auto ke = static_cast<QKeyEvent*>(e);
mitkEvent = mitk::InteractionKeyEvent::New(m_Renderer, GetKeyLetter(ke), GetModifiers(ke));
break;
}
case QEvent::Resize:
{
if (nullptr != m_MenuWidget)
m_MenuWidget->MoveWidgetToCorrectPos();
}
default:
{
break;
}
}
if (mitkEvent != nullptr)
{
if (this->HandleEvent(mitkEvent.GetPointer())) {
return m_ResendQtEvents ? false : true;
}
}
if (updateStatusBar)
{
this->UpdateStatusBar(mousePosition);
}
return QVTKOpenGLNativeWidget::event(e);
}
void QmitkRenderWindow::enterEvent(QEvent *e)
{
mitk::InternalEvent::Pointer internalEvent = mitk::InternalEvent::New(m_Renderer, nullptr, "EnterRenderWindow");
this->HandleEvent(internalEvent.GetPointer());
if (nullptr != m_MenuWidget)
m_MenuWidget->ShowMenu();
QVTKOpenGLNativeWidget::enterEvent(e);
}
void QmitkRenderWindow::leaveEvent(QEvent *e)
{
auto statusBar = mitk::StatusBar::GetInstance();
statusBar->DisplayGreyValueText("");
mitk::InternalEvent::Pointer internalEvent = mitk::InternalEvent::New(m_Renderer, nullptr, "LeaveRenderWindow");
this->HandleEvent(internalEvent.GetPointer());
if (nullptr != m_MenuWidget)
m_MenuWidget->HideMenu();
QVTKOpenGLNativeWidget::leaveEvent(e);
}
void QmitkRenderWindow::resizeGL(int w, int h)
{
QVTKOpenGLNativeWidget::resizeGL(w, h);
mitk::RenderingManager::GetInstance()->ForceImmediateUpdate(renderWindow());
}
void QmitkRenderWindow::dragEnterEvent(QDragEnterEvent *event)
{
if (event->mimeData()->hasFormat("application/x-mitk-datanodes"))
{
event->accept();
}
}
void QmitkRenderWindow::dropEvent(QDropEvent *event)
{
QList<mitk::DataNode *> dataNodeList = QmitkMimeTypes::ToDataNodePtrList(event->mimeData());
if (!dataNodeList.empty())
{
emit NodesDropped(this, dataNodeList.toVector().toStdVector());
}
}
void QmitkRenderWindow::DeferredHideMenu()
{
MITK_DEBUG << "QmitkRenderWindow::DeferredHideMenu";
if (nullptr != m_MenuWidget)
{
m_MenuWidget->HideMenu();
}
}
mitk::Point2D QmitkRenderWindow::GetMousePosition(QMouseEvent *me) const
{
mitk::Point2D point;
point[0] = me->x();
// We need to convert the y component, as the display and vtk have other definitions for the y direction
point[1] = m_Renderer->GetSizeY() - me->y();
return point;
}
mitk::Point2D QmitkRenderWindow::GetMousePosition(QWheelEvent *we) const
{
mitk::Point2D point;
point[0] = we->x();
// We need to convert the y component, as the display and vtk have other definitions for the y direction
point[1] = m_Renderer->GetSizeY() - we->y();
return point;
}
mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetEventButton(QMouseEvent *me) const
{
mitk::InteractionEvent::MouseButtons eventButton;
switch (me->button())
{
case Qt::LeftButton:
eventButton = mitk::InteractionEvent::LeftMouseButton;
break;
case Qt::RightButton:
eventButton = mitk::InteractionEvent::RightMouseButton;
break;
case Qt::MidButton:
eventButton = mitk::InteractionEvent::MiddleMouseButton;
break;
default:
eventButton = mitk::InteractionEvent::NoButton;
break;
}
return eventButton;
}
mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QMouseEvent *me) const
{
mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
if (me->buttons() & Qt::LeftButton)
{
buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
}
if (me->buttons() & Qt::RightButton)
{
buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
}
if (me->buttons() & Qt::MidButton)
{
buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
}
return buttonState;
}
mitk::InteractionEvent::ModifierKeys QmitkRenderWindow::GetModifiers(QInputEvent *me) const
{
mitk::InteractionEvent::ModifierKeys modifiers = mitk::InteractionEvent::NoKey;
if (me->modifiers() & Qt::ALT)
{
modifiers = modifiers | mitk::InteractionEvent::AltKey;
}
if (me->modifiers() & Qt::CTRL)
{
modifiers = modifiers | mitk::InteractionEvent::ControlKey;
}
if (me->modifiers() & Qt::SHIFT)
{
modifiers = modifiers | mitk::InteractionEvent::ShiftKey;
}
return modifiers;
}
mitk::InteractionEvent::MouseButtons QmitkRenderWindow::GetButtonState(QWheelEvent *we) const
{
mitk::InteractionEvent::MouseButtons buttonState = mitk::InteractionEvent::NoButton;
if (we->buttons() & Qt::LeftButton)
{
buttonState = buttonState | mitk::InteractionEvent::LeftMouseButton;
}
if (we->buttons() & Qt::RightButton)
{
buttonState = buttonState | mitk::InteractionEvent::RightMouseButton;
}
if (we->buttons() & Qt::MidButton)
{
buttonState = buttonState | mitk::InteractionEvent::MiddleMouseButton;
}
return buttonState;
}
std::string QmitkRenderWindow::GetKeyLetter(QKeyEvent *ke) const
{
// Converting Qt Key Event to string element.
std::string key = "";
int tkey = ke->key();
if (tkey < 128)
{ // standard ascii letter
key = (char)toupper(tkey);
}
else
{ // special keys
switch (tkey)
{
case Qt::Key_Return:
key = mitk::InteractionEvent::KeyReturn;
break;
case Qt::Key_Enter:
key = mitk::InteractionEvent::KeyEnter;
break;
case Qt::Key_Escape:
key = mitk::InteractionEvent::KeyEsc;
break;
case Qt::Key_Delete:
key = mitk::InteractionEvent::KeyDelete;
break;
case Qt::Key_Up:
key = mitk::InteractionEvent::KeyArrowUp;
break;
case Qt::Key_Down:
key = mitk::InteractionEvent::KeyArrowDown;
break;
case Qt::Key_Left:
key = mitk::InteractionEvent::KeyArrowLeft;
break;
case Qt::Key_Right:
key = mitk::InteractionEvent::KeyArrowRight;
break;
case Qt::Key_F1:
key = mitk::InteractionEvent::KeyF1;
break;
case Qt::Key_F2:
key = mitk::InteractionEvent::KeyF2;
break;
case Qt::Key_F3:
key = mitk::InteractionEvent::KeyF3;
break;
case Qt::Key_F4:
key = mitk::InteractionEvent::KeyF4;
break;
case Qt::Key_F5:
key = mitk::InteractionEvent::KeyF5;
break;
case Qt::Key_F6:
key = mitk::InteractionEvent::KeyF6;
break;
case Qt::Key_F7:
key = mitk::InteractionEvent::KeyF7;
break;
case Qt::Key_F8:
key = mitk::InteractionEvent::KeyF8;
break;
case Qt::Key_F9:
key = mitk::InteractionEvent::KeyF9;
break;
case Qt::Key_F10:
key = mitk::InteractionEvent::KeyF10;
break;
case Qt::Key_F11:
key = mitk::InteractionEvent::KeyF11;
break;
case Qt::Key_F12:
key = mitk::InteractionEvent::KeyF12;
break;
case Qt::Key_End:
key = mitk::InteractionEvent::KeyEnd;
break;
case Qt::Key_Home:
key = mitk::InteractionEvent::KeyPos1;
break;
case Qt::Key_Insert:
key = mitk::InteractionEvent::KeyInsert;
break;
case Qt::Key_PageDown:
key = mitk::InteractionEvent::KeyPageDown;
break;
case Qt::Key_PageUp:
key = mitk::InteractionEvent::KeyPageUp;
break;
case Qt::Key_Space:
key = mitk::InteractionEvent::KeySpace;
break;
}
}
return key;
}
int QmitkRenderWindow::GetDelta(QWheelEvent *we) const
{
return we->delta();
}
void QmitkRenderWindow::UpdateStatusBar(mitk::Point2D pointerPositionOnScreen)
{
mitk::Point3D worldPosition;
m_Renderer->ForceImmediateUpdate();
m_Renderer->DisplayToWorld(pointerPositionOnScreen, worldPosition);
auto statusBar = mitk::StatusBar::GetInstance();
statusBar->DisplayRendererInfo(worldPosition, m_Renderer->GetTime());
}
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowMenu.cpp b/Modules/QtWidgets/src/QmitkRenderWindowMenu.cpp
index b75f46182c..ece6a28e45 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowMenu.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowMenu.cpp
@@ -1,578 +1,578 @@
/*============================================================================
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 "QmitkRenderWindowMenu.h"
// mitk core
#include "mitkProperties.h"
#include "mitkResliceMethodProperty.h"
// qt
#include <QHBoxLayout>
#include <QPainter>
#include <QSize>
#include <QSpacerItem>
#include <QSlider>
#include <QGroupBox>
#include <QLine>
#include <QRadioButton>
#include <QWidgetAction>
//#include"iconClose.xpm"
#include "iconCrosshairMode.xpm"
#include "iconFullScreen.xpm"
//#include"iconHoriSplit.xpm"
#include "iconSettings.xpm"
//#include"iconVertiSplit.xpm"
#include "iconLeaveFullScreen.xpm"
// c++
#include <cmath>
unsigned int QmitkRenderWindowMenu::m_DefaultThickMode(1);
QmitkRenderWindowMenu::QmitkRenderWindowMenu(QWidget* parent,
Qt::WindowFlags flags,
mitk::BaseRenderer* baseRenderer)
: QWidget(parent, flags)
, m_LayoutActionsMenu(nullptr)
, m_CrosshairMenu(nullptr)
, m_FullScreenMode(false)
, m_Renderer(baseRenderer)
, m_Parent(parent)
, m_CrosshairRotationMode(0)
, m_CrosshairVisibility(true)
- , m_Layout(LayoutIndex::AXIAL)
+ , m_Layout(LayoutIndex::Axial)
, m_LayoutDesign(LayoutDesign::DEFAULT)
, m_OldLayoutDesign(LayoutDesign::DEFAULT)
{
CreateMenuWidget();
setMinimumWidth(61); // DIRTY.. If you add or remove a button, you need to change the size.
setMaximumWidth(61);
setAutoFillBackground(true);
this->hide();
m_AutoRotationTimer = new QTimer(this);
m_AutoRotationTimer->setInterval(75);
connect(m_AutoRotationTimer, &QTimer::timeout, this, &QmitkRenderWindowMenu::AutoRotateNextStep);
connect(m_Parent, &QObject::destroyed, this, &QmitkRenderWindowMenu::deleteLater);
}
QmitkRenderWindowMenu::~QmitkRenderWindowMenu()
{
if (m_AutoRotationTimer->isActive())
{
m_AutoRotationTimer->stop();
}
}
void QmitkRenderWindowMenu::SetLayoutIndex(LayoutIndex layoutIndex)
{
m_Layout = layoutIndex;
}
void QmitkRenderWindowMenu::UpdateLayoutDesignList(LayoutDesign layoutDesign)
{
m_LayoutDesign = layoutDesign;
if (nullptr == m_LayoutActionsMenu)
{
CreateSettingsWidget();
}
m_DefaultLayoutAction->setEnabled(true);
m_All2DTop3DBottomLayoutAction->setEnabled(true);
m_All2DLeft3DRightLayoutAction->setEnabled(true);
m_OneBigLayoutAction->setEnabled(true);
m_Only2DHorizontalLayoutAction->setEnabled(true);
m_Only2DVerticalLayoutAction->setEnabled(true);
m_OneTop3DBottomLayoutAction->setEnabled(true);
m_OneLeft3DRightLayoutAction->setEnabled(true);
m_AllHorizontalLayoutAction->setEnabled(true);
m_AllVerticalLayoutAction->setEnabled(true);
m_RemoveOneLayoutAction->setEnabled(true);
switch (m_LayoutDesign)
{
case LayoutDesign::DEFAULT:
{
m_DefaultLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ALL_2D_TOP_3D_BOTTOM:
{
m_All2DTop3DBottomLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ALL_2D_LEFT_3D_RIGHT:
{
m_All2DLeft3DRightLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ONE_BIG:
{
m_OneBigLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ONLY_2D_HORIZONTAL:
{
m_Only2DHorizontalLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ONLY_2D_VERTICAL:
{
m_Only2DVerticalLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ONE_TOP_3D_BOTTOM:
{
m_OneTop3DBottomLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ONE_LEFT_3D_RIGHT:
{
m_OneLeft3DRightLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ALL_HORIZONTAL:
{
m_AllHorizontalLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::ALL_VERTICAL:
{
m_AllVerticalLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::REMOVE_ONE:
{
m_RemoveOneLayoutAction->setEnabled(false);
break;
}
case LayoutDesign::NONE:
{
break;
}
}
}
void QmitkRenderWindowMenu::UpdateCrosshairVisibility(bool visible)
{
m_CrosshairVisibility = visible;
}
void QmitkRenderWindowMenu::UpdateCrosshairRotationMode(int mode)
{
m_CrosshairRotationMode = mode;
}
void QmitkRenderWindowMenu::MoveWidgetToCorrectPos()
{
int moveX = floor(static_cast<double>(this->m_Parent->width()) - static_cast<double>(this->width()) - 4.0);
this->move(moveX, 3);
auto cursorPos = this->mapFromGlobal(QCursor::pos());
if (cursorPos.x() < 0 || cursorPos.x() >= this->width() ||
cursorPos.y() < 0 || cursorPos.y() >= this->height())
{
this->HideMenu();
}
else
{
this->ShowMenu();
}
}
void QmitkRenderWindowMenu::ShowMenu()
{
MITK_DEBUG << "menu showMenu";
this->show();
this->raise();
}
void QmitkRenderWindowMenu::HideMenu()
{
MITK_DEBUG << "menu hideEvent";
this->hide();
}
void QmitkRenderWindowMenu::paintEvent(QPaintEvent * /*e*/)
{
QPainter painter(this);
QColor semiTransparentColor = Qt::black;
semiTransparentColor.setAlpha(255);
painter.fillRect(rect(), semiTransparentColor);
}
void QmitkRenderWindowMenu::CreateMenuWidget()
{
QHBoxLayout *layout = new QHBoxLayout(this);
layout->setAlignment(Qt::AlignRight);
layout->setContentsMargins(1, 1, 1, 1);
QSize size(13, 13);
m_CrosshairMenu = new QMenu(this);
connect(m_CrosshairMenu, &QMenu::aboutToShow, this, &QmitkRenderWindowMenu::OnCrosshairMenuAboutToShow);
m_CrosshairModeButton = new QToolButton(this);
m_CrosshairModeButton->setMaximumSize(15, 15);
m_CrosshairModeButton->setIconSize(size);
m_CrosshairModeButton->setMenu(m_CrosshairMenu);
m_CrosshairModeButton->setIcon(QIcon(QPixmap(iconCrosshairMode_xpm)));
m_CrosshairModeButton->setPopupMode(QToolButton::InstantPopup);
m_CrosshairModeButton->setStyleSheet("QToolButton::menu-indicator { image: none; }");
m_CrosshairModeButton->setAutoRaise(true);
layout->addWidget(m_CrosshairModeButton);
m_FullScreenButton = new QToolButton(this);
m_FullScreenButton->setMaximumSize(15, 15);
m_FullScreenButton->setIconSize(size);
m_FullScreenButton->setIcon(QIcon(QPixmap(iconFullScreen_xpm)));
m_FullScreenButton->setAutoRaise(true);
layout->addWidget(m_FullScreenButton);
m_LayoutDesignButton = new QToolButton(this);
m_LayoutDesignButton->setMaximumSize(15, 15);
m_LayoutDesignButton->setIconSize(size);
m_LayoutDesignButton->setIcon(QIcon(QPixmap(iconSettings_xpm)));
m_LayoutDesignButton->setAutoRaise(true);
layout->addWidget(m_LayoutDesignButton);
connect(m_FullScreenButton, &QToolButton::clicked, this, &QmitkRenderWindowMenu::OnFullScreenButton);
connect(m_LayoutDesignButton, &QToolButton::clicked, this, &QmitkRenderWindowMenu::OnLayoutDesignButton);
}
void QmitkRenderWindowMenu::CreateSettingsWidget()
{
m_LayoutActionsMenu = new QMenu(this);
m_DefaultLayoutAction = new QAction("Standard layout", m_LayoutActionsMenu);
m_DefaultLayoutAction->setDisabled(true);
m_All2DTop3DBottomLayoutAction = new QAction("All 2D top, 3D bottom", m_LayoutActionsMenu);
m_All2DTop3DBottomLayoutAction->setDisabled(false);
m_All2DLeft3DRightLayoutAction = new QAction("All 2D left, 3D right", m_LayoutActionsMenu);
m_All2DLeft3DRightLayoutAction->setDisabled(false);
m_OneBigLayoutAction = new QAction("This big", m_LayoutActionsMenu);
m_OneBigLayoutAction->setDisabled(false);
m_Only2DHorizontalLayoutAction = new QAction("Only 2D horizontal", m_LayoutActionsMenu);
m_Only2DHorizontalLayoutAction->setDisabled(false);
m_Only2DVerticalLayoutAction = new QAction("Only 2D vertical", m_LayoutActionsMenu);
m_Only2DVerticalLayoutAction->setDisabled(false);
m_OneTop3DBottomLayoutAction = new QAction("This top, 3D bottom", m_LayoutActionsMenu);
m_OneTop3DBottomLayoutAction->setDisabled(false);
m_OneLeft3DRightLayoutAction = new QAction("This left, 3D right", m_LayoutActionsMenu);
m_OneLeft3DRightLayoutAction->setDisabled(false);
m_AllHorizontalLayoutAction = new QAction("All horizontal", m_LayoutActionsMenu);
m_AllHorizontalLayoutAction->setDisabled(false);
m_AllVerticalLayoutAction = new QAction("All vertical", m_LayoutActionsMenu);
m_AllVerticalLayoutAction->setDisabled(false);
m_RemoveOneLayoutAction = new QAction("Remove this", m_LayoutActionsMenu);
m_RemoveOneLayoutAction->setDisabled(false);
m_LayoutActionsMenu->addAction(m_DefaultLayoutAction);
m_LayoutActionsMenu->addAction(m_All2DTop3DBottomLayoutAction);
m_LayoutActionsMenu->addAction(m_All2DLeft3DRightLayoutAction);
m_LayoutActionsMenu->addAction(m_OneBigLayoutAction);
m_LayoutActionsMenu->addAction(m_Only2DHorizontalLayoutAction);
m_LayoutActionsMenu->addAction(m_Only2DVerticalLayoutAction);
m_LayoutActionsMenu->addAction(m_OneTop3DBottomLayoutAction);
m_LayoutActionsMenu->addAction(m_OneLeft3DRightLayoutAction);
m_LayoutActionsMenu->addAction(m_AllHorizontalLayoutAction);
m_LayoutActionsMenu->addAction(m_AllVerticalLayoutAction);
m_LayoutActionsMenu->addAction(m_RemoveOneLayoutAction);
m_LayoutActionsMenu->setVisible(false);
connect(m_DefaultLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::DEFAULT); });
connect(m_All2DTop3DBottomLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ALL_2D_TOP_3D_BOTTOM); });
connect(m_All2DLeft3DRightLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ALL_2D_LEFT_3D_RIGHT); });
connect(m_OneBigLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONE_BIG); });
connect(m_Only2DHorizontalLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONLY_2D_HORIZONTAL); });
connect(m_Only2DVerticalLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONLY_2D_VERTICAL); });
connect(m_OneTop3DBottomLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONE_TOP_3D_BOTTOM); });
connect(m_OneLeft3DRightLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ONE_LEFT_3D_RIGHT); });
connect(m_AllHorizontalLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ALL_HORIZONTAL); });
connect(m_AllVerticalLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::ALL_VERTICAL); });
connect(m_RemoveOneLayoutAction, &QAction::triggered, [this]() { this->OnSetLayout(LayoutDesign::REMOVE_ONE); });
}
void QmitkRenderWindowMenu::ChangeFullScreenIcon()
{
m_FullScreenButton->setIcon(m_FullScreenMode ? QPixmap(iconLeaveFullScreen_xpm) : QPixmap(iconFullScreen_xpm));
}
void QmitkRenderWindowMenu::AutoRotateNextStep()
{
if (m_Renderer->GetCameraRotationController())
{
m_Renderer->GetCameraRotationController()->GetSlice()->Next();
}
}
void QmitkRenderWindowMenu::OnAutoRotationActionTriggered()
{
if (m_AutoRotationTimer->isActive())
{
m_AutoRotationTimer->stop();
m_Renderer->GetCameraRotationController()->GetSlice()->PingPongOff();
}
else
{
m_Renderer->GetCameraRotationController()->GetSlice()->PingPongOn();
m_AutoRotationTimer->start();
}
}
void QmitkRenderWindowMenu::OnTSNumChanged(int num)
{
MITK_DEBUG << "Thickslices num: " << num << " on renderer " << m_Renderer.GetPointer();
if (m_Renderer.IsNotNull())
{
unsigned int thickSlicesMode = 0;
// determine the state of the thick-slice mode
mitk::ResliceMethodProperty *resliceMethodEnumProperty = nullptr;
if(m_Renderer->GetCurrentWorldPlaneGeometryNode()->GetProperty(resliceMethodEnumProperty, "reslice.thickslices") && resliceMethodEnumProperty)
{
thickSlicesMode = resliceMethodEnumProperty->GetValueAsId();
if(thickSlicesMode!=0)
m_DefaultThickMode = thickSlicesMode;
}
if(thickSlicesMode==0 && num>0) //default mode only for single slices
{
thickSlicesMode = m_DefaultThickMode; //mip default
m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty("reslice.thickslices.showarea",
mitk::BoolProperty::New(true));
}
if(num<1)
{
thickSlicesMode = 0;
m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty("reslice.thickslices.showarea",
mitk::BoolProperty::New(false));
}
m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty("reslice.thickslices",
mitk::ResliceMethodProperty::New(thickSlicesMode));
m_Renderer->GetCurrentWorldPlaneGeometryNode()->SetProperty("reslice.thickslices.num",
mitk::IntProperty::New(num));
m_TSLabel->setText(QString::number(num * 2 + 1));
m_Renderer->SendUpdateSlice();
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void QmitkRenderWindowMenu::OnCrosshairMenuAboutToShow()
{
QMenu *crosshairModesMenu = m_CrosshairMenu;
crosshairModesMenu->clear();
QAction *resetViewAction = new QAction(crosshairModesMenu);
resetViewAction->setText("Reset view");
crosshairModesMenu->addAction(resetViewAction);
connect(resetViewAction, &QAction::triggered, this, &QmitkRenderWindowMenu::ResetView);
// Show hide crosshairs
{
QAction *showHideCrosshairVisibilityAction = new QAction(crosshairModesMenu);
showHideCrosshairVisibilityAction->setText("Show crosshair");
showHideCrosshairVisibilityAction->setCheckable(true);
showHideCrosshairVisibilityAction->setChecked(m_CrosshairVisibility);
crosshairModesMenu->addAction(showHideCrosshairVisibilityAction);
connect(showHideCrosshairVisibilityAction, &QAction::toggled, this, &QmitkRenderWindowMenu::OnCrosshairVisibilityChanged);
}
// Rotation mode
{
QAction *rotationGroupSeparator = new QAction(crosshairModesMenu);
rotationGroupSeparator->setSeparator(true);
rotationGroupSeparator->setText("Rotation mode");
crosshairModesMenu->addAction(rotationGroupSeparator);
QActionGroup *rotationModeActionGroup = new QActionGroup(crosshairModesMenu);
rotationModeActionGroup->setExclusive(true);
QAction *noCrosshairRotation = new QAction(crosshairModesMenu);
noCrosshairRotation->setActionGroup(rotationModeActionGroup);
noCrosshairRotation->setText("No crosshair rotation");
noCrosshairRotation->setCheckable(true);
noCrosshairRotation->setChecked(m_CrosshairRotationMode == 0);
noCrosshairRotation->setData(0);
crosshairModesMenu->addAction(noCrosshairRotation);
QAction *singleCrosshairRotation = new QAction(crosshairModesMenu);
singleCrosshairRotation->setActionGroup(rotationModeActionGroup);
singleCrosshairRotation->setText("Crosshair rotation");
singleCrosshairRotation->setCheckable(true);
singleCrosshairRotation->setChecked(m_CrosshairRotationMode == 1);
singleCrosshairRotation->setData(1);
crosshairModesMenu->addAction(singleCrosshairRotation);
QAction *coupledCrosshairRotation = new QAction(crosshairModesMenu);
coupledCrosshairRotation->setActionGroup(rotationModeActionGroup);
coupledCrosshairRotation->setText("Coupled crosshair rotation");
coupledCrosshairRotation->setCheckable(true);
coupledCrosshairRotation->setChecked(m_CrosshairRotationMode == 2);
coupledCrosshairRotation->setData(2);
crosshairModesMenu->addAction(coupledCrosshairRotation);
QAction *swivelMode = new QAction(crosshairModesMenu);
swivelMode->setActionGroup(rotationModeActionGroup);
swivelMode->setText("Swivel mode");
swivelMode->setCheckable(true);
swivelMode->setChecked(m_CrosshairRotationMode == 3);
swivelMode->setData(3);
crosshairModesMenu->addAction(swivelMode);
connect(rotationModeActionGroup, &QActionGroup::triggered, this, &QmitkRenderWindowMenu::OnCrosshairRotationModeSelected);
}
// auto rotation support
if (m_Renderer.IsNotNull() && m_Renderer->GetMapperID() == mitk::BaseRenderer::Standard3D)
{
QAction *autoRotationGroupSeparator = new QAction(crosshairModesMenu);
autoRotationGroupSeparator->setSeparator(true);
crosshairModesMenu->addAction(autoRotationGroupSeparator);
QAction *autoRotationAction = crosshairModesMenu->addAction("Auto Rotation");
autoRotationAction->setCheckable(true);
autoRotationAction->setChecked(m_AutoRotationTimer->isActive());
connect(autoRotationAction, &QAction::triggered, this, &QmitkRenderWindowMenu::OnAutoRotationActionTriggered);
}
// Thickslices support
if (m_Renderer.IsNotNull() && m_Renderer->GetMapperID() == mitk::BaseRenderer::Standard2D)
{
QAction *thickSlicesGroupSeparator = new QAction(crosshairModesMenu);
thickSlicesGroupSeparator->setSeparator(true);
thickSlicesGroupSeparator->setText("ThickSlices mode");
crosshairModesMenu->addAction(thickSlicesGroupSeparator);
QActionGroup *thickSlicesActionGroup = new QActionGroup(crosshairModesMenu);
thickSlicesActionGroup->setExclusive(true);
int currentMode = 0;
{
mitk::ResliceMethodProperty::Pointer m = dynamic_cast<mitk::ResliceMethodProperty *>(
m_Renderer->GetCurrentWorldPlaneGeometryNode()->GetProperty("reslice.thickslices"));
if (m.IsNotNull())
currentMode = m->GetValueAsId();
}
int currentNum = 1;
{
mitk::IntProperty::Pointer m = dynamic_cast<mitk::IntProperty *>(
m_Renderer->GetCurrentWorldPlaneGeometryNode()->GetProperty("reslice.thickslices.num"));
if (m.IsNotNull())
{
currentNum = m->GetValue();
}
}
if (currentMode == 0)
currentNum = 0;
QSlider *m_TSSlider = new QSlider(crosshairModesMenu);
m_TSSlider->setMinimum(0);
m_TSSlider->setMaximum(50);
m_TSSlider->setValue(currentNum);
m_TSSlider->setOrientation(Qt::Horizontal);
connect(m_TSSlider, &QSlider::valueChanged, this, &QmitkRenderWindowMenu::OnTSNumChanged);
QHBoxLayout *tsLayout = new QHBoxLayout;
tsLayout->setContentsMargins(4, 4, 4, 4);
tsLayout->addWidget(new QLabel("TS: "));
tsLayout->addWidget(m_TSSlider);
tsLayout->addWidget(m_TSLabel = new QLabel(QString::number(currentNum * 2 + 1), this));
QWidget *tsWidget = new QWidget;
tsWidget->setLayout(tsLayout);
QWidgetAction *m_TSSliderAction = new QWidgetAction(crosshairModesMenu);
m_TSSliderAction->setDefaultWidget(tsWidget);
crosshairModesMenu->addAction(m_TSSliderAction);
}
}
void QmitkRenderWindowMenu::OnCrosshairVisibilityChanged(bool visible)
{
UpdateCrosshairVisibility(visible);
emit CrosshairVisibilityChanged(m_CrosshairVisibility);
}
void QmitkRenderWindowMenu::OnCrosshairRotationModeSelected(QAction *action)
{
UpdateCrosshairRotationMode(action->data().toInt());
emit CrosshairRotationModeChanged(m_CrosshairRotationMode);
}
void QmitkRenderWindowMenu::OnFullScreenButton(bool /*checked*/)
{
if (!m_FullScreenMode)
{
m_FullScreenMode = true;
m_OldLayoutDesign = m_LayoutDesign;
emit LayoutDesignChanged(LayoutDesign::ONE_BIG);
}
else
{
m_FullScreenMode = false;
emit LayoutDesignChanged(m_OldLayoutDesign);
}
MoveWidgetToCorrectPos();
ChangeFullScreenIcon();
ShowMenu();
}
void QmitkRenderWindowMenu::OnLayoutDesignButton(bool /*checked*/)
{
if (nullptr == m_LayoutActionsMenu)
{
CreateSettingsWidget();
}
QPoint point = mapToGlobal(m_LayoutDesignButton->geometry().topLeft());
m_LayoutActionsMenu->setVisible(true);
m_LayoutActionsMenu->exec(point);
}
void QmitkRenderWindowMenu::OnSetLayout(LayoutDesign layoutDesign)
{
m_FullScreenMode = false;
ChangeFullScreenIcon();
m_LayoutDesign = layoutDesign;
emit LayoutDesignChanged(m_LayoutDesign);
ShowMenu();
}
diff --git a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
index 11585a05e9..9679e85137 100644
--- a/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkRenderWindowWidget.cpp
@@ -1,424 +1,424 @@
/*============================================================================
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 <mitkImage.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
// itk
#include <itkSpatialOrientationAdapter.h>
// vtk
#include <vtkCornerAnnotation.h>
#include <vtkTextProperty.h>
QmitkRenderWindowWidget::QmitkRenderWindowWidget(QWidget* parent/* = nullptr*/,
const QString& widgetName/* = ""*/,
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 = this->GetSliceNavigationController();
if (nullptr != sliceNavigationController)
{
sliceNavigationController->SetCrosshairEvent.RemoveListener(
mitk::MessageDelegate1<QmitkRenderWindowWidget, const mitk::Point3D &>(
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 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);
+ m_RenderWindow->SetLayoutIndex(mitk::AnatomicalPlane::Sagittal);
auto sliceNavigationController = this->GetSliceNavigationController();
sliceNavigationController->SetDefaultViewDirection(mitk::AnatomicalPlane::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<QmitkRenderWindowWidget, const mitk::Point3D &>(
this, &QmitkRenderWindowWidget::SetCrosshairPosition));
// finally add observer, after all relevant objects have been created / initialized
sliceNavigationController->ConnectGeometrySendEvent(this);
sliceNavigationController->ConnectGeometrySliceEvent(this);
mitk::TimeGeometry::ConstPointer timeGeometry = m_DataStorage->ComputeBoundingGeometry3D(m_DataStorage->GetAll());
mitk::RenderingManager::GetInstance()->InitializeView(m_RenderWindow->GetVtkRenderWindow(), timeGeometry);
}
void QmitkRenderWindowWidget::InitializeDecorations()
{
vtkRenderer* vtkRenderer = m_RenderWindow->GetRenderer()->GetVtkRenderer();
if (nullptr == vtkRenderer)
{
return;
}
// initialize background color gradients
float black[3] = { 0.0f, 0.0f, 0.0f };
SetGradientBackgroundColors(black, black);
// initialize annotation text and decoration color
setFrameStyle(QFrame::Box | QFrame::Plain);
m_CornerAnnotation = vtkSmartPointer<vtkCornerAnnotation>::New();
m_CornerAnnotation->SetText(0, "Sagittal");
m_CornerAnnotation->SetMaximumFontSize(12);
if (0 == vtkRenderer->HasViewProp(m_CornerAnnotation))
{
vtkRenderer->AddViewProp(m_CornerAnnotation);
}
float white[3] = { 1.0f, 1.0f, 1.0f };
SetDecorationColor(mitk::Color(white));
}
void QmitkRenderWindowWidget::SetCrosshairPosition(const mitk::Point3D& newPosition)
{
m_CrosshairManager->SetCrosshairPosition(newPosition);
this->RequestUpdate();
}
mitk::Point3D QmitkRenderWindowWidget::GetCrosshairPosition() const
{
return m_CrosshairManager->GetCrosshairPosition();
}
void QmitkRenderWindowWidget::SetGeometry(const itk::EventObject& event)
{
if (!mitk::SliceNavigationController::GeometrySendEvent(nullptr, 0).CheckEvent(&event))
{
return;
}
auto sliceNavigationController = this->GetSliceNavigationController();
const auto* inputTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry();
m_CrosshairManager->ComputeOrientedTimeGeometries(inputTimeGeometry);
if (m_WindowControls)
{
this->ComputeInvertedSliceNavigation();
}
}
void QmitkRenderWindowWidget::SetGeometrySlice(const itk::EventObject& event)
{
if (!mitk::SliceNavigationController::GeometrySliceEvent(nullptr, 0).CheckEvent(&event))
{
return;
}
auto sliceNavigationController = this->GetSliceNavigationController();
m_CrosshairManager->UpdateSlice(sliceNavigationController);
}
void QmitkRenderWindowWidget::ComputeInvertedSliceNavigation()
{
auto sliceNavigationController = this->GetSliceNavigationController();
auto viewDirection = sliceNavigationController->GetViewDirection();
unsigned int axis = 0;
switch (viewDirection)
{
case mitk::AnatomicalPlane::Original:
return;
case mitk::AnatomicalPlane::Axial:
{
axis = 2;
break;
}
case mitk::AnatomicalPlane::Coronal:
{
axis = 1;
break;
}
case mitk::AnatomicalPlane::Sagittal:
{
axis = 0;
break;
}
}
const auto* inputTimeGeometry = sliceNavigationController->GetInputWorldTimeGeometry();
const mitk::BaseGeometry* rendererGeometry = m_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<mitk::DataNode::Pointer> 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<mitk::Image*>(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<mitk::DataNode::Pointer> selectedNodes)
{
if (selectedNodes.empty())
{
return;
}
auto selectedImage = dynamic_cast<mitk::Image*>(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->GetSliceNavigationController()->SelectSliceByPoint(currentPosition);
renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
}
diff --git a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
index dee10d29de..3a82a7778e 100644
--- a/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkStdMultiWidget.cpp
@@ -1,737 +1,737 @@
/*============================================================================
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.
============================================================================*/
#define SMW_INFO MITK_INFO("widget.stdmulti")
#include "QmitkStdMultiWidget.h"
#include "QmitkRenderWindowWidget.h"
// mitk core
#include <mitkCameraController.h>
#include <mitkImage.h>
#include <mitkImagePixelReadAccessor.h>
#include <mitkInteractionConst.h>
#include <mitkLine.h>
#include <mitkNodePredicateBase.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateProperty.h>
#include <mitkPixelTypeMultiplex.h>
#include <mitkPlaneGeometryDataMapper2D.h>
#include <mitkPointSet.h>
#include <mitkProperties.h>
#include <mitkStatusBar.h>
#include <mitkDisplayActionEventHandlerStd.h>
#include <mitkVtkLayerController.h>
// qt
#include <QList>
#include <QMouseEvent>
#include <QTimer>
// vtk
#include <vtkSmartPointer.h>
// c++
#include <iomanip>
QmitkStdMultiWidget::QmitkStdMultiWidget(QWidget *parent,
Qt::WindowFlags f/* = 0*/,
const QString &name/* = "stdmulti"*/)
: QmitkAbstractMultiWidget(parent, f, name)
, m_TimeNavigationController(nullptr)
{
m_TimeNavigationController = mitk::RenderingManager::GetInstance()->GetTimeNavigationController();
}
QmitkStdMultiWidget::~QmitkStdMultiWidget()
{
auto allRenderWindows = this->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
m_TimeNavigationController->Disconnect(renderWindow->GetSliceNavigationController());
}
}
void QmitkStdMultiWidget::InitializeMultiWidget()
{
// yellow is default color for widget4
m_DecorationColorWidget4[0] = 1.0f;
m_DecorationColorWidget4[1] = 1.0f;
m_DecorationColorWidget4[2] = 0.0f;
SetLayout(2, 2);
// transfer colors in WorldGeometry-Nodes of the associated Renderer
// of widget 1
m_PlaneNode1 =
mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode1->SetColor(GetDecorationColor(0));
// of widget 2
m_PlaneNode2 =
mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode2->SetColor(GetDecorationColor(1));
// of widget 3
m_PlaneNode3 =
mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode3->SetColor(GetDecorationColor(2));
// the parent node
m_ParentNodeForGeometryPlanes =
mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCurrentWorldPlaneGeometryNode();
AddDisplayPlaneSubTree();
SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerStd>());
auto displayActionEventHandler = GetDisplayActionEventHandler();
if (nullptr != displayActionEventHandler)
{
displayActionEventHandler->InitActions();
}
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const QString& widgetName) const
{
if ("axial" == widgetName)
{
return GetRenderWindow1();
}
if ("sagittal" == widgetName)
{
return GetRenderWindow2();
}
if ("coronal" == widgetName)
{
return GetRenderWindow3();
}
if ("3d" == widgetName)
{
return GetRenderWindow4();
}
return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
}
-QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
+QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(const mitk::AnatomicalPlane& orientation) const
{
- return GetRenderWindow(static_cast<unsigned int>(viewDirection));
+ return GetRenderWindow(static_cast<unsigned int>(orientation));
}
void QmitkStdMultiWidget::SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera)
{
auto* renderingManager = mitk::RenderingManager::GetInstance();
mitk::Point3D currentPosition = mitk::Point3D();
unsigned int imageTimeStep = 0;
if (!resetCamera)
{
// store the current position to set it again later, if the camera should not be reset
currentPosition = this->GetSelectedPosition("");
// store the current time step to set it again later, if the camera should not be reset
const auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
if (referenceGeometry->IsValidTimePoint(currentTimePoint))
{
imageTimeStep = referenceGeometry->TimePointToTimeStep(currentTimePoint);
}
}
// initialize render windows
renderingManager->InitializeViews(referenceGeometry, mitk::RenderingManager::REQUEST_UPDATE_ALL, resetCamera);
if (!resetCamera)
{
this->SetSelectedPosition(currentPosition, "");
renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
}
}
bool QmitkStdMultiWidget::HasCoupledRenderWindows() const
{
return true;
}
void QmitkStdMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& /*widgetName*/)
{
GetRenderWindow1()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
GetRenderWindow2()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
GetRenderWindow3()->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
RequestUpdateAll();
}
const mitk::Point3D QmitkStdMultiWidget::GetSelectedPosition(const QString& /*widgetName*/) const
{
const mitk::PlaneGeometry* plane1 = GetRenderWindow1()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry* plane2 = GetRenderWindow2()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
const mitk::PlaneGeometry* plane3 = GetRenderWindow3()->GetSliceNavigationController()->GetCurrentPlaneGeometry();
mitk::Line3D line;
if ((plane1 != nullptr) && (plane2 != nullptr)
&& (plane1->IntersectionLine(plane2, line)))
{
mitk::Point3D point;
if ((plane3 != nullptr) && (plane3->IntersectionPoint(line, point)))
{
return point;
}
}
return mitk::Point3D();
}
void QmitkStdMultiWidget::SetCrosshairVisibility(bool visible)
{
if (m_PlaneNode1.IsNotNull())
{
m_PlaneNode1->SetVisibility(visible);
}
if (m_PlaneNode2.IsNotNull())
{
m_PlaneNode2->SetVisibility(visible);
}
if (m_PlaneNode3.IsNotNull())
{
m_PlaneNode3->SetVisibility(visible);
}
emit NotifyCrosshairVisibilityChanged(visible);
RequestUpdateAll();
}
bool QmitkStdMultiWidget::GetCrosshairVisibility() const
{
bool crosshairVisibility = true;
if (m_PlaneNode1.IsNotNull())
{
bool visibilityProperty = false;
m_PlaneNode1->GetVisibility(visibilityProperty, nullptr);
crosshairVisibility &= visibilityProperty;
}
if (m_PlaneNode2.IsNotNull())
{
bool visibilityProperty = false;
crosshairVisibility &= m_PlaneNode2->GetVisibility(visibilityProperty, nullptr);
crosshairVisibility &= visibilityProperty;
}
if (m_PlaneNode3.IsNotNull())
{
bool visibilityProperty = false;
crosshairVisibility &= m_PlaneNode3->GetVisibility(visibilityProperty, nullptr);
crosshairVisibility &= visibilityProperty;
}
return crosshairVisibility;
}
void QmitkStdMultiWidget::SetCrosshairGap(unsigned int gapSize)
{
m_PlaneNode1->SetIntProperty("Crosshair.Gap Size", gapSize);
m_PlaneNode2->SetIntProperty("Crosshair.Gap Size", gapSize);
m_PlaneNode3->SetIntProperty("Crosshair.Gap Size", gapSize);
}
void QmitkStdMultiWidget::ResetCrosshair()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(dataStorage);
SetWidgetPlaneMode(mitk::InteractionSchemeSwitcher::MITKStandard);
}
void QmitkStdMultiWidget::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;
}
emit NotifyCrosshairRotationModeChanged(userMode);
}
mitk::SliceNavigationController* QmitkStdMultiWidget::GetTimeNavigationController()
{
return m_TimeNavigationController;
}
void QmitkStdMultiWidget::AddPlanesToDataStorage()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
&& m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
{
dataStorage->Add(m_ParentNodeForGeometryPlanes);
dataStorage->Add(m_PlaneNode1, m_ParentNodeForGeometryPlanes);
dataStorage->Add(m_PlaneNode2, m_ParentNodeForGeometryPlanes);
dataStorage->Add(m_PlaneNode3, m_ParentNodeForGeometryPlanes);
}
}
void QmitkStdMultiWidget::RemovePlanesFromDataStorage()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
if (m_PlaneNode1.IsNotNull() && m_PlaneNode2.IsNotNull()
&& m_PlaneNode3.IsNotNull() && m_ParentNodeForGeometryPlanes.IsNotNull())
{
dataStorage->Remove(m_PlaneNode1);
dataStorage->Remove(m_PlaneNode2);
dataStorage->Remove(m_PlaneNode3);
dataStorage->Remove(m_ParentNodeForGeometryPlanes);
}
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow(unsigned int number) const
{
switch (number)
{
case 0:
return GetRenderWindow1();
case 1:
return GetRenderWindow2();
case 2:
return GetRenderWindow3();
case 3:
return GetRenderWindow4();
default:
MITK_ERROR << "Requested unknown render window";
break;
}
return nullptr;
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow1() const
{
return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 0));
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow2() const
{
return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(0, 1));
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow3() const
{
return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 0));
}
QmitkRenderWindow* QmitkStdMultiWidget::GetRenderWindow4() const
{
return QmitkAbstractMultiWidget::GetRenderWindow(GetNameFromIndex(1, 1));
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane1() const
{
return m_PlaneNode1;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane2() const
{
return m_PlaneNode2;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane3() const
{
return m_PlaneNode3;
}
mitk::DataNode::Pointer QmitkStdMultiWidget::GetWidgetPlane(unsigned number) const
{
switch (number)
{
case 1:
return m_PlaneNode1;
case 2:
return m_PlaneNode2;
case 3:
return m_PlaneNode3;
default:
MITK_ERROR << "Requested unknown render window";
break;
}
return nullptr;
}
void QmitkStdMultiWidget::SetDecorationColor(unsigned int widgetNumber, mitk::Color color)
{
switch (widgetNumber)
{
case 0:
if (m_PlaneNode1.IsNotNull())
{
m_PlaneNode1->SetColor(color);
}
break;
case 1:
if (m_PlaneNode2.IsNotNull())
{
m_PlaneNode2->SetColor(color);
}
break;
case 2:
if (m_PlaneNode3.IsNotNull())
{
m_PlaneNode3->SetColor(color);
}
break;
case 3:
m_DecorationColorWidget4 = color;
break;
default:
MITK_ERROR << "Decoration color for unknown widget!";
break;
}
}
mitk::Color QmitkStdMultiWidget::GetDecorationColor(unsigned int widgetNumber)
{
// The implementation looks a bit messy here, but it avoids
// synchronization of the color of the geometry nodes and an
// internal member here.
// Default colors were chosen for decent visibility.
// Feel free to change your preferences in the workbench.
float tmp[3] = { 0.0f, 0.0f, 0.0f };
switch (widgetNumber)
{
case 0:
{
if (m_PlaneNode1.IsNotNull())
{
if (m_PlaneNode1->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode1->GetProperty("color"))->GetColor();
}
}
float red[3] = { 0.753f, 0.0f, 0.0f }; // This is #C00000 in hex
return mitk::Color(red);
}
case 1:
{
if (m_PlaneNode2.IsNotNull())
{
if (m_PlaneNode2->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode2->GetProperty("color"))->GetColor();
}
}
float green[3] = { 0.0f, 0.69f, 0.0f }; // This is #00B000 in hex
return mitk::Color(green);
}
case 2:
{
if (m_PlaneNode3.IsNotNull())
{
if (m_PlaneNode3->GetColor(tmp))
{
return dynamic_cast<mitk::ColorProperty *>(m_PlaneNode3->GetProperty("color"))->GetColor();
}
}
float blue[3] = { 0.0, 0.502f, 1.0f }; // This is #0080FF in hex
return mitk::Color(blue);
}
case 3:
{
return m_DecorationColorWidget4;
}
default:
MITK_ERROR << "Decoration color for unknown widget!";
float black[3] = { 0.0f, 0.0f, 0.0f };
return mitk::Color(black);
}
}
void QmitkStdMultiWidget::mousePressEvent(QMouseEvent*)
{
// nothing here, but necessary for mouse interactions (.xml-configuration files)
}
void QmitkStdMultiWidget::moveEvent(QMoveEvent* e)
{
QWidget::moveEvent(e);
// it is necessary to readjust the position of the Annotation as the StdMultiWidget has moved
// unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
emit Moved();
}
void QmitkStdMultiWidget::wheelEvent(QWheelEvent* e)
{
emit WheelMoved(e);
}
void QmitkStdMultiWidget::Fit()
{
vtkSmartPointer<vtkRenderer> vtkrenderer;
vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetVtkRenderer();
if (nullptr != vtkrenderer)
{
vtkrenderer->ResetCamera();
}
vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetVtkRenderer();
if (nullptr != vtkrenderer)
{
vtkrenderer->ResetCamera();
}
vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetVtkRenderer();
if (nullptr != vtkrenderer)
{
vtkrenderer->ResetCamera();
}
vtkrenderer = mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetVtkRenderer();
if (nullptr != vtkrenderer)
{
vtkrenderer->ResetCamera();
}
mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow())->GetCameraController()->Fit();
mitk::BaseRenderer::GetInstance(GetRenderWindow4()->renderWindow())->GetCameraController()->Fit();
int w = vtkObject::GetGlobalWarningDisplay();
vtkObject::GlobalWarningDisplayOff();
vtkObject::SetGlobalWarningDisplay(w);
}
void QmitkStdMultiWidget::AddDisplayPlaneSubTree()
{
// add the displayed planes of the multiwidget to a node to which the subtree
// @a planesSubTree points ...
mitk::PlaneGeometryDataMapper2D::Pointer mapper;
// ... of widget 1
mitk::BaseRenderer* renderer1 = mitk::BaseRenderer::GetInstance(GetRenderWindow1()->renderWindow());
m_PlaneNode1 = renderer1->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode1->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode1->SetProperty("name", mitk::StringProperty::New(std::string(renderer1->GetName()) + ".plane"));
m_PlaneNode1->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode1->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode1->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 2
mitk::BaseRenderer* renderer2 = mitk::BaseRenderer::GetInstance(GetRenderWindow2()->renderWindow());
m_PlaneNode2 = renderer2->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode2->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode2->SetProperty("name", mitk::StringProperty::New(std::string(renderer2->GetName()) + ".plane"));
m_PlaneNode2->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode2->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode2->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
// ... of widget 3
mitk::BaseRenderer *renderer3 = mitk::BaseRenderer::GetInstance(GetRenderWindow3()->renderWindow());
m_PlaneNode3 = renderer3->GetCurrentWorldPlaneGeometryNode();
m_PlaneNode3->SetProperty("visible", mitk::BoolProperty::New(true));
m_PlaneNode3->SetProperty("name", mitk::StringProperty::New(std::string(renderer3->GetName()) + ".plane"));
m_PlaneNode3->SetProperty("includeInBoundingBox", mitk::BoolProperty::New(false));
m_PlaneNode3->SetProperty("helper object", mitk::BoolProperty::New(true));
mapper = mitk::PlaneGeometryDataMapper2D::New();
m_PlaneNode3->SetMapper(mitk::BaseRenderer::Standard2D, mapper);
m_ParentNodeForGeometryPlanes = mitk::DataNode::New();
m_ParentNodeForGeometryPlanes->SetProperty("name", mitk::StringProperty::New("Widgets"));
m_ParentNodeForGeometryPlanes->SetProperty("helper object", mitk::BoolProperty::New(true));
}
void QmitkStdMultiWidget::EnsureDisplayContainsPoint(mitk::BaseRenderer *renderer, const mitk::Point3D &p)
{
mitk::Point2D pointOnDisplay;
renderer->WorldToDisplay(p, pointOnDisplay);
if (pointOnDisplay[0] < renderer->GetVtkRenderer()->GetOrigin()[0] ||
pointOnDisplay[1] < renderer->GetVtkRenderer()->GetOrigin()[1] ||
pointOnDisplay[0] > renderer->GetVtkRenderer()->GetOrigin()[0] + renderer->GetViewportSize()[0] ||
pointOnDisplay[1] > renderer->GetVtkRenderer()->GetOrigin()[1] + renderer->GetViewportSize()[1])
{
mitk::Point2D pointOnPlane;
renderer->GetCurrentWorldPlaneGeometry()->Map(p, pointOnPlane);
renderer->GetCameraController()->MoveCameraToPoint(pointOnPlane);
}
}
void QmitkStdMultiWidget::SetWidgetPlaneVisibility(const char *widgetName, bool visible, mitk::BaseRenderer *renderer)
{
auto dataStorage = GetDataStorage();
if (nullptr != dataStorage)
{
mitk::DataNode* dataNode = dataStorage->GetNamedNode(widgetName);
if (dataNode != nullptr)
{
dataNode->SetVisibility(visible, renderer);
}
}
}
void QmitkStdMultiWidget::SetWidgetPlanesVisibility(bool visible, mitk::BaseRenderer *renderer)
{
if (m_PlaneNode1.IsNotNull())
{
m_PlaneNode1->SetVisibility(visible, renderer);
}
if (m_PlaneNode2.IsNotNull())
{
m_PlaneNode2->SetVisibility(visible, renderer);
}
if (m_PlaneNode3.IsNotNull())
{
m_PlaneNode3->SetVisibility(visible, renderer);
}
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
//////////////////////////////////////////////////////////////////////////
// PRIVATE
//////////////////////////////////////////////////////////////////////////
void QmitkStdMultiWidget::SetLayoutImpl()
{
CreateRenderWindowWidgets();
GetMultiWidgetLayoutManager()->SetLayoutDesign(QmitkMultiWidgetLayoutManager::LayoutDesign::DEFAULT);
// Initialize views as axial, sagittal, coronal to all data objects in DataStorage
auto geo = GetDataStorage()->ComputeBoundingGeometry3D(GetDataStorage()->GetAll());
mitk::RenderingManager::GetInstance()->InitializeViews(geo);
}
void QmitkStdMultiWidget::CreateRenderWindowWidgets()
{
// create axial render window (widget)
QString renderWindowWidgetName = GetNameFromIndex(0, 0);
RenderWindowWidgetPointer renderWindowWidget1 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
auto renderWindow1 = renderWindowWidget1->GetRenderWindow();
renderWindow1->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Axial);
renderWindowWidget1->SetDecorationColor(GetDecorationColor(0));
renderWindowWidget1->SetCornerAnnotationText("Axial");
- renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(ViewDirection::AXIAL);
+ renderWindowWidget1->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Axial);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget1);
// create sagittal render window (widget)
renderWindowWidgetName = GetNameFromIndex(0, 1);
RenderWindowWidgetPointer renderWindowWidget2 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
auto renderWindow2 = renderWindowWidget2->GetRenderWindow();
renderWindow2->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Sagittal);
renderWindowWidget2->SetDecorationColor(GetDecorationColor(1));
renderWindowWidget2->setStyleSheet("border: 0px");
renderWindowWidget2->SetCornerAnnotationText("Sagittal");
- renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(ViewDirection::SAGITTAL);
+ renderWindowWidget2->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Sagittal);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget2);
// create coronal render window (widget)
renderWindowWidgetName = GetNameFromIndex(1, 0);
RenderWindowWidgetPointer renderWindowWidget3 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
auto renderWindow3 = renderWindowWidget3->GetRenderWindow();
renderWindow3->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Coronal);
renderWindowWidget3->SetDecorationColor(GetDecorationColor(2));
renderWindowWidget3->SetCornerAnnotationText("Coronal");
- renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(ViewDirection::CORONAL);
+ renderWindowWidget3->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Coronal);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget3);
// create 3D render window (widget)
renderWindowWidgetName = GetNameFromIndex(1, 1);
RenderWindowWidgetPointer renderWindowWidget4 = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
auto renderWindow4 = renderWindowWidget4->GetRenderWindow();
renderWindow4->GetSliceNavigationController()->SetDefaultViewDirection(mitk::AnatomicalPlane::Original);
renderWindowWidget4->SetDecorationColor(GetDecorationColor(3));
renderWindowWidget4->SetCornerAnnotationText("3D");
- renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(ViewDirection::THREE_D);
+ renderWindowWidget4->GetRenderWindow()->SetLayoutIndex(mitk::AnatomicalPlane::Original);
mitk::BaseRenderer::GetInstance(renderWindowWidget4->GetRenderWindow()->renderWindow())->SetMapperID(mitk::BaseRenderer::Standard3D);
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget4);
SetActiveRenderWindowWidget(renderWindowWidget1);
// connect to the "time navigation controller": send time via sliceNavigationControllers
m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow1->GetSliceNavigationController());
m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow2->GetSliceNavigationController());
m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow3->GetSliceNavigationController());
m_TimeNavigationController->ConnectGeometryTimeEvent(renderWindow4->GetSliceNavigationController());
renderWindow1->GetSliceNavigationController()->ConnectGeometrySendEvent(
mitk::BaseRenderer::GetInstance(renderWindow4->renderWindow()));
// reverse connection between sliceNavigationControllers and timeNavigationController
renderWindow1->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
renderWindow2->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
renderWindow3->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
//renderWindow4->GetSliceNavigationController()->ConnectGeometryTimeEvent(m_TimeNavigationController);
auto layoutManager = GetMultiWidgetLayoutManager();
connect(renderWindow1, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
connect(renderWindow1, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
connect(renderWindow1, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
connect(renderWindow1, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairVisibility);
connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow1, &QmitkRenderWindow::UpdateCrosshairRotationMode);
connect(renderWindow2, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
connect(renderWindow2, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
connect(renderWindow2, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
connect(renderWindow2, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairVisibility);
connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow2, &QmitkRenderWindow::UpdateCrosshairRotationMode);
connect(renderWindow3, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
connect(renderWindow3, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
connect(renderWindow3, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
connect(renderWindow3, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairVisibility);
connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow3, &QmitkRenderWindow::UpdateCrosshairRotationMode);
connect(renderWindow4, &QmitkRenderWindow::ResetView, this, &QmitkStdMultiWidget::ResetCrosshair);
connect(renderWindow4, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkStdMultiWidget::SetCrosshairVisibility);
connect(renderWindow4, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkStdMultiWidget::SetWidgetPlaneMode);
connect(renderWindow4, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(this, &QmitkStdMultiWidget::NotifyCrosshairVisibilityChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairVisibility);
connect(this, &QmitkStdMultiWidget::NotifyCrosshairRotationModeChanged, renderWindow4, &QmitkRenderWindow::UpdateCrosshairRotationMode);
}
diff --git a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
index 99ccfe8289..1673398ef5 100644
--- a/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
+++ b/Plugins/org.mitk.gui.common/src/mitkIRenderWindowPart.h
@@ -1,218 +1,218 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKIRENDERWINDOWPART_H
#define MITKIRENDERWINDOWPART_H
#include <QString>
#include <QStringList>
#include <QHash>
#include <QtPlugin>
#include <mitkBaseRenderer.h>
#include <mitkNumericTypes.h>
#include <mitkRenderingManager.h>
#include <org_mitk_gui_common_Export.h>
class QmitkRenderWindow;
namespace mitk {
struct IRenderingManager;
class SliceNavigationController;
/**
* \ingroup org_mitk_gui_common
*
* \brief Interface for a MITK Workbench Part providing a render window.
*
* This interface allows generic access to Workbench parts which provide some
* kind of render window. The interface is intended to be implemented by
* subclasses of berry::IWorkbenchPart. Usually, the interface is implemented
* by a Workbench editor.
*
* A IRenderWindowPart provides zero or more QmitkRenderWindow instances which can
* be controlled via this interface. QmitkRenderWindow instances have an associated
* \e id, which is implementation specific.
- * Additionally the defined values AXIAL, SAGITTAL, CORONAL, THREE_D from mitk::BaseRenderer
+ * Additionally the defined values Axial, Sagittal, Coronal and Original from mitk::AnatomicalPlane
* can be used to retrieve a specific QmitkRenderWindow.
*
* \see ILinkedRenderWindowPart
* \see IRenderWindowPartListener
* \see QmitkAbstractRenderEditor
*/
struct MITK_GUI_COMMON_PLUGIN IRenderWindowPart {
static const QString DECORATION_BORDER; // = "border"
static const QString DECORATION_LOGO; // = "logo"
static const QString DECORATION_MENU; // = "menu"
static const QString DECORATION_BACKGROUND; // = "background"
static const QString DECORATION_CORNER_ANNOTATION; // = "corner annotation"
virtual ~IRenderWindowPart();
/**
* Get the currently active (focused) render window.
* Focus handling is implementation specific.
*
* \return The active QmitkRenderWindow instance; <code>nullptr</code>
* if no render window is active.
*/
virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const = 0;
/**
* Get all render windows with their ids.
*
* \return A hash map mapping the render window id to the QmitkRenderWindow instance.
*/
virtual QHash<QString,QmitkRenderWindow*> GetQmitkRenderWindows() const = 0;
/**
* Get a render window with a specific id.
*
* \param id The render window id.
* \return The QmitkRenderWindow instance for <code>id</code>
*/
virtual QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const = 0;
/**
- * Get a render window with a specific view direction.
+ * Get a render window with a specific plane orientation.
*
- * \param viewDirection The render window view direction.
- * \return The QmitkRenderWindow instance for <code>viewDirection</code>
+ * \param orientation The render window plane orientation.
+ * \return The QmitkRenderWindow instance for <code>orientation</code>
*/
- virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const = 0;
+ virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const = 0;
/**
* Get the rendering manager used by this render window part.
*
* \return The current IRenderingManager instance or <code>nullptr</code>
* if no rendering manager is used.
*/
virtual mitk::IRenderingManager* GetRenderingManager() const = 0;
/**
* Request an update of all render windows.
*
* \param requestType Specifies the type of render windows for which an update
* will be requested.
*/
virtual void RequestUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) = 0;
/**
* Force an immediate update of all render windows.
*
* \param requestType Specifies the type of render windows for which an immediate update
* will be requested.
*/
virtual void ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType = mitk::RenderingManager::REQUEST_UPDATE_ALL) = 0;
/**
* @brief Set the reference geometry for interaction inside the render windows of the render window part.
*
* @param referenceGeometry The reference geometry which is used for updating the
* time geometry inside the render windows.
* @param resetCamera If true, the camera and crosshair will be reset to the default view (centered, no zoom).
* If false, the current crosshair position and the camera zoom will be stored and reset
* after the reference geometry has been updated.
*/
virtual void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) = 0;
/**
* @brief Returns true if the render windows are coupled; false if not.
*
* Render windows are coupled if the slice navigation controller of the render windows
* are connected which means that always the same geometry is used for the render windows.
*/
virtual bool HasCoupledRenderWindows() const = 0;
/**
* Get the SliceNavigationController for controlling time positions.
*
* \return A SliceNavigationController if the render window supports this
* operation; otherwise returns <code>nullptr</code>.
*/
virtual mitk::SliceNavigationController* GetTimeNavigationController() const = 0;
/**
* Get the selected position in the render window with id <code>id</code>
* or in the active render window if <code>id</code> is an empty string.
*
* \param id The render window id.
* \return The currently selected position in world coordinates.
*/
virtual mitk::Point3D GetSelectedPosition(const QString& id = QString()) const = 0;
/**
* Set the selected position in the render window with id <code>id</code>
* or in the active render window if <code>id</code> is nullptr.
*
* \param pos The position in world coordinates which should be selected.
* \param id The render window id in which the selection should take place.
*/
virtual void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) = 0;
/**
* Get the time point selected in the render window with id <code>id</code>
* or in the active render window if <code>id</code> is an empty string.
*
* \param id The render window id.
* \return The currently selected position in world coordinates.
*/
virtual TimePointType GetSelectedTimePoint(const QString& id = QString()) const = 0;
/**
* Enable \e decorations like colored borders, menu widgets, logos, text annotations, etc.
*
* Decorations are implementation specific. A set of standardized decoration names is listed
* in GetDecorations().
*
* \param enable If <code>true</code> enable the decorations specified in <code>decorations</code>,
* otherwise disable them.
* \param decorations A list of decoration names. If empty, all supported decorations are affected.
*
* \see GetDecorations()
*/
virtual void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) = 0;
/**
* Return if a specific decoration is enabled.
*
* \return <code>true</code> if the decoration is enabled, <code>false</code> if it is disabled
* or unknown.
*
* \see GetDecorations()
*/
virtual bool IsDecorationEnabled(const QString& decoration) const = 0;
/**
* Get a list of supported decorations.
*
* The following decoration names are standardized and should not be used for other decoration types:
* <ul>
* <li>\e DECORATION_BORDER Any border decorations like colored rectangles, etc.
* <li>\e DECORATION_MENU Menus associated with render windows
* <li>\e DECORATION_BACKGROUND All kinds of backgrounds (patterns, gradients, etc.) except for solid colored backgrounds
* <li>\e DECORATION_LOGO Any kind of logo overlayed on the rendered scene
* </ul>
*
* \return A list of supported decoration names.
*/
virtual QStringList GetDecorations() const = 0;
};
}
Q_DECLARE_INTERFACE(mitk::IRenderWindowPart, "org.mitk.ui.IRenderWindowPart")
#endif // MITKIRENDERWINDOWPART_H
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
index 55390c7ad5..916ffd34a6 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.cpp
@@ -1,241 +1,241 @@
/*============================================================================
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 "QmitkAbstractMultiWidgetEditor.h"
// mitk qt widgets module
#include <QmitkAbstractMultiWidget.h>
#include <QmitkRenderWindowWidget.h>
// mitk gui qt common plugin
#include "QmitkMultiWidgetDecorationManager.h"
// berry
#include <berryIWorkbenchPartConstants.h>
const QString QmitkAbstractMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.abstractmultiwidget";
struct QmitkAbstractMultiWidgetEditor::Impl final
{
Impl();
~Impl() = default;
QmitkAbstractMultiWidget* m_MultiWidget;
std::unique_ptr<QmitkMultiWidgetDecorationManager> m_MultiWidgetDecorationManager;
};
QmitkAbstractMultiWidgetEditor::Impl::Impl()
: m_MultiWidget(nullptr)
{
// nothing here
}
QmitkAbstractMultiWidgetEditor::QmitkAbstractMultiWidgetEditor()
: m_Impl(std::make_unique<Impl>())
{
// nothing here
}
QmitkAbstractMultiWidgetEditor::~QmitkAbstractMultiWidgetEditor() {}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetActiveQmitkRenderWindow() const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
auto activeRenderWindowWidget = multiWidget->GetActiveRenderWindowWidget();
if (nullptr != activeRenderWindowWidget)
{
return activeRenderWindowWidget->GetRenderWindow();
}
}
return nullptr;
}
QHash<QString, QmitkRenderWindow*> QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindows() const
{
QHash<QString, QmitkRenderWindow*> result;
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return result;
}
result = multiWidget->GetRenderWindows();
return result;
}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindow(const QString& id) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return nullptr;
}
return multiWidget->GetRenderWindow(id);
}
-QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const
+QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return nullptr;
}
- return multiWidget->GetRenderWindow(viewDirection);
+ return multiWidget->GetRenderWindow(orientation);
}
void QmitkAbstractMultiWidgetEditor::SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return;
}
multiWidget->SetReferenceGeometry(referenceGeometry, resetCamera);
}
bool QmitkAbstractMultiWidgetEditor::HasCoupledRenderWindows() const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return false;
}
return multiWidget->HasCoupledRenderWindows();
}
mitk::Point3D QmitkAbstractMultiWidgetEditor::GetSelectedPosition(const QString& id/* = QString()*/) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return mitk::Point3D();
}
return multiWidget->GetSelectedPosition(id);
}
void QmitkAbstractMultiWidgetEditor::SetSelectedPosition(const mitk::Point3D& pos, const QString& id/* = QString()*/)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
return multiWidget->SetSelectedPosition(pos, id);
}
}
void QmitkAbstractMultiWidgetEditor::EnableDecorations(bool enable, const QStringList& decorations)
{
m_Impl->m_MultiWidgetDecorationManager->ShowDecorations(enable, decorations);
}
bool QmitkAbstractMultiWidgetEditor::IsDecorationEnabled(const QString& decoration) const
{
return m_Impl->m_MultiWidgetDecorationManager->IsDecorationVisible(decoration);
}
QStringList QmitkAbstractMultiWidgetEditor::GetDecorations() const
{
return m_Impl->m_MultiWidgetDecorationManager->GetDecorations();
}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindowByIndex(int index) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return nullptr;
}
QString renderWindowName = multiWidget->GetNameFromIndex(index);
return multiWidget->GetRenderWindow(renderWindowName);
}
QmitkRenderWindow* QmitkAbstractMultiWidgetEditor::GetQmitkRenderWindowByIndex(int row, int column) const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return nullptr;
}
QString renderWindowName = multiWidget->GetNameFromIndex(row, column);
return multiWidget->GetRenderWindow(renderWindowName);
}
void QmitkAbstractMultiWidgetEditor::SetMultiWidget(QmitkAbstractMultiWidget* multiWidget)
{
m_Impl->m_MultiWidget = multiWidget;
m_Impl->m_MultiWidgetDecorationManager.reset(new QmitkMultiWidgetDecorationManager(multiWidget));
}
QmitkAbstractMultiWidget* QmitkAbstractMultiWidgetEditor::GetMultiWidget() const
{
return m_Impl->m_MultiWidget;
}
int QmitkAbstractMultiWidgetEditor::GetRowCount() const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return 0;
}
return multiWidget->GetRowCount();
}
int QmitkAbstractMultiWidgetEditor::GetColumnCount() const
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return 0;
}
return multiWidget->GetColumnCount();
}
void QmitkAbstractMultiWidgetEditor::OnLayoutSet(int row, int column)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->SetLayout(row, column);
FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
}
}
void QmitkAbstractMultiWidgetEditor::OnSynchronize(bool synchronized)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->Synchronize(synchronized);
}
}
void QmitkAbstractMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->SetInteractionScheme(scheme);
}
}
diff --git a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
index c053a419c6..ac66afd25e 100644
--- a/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
+++ b/Plugins/org.mitk.gui.qt.common/src/QmitkAbstractMultiWidgetEditor.h
@@ -1,135 +1,135 @@
/*============================================================================
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 QMITKABSTRACTMULTIWIDGETEDITOR_H
#define QMITKABSTRACTMULTIWIDGETEDITOR_H
#include <org_mitk_gui_qt_common_Export.h>
// org mitk gui qt common plugin
#include <QmitkAbstractRenderEditor.h>
// mitk core
#include <mitkInteractionSchemeSwitcher.h>
// berry
#include <berryIPartListener.h>
// c++
#include <memory>
class QmitkAbstractMultiWidget;
class QmitkLevelWindowWidget;
class MITK_QT_COMMON QmitkAbstractMultiWidgetEditor : public QmitkAbstractRenderEditor, public berry::IPartListener
{
Q_OBJECT
public:
berryObjectMacro(QmitkAbstractMultiWidgetEditor, QmitkAbstractRenderEditor, IPartListener);
static const QString EDITOR_ID;
QmitkAbstractMultiWidgetEditor();
virtual ~QmitkAbstractMultiWidgetEditor() override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QmitkRenderWindow* GetActiveQmitkRenderWindow() const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QHash<QString, QmitkRenderWindow*> GetQmitkRenderWindows() const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QmitkRenderWindow* GetQmitkRenderWindow(const QString& id) const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
- virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::BaseRenderer::ViewDirection& viewDirection) const override;
+ virtual QmitkRenderWindow* GetQmitkRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
void SetReferenceGeometry(const mitk::TimeGeometry* referenceGeometry, bool resetCamera) override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
bool HasCoupledRenderWindows() const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual mitk::Point3D GetSelectedPosition(const QString& id = QString()) const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual void SetSelectedPosition(const mitk::Point3D& pos, const QString& id = QString()) override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual void EnableDecorations(bool enable, const QStringList& decorations = QStringList()) override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual bool IsDecorationEnabled(const QString& decoration) const override;
/**
* @brief Overridden from QmitkAbstractRenderEditor : IRenderWindowPart
*/
virtual QStringList GetDecorations() const override;
/**
* @brief Retrieve a QmitkRenderWindow by its index.
*/
virtual QmitkRenderWindow* GetQmitkRenderWindowByIndex(int index) const;
/**
* @brief Retrieve a QmitkRenderWindow by the row and column position.
*/
virtual QmitkRenderWindow* GetQmitkRenderWindowByIndex(int row, int column) const;
/**
* @brief Set the current multi widget of this editor.
*/
virtual void SetMultiWidget(QmitkAbstractMultiWidget* multiWidget);
/**
* @brief Return the current multi widget of this editor.
*/
virtual QmitkAbstractMultiWidget* GetMultiWidget() const;
/**
* @brief Return the number of rows of the underlying multi widget.
*/
virtual int GetRowCount() const;
/**
* @brief Return the number of columns of the underlying multi widget.
*/
virtual int GetColumnCount() const;
virtual QmitkLevelWindowWidget* GetLevelWindowWidget() const = 0;
public Q_SLOTS:
/**
* @brief A slot that can be called if the layout has been changed.
* This function will call the function 'SetLayout' of the multi widget where
* custom behavior can be implemented.
* Finally 'FirePropertyChange' is called to inform the workbench about an input change.
*/
virtual void OnLayoutSet(int row, int column);
virtual void OnSynchronize(bool synchronized);
virtual void OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme);
private:
struct Impl;
std::unique_ptr<Impl> m_Impl;
};
#endif // QMITKABSTRACTMULTIWIDGETEDITOR_H