diff --git a/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp b/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp
index 1c90cbb343..1dec42e65c 100644
--- a/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp
+++ b/Modules/PlanarFigure/src/Rendering/mitkPlanarFigureMapper2D.cpp
@@ -1,964 +1,965 @@
/*============================================================================
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 "mitkPlanarFigureMapper2D.h"
#include "mitkBaseRenderer.h"
#include "mitkColorProperty.h"
#include "vtkContext2D.h"
#include "vtkContextDevice2D.h"
#include "vtkOpenGLContextDevice2D.h"
#include "mitkPlaneGeometry.h"
#include "mitkProperties.h"
#include "vtkTextProperty.h"
#define _USE_MATH_DEFINES
#include <cmath>
#include <array>
#include <vector>
#include <regex>
mitk::PlanarFigureMapper2D::PlanarFigureMapper2D()
: m_NodeModified(true), m_NodeModifiedObserverTag(0), m_NodeModifiedObserverAdded(false), m_Initialized(false)
{
this->InitializeDefaultPlanarFigureProperties();
}
mitk::PlanarFigureMapper2D::~PlanarFigureMapper2D()
{
if (m_NodeModifiedObserverAdded && GetDataNode() != nullptr)
{
GetDataNode()->RemoveObserver(m_NodeModifiedObserverTag);
}
}
void mitk::PlanarFigureMapper2D::ApplyColorAndOpacityProperties(mitk::BaseRenderer *renderer, vtkActor * /*actor*/)
{
float rgba[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
// check for color prop and use it for rendering if it exists
GetDataNode()->GetColor(rgba, renderer, "color");
// check for opacity prop and use it for rendering if it exists
GetDataNode()->GetOpacity(rgba[3], renderer, "opacity");
this->m_Pen->SetColorF((double)rgba[0], (double)rgba[1], (double)rgba[2], (double)rgba[3]);
}
void mitk::PlanarFigureMapper2D::Initialize(mitk::BaseRenderer *)
{
this->m_Pen = vtkSmartPointer<vtkPen>::New();
vtkOpenGLContextDevice2D *device = nullptr;
device = vtkOpenGLContextDevice2D::New();
if (device)
{
this->m_Context->Begin(device);
device->Delete();
this->m_Initialized = true;
this->m_Context->ApplyPen(this->m_Pen);
}
else
{
}
}
void mitk::PlanarFigureMapper2D::MitkRender(mitk::BaseRenderer *renderer, mitk::VtkPropRenderer::RenderType type)
{
/* This is a temporary fix because the rendering of planar figures causes problems when two windows try to show the
same figure, which can happen a lot when using the MxNMultiWidget. Therefore, rendering is completely
disabled here if the renderer in question does not belong to the StdMultiWidget.
See T29333 */
- std::regex pattern("^stdmulti\\.widget[0-3]$");
- if (!std::regex_match(renderer->GetName(), pattern))
+ std::regex pattern("^mxn\\.widget");
+ std::cmatch match;
+ if (std::regex_search(renderer->GetName(), match, pattern))
return;
if (type != mitk::VtkPropRenderer::Overlay) return;
if (!this->m_Initialized)
{
this->Initialize(renderer);
}
vtkOpenGLContextDevice2D::SafeDownCast(
this->m_Context->GetDevice())->Begin(renderer->GetVtkRenderer());
bool visible = true;
GetDataNode()->GetVisibility(visible, renderer, "visible");
if (!visible)
return;
// Get PlanarFigure from input
auto *planarFigure =
const_cast<mitk::PlanarFigure *>(static_cast<const mitk::PlanarFigure *>(GetDataNode()->GetData()));
// Check if PlanarFigure has already been placed; otherwise, do nothing
if (!planarFigure->IsPlaced())
{
return;
}
// Get 2D geometry frame of PlanarFigure
const mitk::PlaneGeometry *planarFigurePlaneGeometry = planarFigure->GetPlaneGeometry();
if (planarFigurePlaneGeometry == nullptr)
{
MITK_ERROR << "PlanarFigure does not have valid PlaneGeometry!";
return;
}
// Get current world 2D geometry from renderer
const mitk::PlaneGeometry *rendererPlaneGeometry = renderer->GetCurrentWorldPlaneGeometry();
// If the PlanarFigure geometry is a plane geometry, check if current
// world plane is parallel to and within the planar figure geometry bounds
// (otherwise, display nothing)
if ((planarFigurePlaneGeometry != nullptr) && (rendererPlaneGeometry != nullptr))
{
double planeThickness = planarFigurePlaneGeometry->GetExtentInMM(2);
if (!planarFigurePlaneGeometry->IsParallel(rendererPlaneGeometry) ||
!(planarFigurePlaneGeometry->DistanceFromPlane(rendererPlaneGeometry) < planeThickness / 3.0))
{
// Planes are not parallel or renderer plane is not within PlanarFigure
// geometry bounds --> exit
return;
}
}
else
{
// Plane is not valid (curved reformations are not possible yet)
return;
}
// Apply visual appearance properties from the PropertyList
ApplyColorAndOpacityProperties(renderer);
// Get properties from node (if present)
const mitk::DataNode *node = this->GetDataNode();
this->InitializePlanarFigurePropertiesFromDataNode(node);
PlanarFigureDisplayMode lineDisplayMode = PF_DEFAULT;
if (m_IsSelected)
{
lineDisplayMode = PF_SELECTED;
}
else if (m_IsHovering)
{
lineDisplayMode = PF_HOVER;
}
mitk::Point2D anchorPoint;
anchorPoint[0] = 0;
anchorPoint[1] = 1;
// render the actual lines of the PlanarFigure
RenderLines(lineDisplayMode, planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
// position-offset of the annotations, is set in RenderAnnotations() and
// used in RenderQuantities()
double annotationOffset = 0.0;
// Get Global Opacity
float globalOpacity = 1.0;
node->GetFloatProperty("opacity", globalOpacity);
if (m_DrawControlPoints)
{
// draw the control-points
RenderControlPoints(planarFigure, lineDisplayMode, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
}
// draw name near the anchor point (point located on the right)
const std::string name = node->GetName();
if (m_DrawName && !name.empty())
{
RenderAnnotations(renderer, name, anchorPoint, globalOpacity, lineDisplayMode, annotationOffset);
}
// draw feature quantities (if requested) next to the anchor point,
// but under the name (that is where 'annotationOffset' is used)
if (m_DrawQuantities)
{
RenderQuantities(planarFigure, renderer, anchorPoint, annotationOffset, globalOpacity, lineDisplayMode);
}
this->m_Context->GetDevice()->End();
}
void mitk::PlanarFigureMapper2D::PaintPolyLine(const mitk::PlanarFigure::PolyLineType vertices,
bool closed,
Point2D &anchorPoint,
const PlaneGeometry *planarFigurePlaneGeometry,
const PlaneGeometry *rendererPlaneGeometry,
const mitk::BaseRenderer *renderer)
{
mitk::Point2D rightMostPoint;
rightMostPoint.Fill(itk::NumericTraits<float>::min());
// transform all vertices into Point2Ds in display-Coordinates and store them in vector
std::vector<mitk::Point2D> pointlist;
for (auto iter = vertices.cbegin(); iter != vertices.cend(); ++iter)
{
// Draw this 2D point as OpenGL vertex
mitk::Point2D displayPoint;
this->TransformObjectToDisplay(*iter, displayPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
pointlist.push_back(displayPoint);
if (displayPoint[0] > rightMostPoint[0])
rightMostPoint = displayPoint;
}
// If the planarfigure is closed, we add the first control point again.
// Thus we can always use 'GL_LINE_STRIP' and get rid of strange flickering
// effect when using the MESA OpenGL library.
if (closed)
{
mitk::Point2D displayPoint;
this->TransformObjectToDisplay(
vertices.cbegin()[0], displayPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
pointlist.push_back(displayPoint);
}
// now paint all the points in one run
std::vector<float> points;
points.reserve(pointlist.size() * 2);
for (unsigned int i = 0 ; i < pointlist.size() ; ++i)
{
points.push_back(pointlist[i][0]);
points.push_back(pointlist[i][1]);
}
if (2 <= pointlist.size())
m_Context->DrawPoly(points.data(), pointlist.size());
anchorPoint = rightMostPoint;
}
void mitk::PlanarFigureMapper2D::DrawMainLines(mitk::PlanarFigure *figure,
Point2D &anchorPoint,
const PlaneGeometry *planarFigurePlaneGeometry,
const PlaneGeometry *rendererPlaneGeometry,
const mitk::BaseRenderer *renderer)
{
const auto numberOfPolyLines = figure->GetPolyLinesSize();
for (auto loop = 0; loop < numberOfPolyLines; ++loop)
{
const auto polyline = figure->GetPolyLine(loop);
this->PaintPolyLine(
polyline, figure->IsClosed(), anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
}
}
void mitk::PlanarFigureMapper2D::DrawHelperLines(mitk::PlanarFigure *figure,
Point2D &anchorPoint,
const PlaneGeometry *planarFigurePlaneGeometry,
const PlaneGeometry *rendererPlaneGeometry,
const mitk::BaseRenderer *renderer)
{
const auto numberOfHelperPolyLines = figure->GetHelperPolyLinesSize();
// Draw helper objects
for (unsigned int loop = 0; loop < numberOfHelperPolyLines; ++loop)
{
const auto helperPolyLine =
figure->GetHelperPolyLine(loop, renderer->GetScaleFactorMMPerDisplayUnit(), renderer->GetViewportSize()[1]);
// Check if the current helper objects is to be painted
if (!figure->IsHelperToBePainted(loop))
{
continue;
}
// ... and once normally above the shadow.
this->PaintPolyLine(helperPolyLine, false, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
}
}
void mitk::PlanarFigureMapper2D::TransformObjectToDisplay(const mitk::Point2D &point2D,
mitk::Point2D &displayPoint,
const mitk::PlaneGeometry *objectGeometry,
const mitk::PlaneGeometry * /*rendererGeometry*/,
const mitk::BaseRenderer *renderer)
{
mitk::Point3D point3D;
// Map circle point from local 2D geometry into 3D world space
objectGeometry->Map(point2D, point3D);
// Project 3D world point onto display geometry
renderer->WorldToView(point3D, displayPoint);
}
void mitk::PlanarFigureMapper2D::DrawMarker(const mitk::Point2D &point,
float *lineColor,
float lineOpacity,
float *markerColor,
float markerOpacity,
float lineWidth,
PlanarFigureControlPointStyleProperty::Shape shape,
const mitk::PlaneGeometry *objectGeometry,
const mitk::PlaneGeometry *rendererGeometry,
const mitk::BaseRenderer *renderer)
{
if (this->GetDataNode() != nullptr && this->GetDataNode()->GetDataInteractor().IsNull())
return;
if (markerOpacity == 0 && lineOpacity == 0)
return;
mitk::Point2D displayPoint;
this->TransformObjectToDisplay(point, displayPoint, objectGeometry, rendererGeometry, renderer);
this->m_Context->GetPen()->SetColorF((double)markerColor[0], (double)markerColor[1], (double)markerColor[2], markerOpacity);
this->m_Context->GetPen()->SetWidth(lineWidth);
switch (shape)
{
case PlanarFigureControlPointStyleProperty::Square:
default:
{
// Paint filled square
if (markerOpacity > 0)
{
m_Context->DrawRect(displayPoint[0] - 4, displayPoint[1] - 4, 8, 8);
}
// Paint outline
this->m_Context->GetPen()->SetColorF((double)lineColor[0], (double)lineColor[1], (double)lineColor[2], (double)lineOpacity);
std::array<float, 8> outline = {{
static_cast<float>(displayPoint[0] - 4),
static_cast<float>(displayPoint[1] - 4),
static_cast<float>(displayPoint[0] - 4),
static_cast<float>(displayPoint[1] + 4),
static_cast<float>(displayPoint[0] + 4),
static_cast<float>(displayPoint[1] + 4),
static_cast<float>(displayPoint[0] + 4),
static_cast<float>(displayPoint[1] - 4)
}};
m_Context->DrawLines(outline.data(), 4);
break;
}
case PlanarFigureControlPointStyleProperty::Circle:
{
// TODO: This code can not be reached using the properties provided in the GUI
/*float radius = 4.0;
if (markerOpacity > 0)
{
// Paint filled circle
glBegin(GL_POLYGON);
for (int angle = 0; angle < 8; ++angle)
{
float angleRad = angle * (float)3.14159 / 4.0;
float x = displayPoint[0] + radius * (float)cos(angleRad);
float y = displayPoint[1] + radius * (float)sin(angleRad);
glVertex3f(x, y, PLANAR_OFFSET);
}
glEnd();
}
// Paint outline
glColor4f(lineColor[0], lineColor[1], lineColor[2], lineOpacity);
glBegin(GL_LINE_LOOP);
for (int angle = 0; angle < 8; ++angle)
{
float angleRad = angle * (float)3.14159 / 4.0;
float x = displayPoint[0] + radius * (float)cos(angleRad);
float y = displayPoint[1] + radius * (float)sin(angleRad);
glVertex3f(x, y, PLANAR_OFFSET);
}
glEnd();*/
break;
}
} // end switch
}
void mitk::PlanarFigureMapper2D::InitializeDefaultPlanarFigureProperties()
{
m_IsSelected = false;
m_IsHovering = false;
m_DrawOutline = false;
m_DrawQuantities = false;
m_DrawShadow = false;
m_DrawControlPoints = false;
m_DrawName = true;
m_DrawDashed = false;
m_DrawHelperDashed = false;
m_AnnotationsShadow = false;
m_ShadowWidthFactor = 1.2;
m_LineWidth = 1.0;
m_OutlineWidth = 4.0;
m_HelperlineWidth = 2.0;
m_DevicePixelRatio = 1.0;
m_ControlPointShape = PlanarFigureControlPointStyleProperty::Square;
this->SetColorProperty(m_LineColor, PF_DEFAULT, 1.0, 1.0, 1.0);
this->SetFloatProperty(m_LineOpacity, PF_DEFAULT, 1.0);
this->SetColorProperty(m_OutlineColor, PF_DEFAULT, 0.0, 0.0, 1.0);
this->SetFloatProperty(m_OutlineOpacity, PF_DEFAULT, 1.0);
this->SetColorProperty(m_HelperlineColor, PF_DEFAULT, 0.4, 0.8, 0.2);
this->SetFloatProperty(m_HelperlineOpacity, PF_DEFAULT, 0.4);
this->SetColorProperty(m_MarkerlineColor, PF_DEFAULT, 1.0, 1.0, 1.0);
this->SetFloatProperty(m_MarkerlineOpacity, PF_DEFAULT, 1.0);
this->SetColorProperty(m_MarkerColor, PF_DEFAULT, 1.0, 1.0, 1.0);
this->SetFloatProperty(m_MarkerOpacity, PF_DEFAULT, 0.0);
this->SetColorProperty(m_AnnotationColor, PF_DEFAULT, 1.0, 1.0, 1.0);
this->SetColorProperty(m_LineColor, PF_HOVER, 1.0, 0.7, 0.0);
this->SetFloatProperty(m_LineOpacity, PF_HOVER, 1.0);
this->SetColorProperty(m_OutlineColor, PF_HOVER, 0.0, 0.0, 1.0);
this->SetFloatProperty(m_OutlineOpacity, PF_HOVER, 1.0);
this->SetColorProperty(m_HelperlineColor, PF_HOVER, 0.4, 0.8, 0.2);
this->SetFloatProperty(m_HelperlineOpacity, PF_HOVER, 0.4);
this->SetColorProperty(m_MarkerlineColor, PF_HOVER, 1.0, 1.0, 1.0);
this->SetFloatProperty(m_MarkerlineOpacity, PF_HOVER, 1.0);
this->SetColorProperty(m_MarkerColor, PF_HOVER, 1.0, 0.6, 0.0);
this->SetFloatProperty(m_MarkerOpacity, PF_HOVER, 0.2);
this->SetColorProperty(m_AnnotationColor, PF_HOVER, 1.0, 0.7, 0.0);
this->SetColorProperty(m_LineColor, PF_SELECTED, 1.0, 0.0, 0.0);
this->SetFloatProperty(m_LineOpacity, PF_SELECTED, 1.0);
this->SetColorProperty(m_OutlineColor, PF_SELECTED, 0.0, 0.0, 1.0);
this->SetFloatProperty(m_OutlineOpacity, PF_SELECTED, 1.0);
this->SetColorProperty(m_HelperlineColor, PF_SELECTED, 0.4, 0.8, 0.2);
this->SetFloatProperty(m_HelperlineOpacity, PF_SELECTED, 0.4);
this->SetColorProperty(m_MarkerlineColor, PF_SELECTED, 1.0, 1.0, 1.0);
this->SetFloatProperty(m_MarkerlineOpacity, PF_SELECTED, 1.0);
this->SetColorProperty(m_MarkerColor, PF_SELECTED, 1.0, 0.6, 0.0);
this->SetFloatProperty(m_MarkerOpacity, PF_SELECTED, 1.0);
this->SetColorProperty(m_AnnotationColor, PF_SELECTED, 1.0, 0.0, 0.0);
}
void mitk::PlanarFigureMapper2D::InitializePlanarFigurePropertiesFromDataNode(const mitk::DataNode *node)
{
if (node == nullptr)
{
return;
}
// if we have not added an observer for ModifiedEvents on the DataNode,
// we add one now.
if (!m_NodeModifiedObserverAdded)
{
itk::SimpleMemberCommand<mitk::PlanarFigureMapper2D>::Pointer nodeModifiedCommand =
itk::SimpleMemberCommand<mitk::PlanarFigureMapper2D>::New();
nodeModifiedCommand->SetCallbackFunction(this, &mitk::PlanarFigureMapper2D::OnNodeModified);
m_NodeModifiedObserverTag = node->AddObserver(itk::ModifiedEvent(), nodeModifiedCommand);
m_NodeModifiedObserverAdded = true;
}
// If the DataNode has not been modified since the last execution of
// this method, we do not run it now.
if (!m_NodeModified)
return;
// Mark the current properties as unmodified
m_NodeModified = false;
// Get Global Opacity
float globalOpacity = 1.0;
node->GetFloatProperty("opacity", globalOpacity);
node->GetBoolProperty("selected", m_IsSelected);
node->GetBoolProperty("planarfigure.ishovering", m_IsHovering);
node->GetBoolProperty("planarfigure.drawoutline", m_DrawOutline);
node->GetBoolProperty("planarfigure.drawshadow", m_DrawShadow);
node->GetBoolProperty("planarfigure.drawquantities", m_DrawQuantities);
node->GetBoolProperty("planarfigure.drawcontrolpoints", m_DrawControlPoints);
node->GetBoolProperty("planarfigure.drawname", m_DrawName);
node->GetBoolProperty("planarfigure.drawdashed", m_DrawDashed);
node->GetBoolProperty("planarfigure.helperline.drawdashed", m_DrawHelperDashed);
node->GetFloatProperty("planarfigure.line.width", m_LineWidth);
node->GetFloatProperty("planarfigure.shadow.widthmodifier", m_ShadowWidthFactor);
node->GetFloatProperty("planarfigure.outline.width", m_OutlineWidth);
node->GetFloatProperty("planarfigure.helperline.width", m_HelperlineWidth);
node->GetFloatProperty("planarfigure.devicepixelratio", m_DevicePixelRatio);
node->GetStringProperty("planarfigure.annotations.font.family", m_AnnotationFontFamily);
node->GetBoolProperty("planarfigure.annotations.font.bold", m_DrawAnnotationBold);
node->GetBoolProperty("planarfigure.annotations.font.italic", m_DrawAnnotationItalic);
node->GetIntProperty("planarfigure.annotations.font.size", m_AnnotationSize);
if (!node->GetBoolProperty("planarfigure.annotations.shadow", m_AnnotationsShadow))
{
node->GetBoolProperty("planarfigure.drawshadow", m_AnnotationsShadow);
}
PlanarFigureControlPointStyleProperty::Pointer styleProperty =
dynamic_cast<PlanarFigureControlPointStyleProperty *>(node->GetProperty("planarfigure.controlpointshape"));
if (styleProperty.IsNotNull())
{
m_ControlPointShape = styleProperty->GetShape();
}
// Set default color and opacity
// If property "planarfigure.default.*.color" exists, then use that color. Otherwise global "color" property is used.
if (!node->GetColor(m_LineColor[PF_DEFAULT], nullptr, "planarfigure.default.line.color"))
{
node->GetColor(m_LineColor[PF_DEFAULT], nullptr, "color");
}
node->GetFloatProperty("planarfigure.default.line.opacity", m_LineOpacity[PF_DEFAULT]);
if (!node->GetColor(m_OutlineColor[PF_DEFAULT], nullptr, "planarfigure.default.outline.color"))
{
node->GetColor(m_OutlineColor[PF_DEFAULT], nullptr, "color");
}
node->GetFloatProperty("planarfigure.default.outline.opacity", m_OutlineOpacity[PF_DEFAULT]);
if (!node->GetColor(m_HelperlineColor[PF_DEFAULT], nullptr, "planarfigure.default.helperline.color"))
{
node->GetColor(m_HelperlineColor[PF_DEFAULT], nullptr, "color");
}
node->GetFloatProperty("planarfigure.default.helperline.opacity", m_HelperlineOpacity[PF_DEFAULT]);
node->GetColor(m_MarkerlineColor[PF_DEFAULT], nullptr, "planarfigure.default.markerline.color");
node->GetFloatProperty("planarfigure.default.markerline.opacity", m_MarkerlineOpacity[PF_DEFAULT]);
node->GetColor(m_MarkerColor[PF_DEFAULT], nullptr, "planarfigure.default.marker.color");
node->GetFloatProperty("planarfigure.default.marker.opacity", m_MarkerOpacity[PF_DEFAULT]);
if (!node->GetColor(m_AnnotationColor[PF_DEFAULT], nullptr, "planarfigure.default.annotation.color"))
{
if (!node->GetColor(m_AnnotationColor[PF_DEFAULT], nullptr, "planarfigure.default.line.color"))
{
node->GetColor(m_AnnotationColor[PF_DEFAULT], nullptr, "color");
}
}
// Set hover color and opacity
node->GetColor(m_LineColor[PF_HOVER], nullptr, "planarfigure.hover.line.color");
node->GetFloatProperty("planarfigure.hover.line.opacity", m_LineOpacity[PF_HOVER]);
node->GetColor(m_OutlineColor[PF_HOVER], nullptr, "planarfigure.hover.outline.color");
node->GetFloatProperty("planarfigure.hover.outline.opacity", m_OutlineOpacity[PF_HOVER]);
node->GetColor(m_HelperlineColor[PF_HOVER], nullptr, "planarfigure.hover.helperline.color");
node->GetFloatProperty("planarfigure.hover.helperline.opacity", m_HelperlineOpacity[PF_HOVER]);
node->GetColor(m_MarkerlineColor[PF_HOVER], nullptr, "planarfigure.hover.markerline.color");
node->GetFloatProperty("planarfigure.hover.markerline.opacity", m_MarkerlineOpacity[PF_HOVER]);
node->GetColor(m_MarkerColor[PF_HOVER], nullptr, "planarfigure.hover.marker.color");
node->GetFloatProperty("planarfigure.hover.marker.opacity", m_MarkerOpacity[PF_HOVER]);
if (!node->GetColor(m_AnnotationColor[PF_HOVER], nullptr, "planarfigure.hover.annotation.color"))
{
if (!node->GetColor(m_AnnotationColor[PF_HOVER], nullptr, "planarfigure.hover.line.color"))
{
node->GetColor(m_AnnotationColor[PF_HOVER], nullptr, "color");
}
}
// Set selected color and opacity
node->GetColor(m_LineColor[PF_SELECTED], nullptr, "planarfigure.selected.line.color");
node->GetFloatProperty("planarfigure.selected.line.opacity", m_LineOpacity[PF_SELECTED]);
node->GetColor(m_OutlineColor[PF_SELECTED], nullptr, "planarfigure.selected.outline.color");
node->GetFloatProperty("planarfigure.selected.outline.opacity", m_OutlineOpacity[PF_SELECTED]);
node->GetColor(m_HelperlineColor[PF_SELECTED], nullptr, "planarfigure.selected.helperline.color");
node->GetFloatProperty("planarfigure.selected.helperline.opacity", m_HelperlineOpacity[PF_SELECTED]);
node->GetColor(m_MarkerlineColor[PF_SELECTED], nullptr, "planarfigure.selected.markerline.color");
node->GetFloatProperty("planarfigure.selected.markerline.opacity", m_MarkerlineOpacity[PF_SELECTED]);
node->GetColor(m_MarkerColor[PF_SELECTED], nullptr, "planarfigure.selected.marker.color");
node->GetFloatProperty("planarfigure.selected.marker.opacity", m_MarkerOpacity[PF_SELECTED]);
if (!node->GetColor(m_AnnotationColor[PF_SELECTED], nullptr, "planarfigure.selected.annotation.color"))
{
if (!node->GetColor(m_AnnotationColor[PF_SELECTED], nullptr, "planarfigure.selected.line.color"))
{
node->GetColor(m_AnnotationColor[PF_SELECTED], nullptr, "color");
}
}
// adapt opacity values to global "opacity" property
for (unsigned int i = 0; i < PF_COUNT; ++i)
{
m_LineOpacity[i] *= globalOpacity;
m_OutlineOpacity[i] *= globalOpacity;
m_HelperlineOpacity[i] *= globalOpacity;
m_MarkerlineOpacity[i] *= globalOpacity;
m_MarkerOpacity[i] *= globalOpacity;
}
}
void mitk::PlanarFigureMapper2D::OnNodeModified()
{
m_NodeModified = true;
}
void mitk::PlanarFigureMapper2D::SetDefaultProperties(mitk::DataNode *node,
mitk::BaseRenderer *renderer,
bool overwrite)
{
node->AddProperty("visible", mitk::BoolProperty::New(true), renderer, overwrite);
// node->SetProperty("planarfigure.iseditable",mitk::BoolProperty::New(true));
node->AddProperty("planarfigure.isextendable", mitk::BoolProperty::New(false));
// node->AddProperty( "planarfigure.ishovering", mitk::BoolProperty::New(true) );
node->AddProperty("planarfigure.drawoutline", mitk::BoolProperty::New(false));
// node->AddProperty( "planarfigure.drawquantities", mitk::BoolProperty::New(true) );
node->AddProperty("planarfigure.drawshadow", mitk::BoolProperty::New(true));
node->AddProperty("planarfigure.drawcontrolpoints", mitk::BoolProperty::New(true));
node->AddProperty("planarfigure.drawname", mitk::BoolProperty::New(true));
node->AddProperty("planarfigure.drawdashed", mitk::BoolProperty::New(false));
node->AddProperty("planarfigure.helperline.drawdashed", mitk::BoolProperty::New(false));
node->AddProperty("planarfigure.annotations.font.family", mitk::StringProperty::New("Arial"));
node->AddProperty("planarfigure.annotations.font.bold", mitk::BoolProperty::New(false));
node->AddProperty("planarfigure.annotations.font.italic", mitk::BoolProperty::New(false));
node->AddProperty("planarfigure.annotations.font.size", mitk::IntProperty::New(12));
node->AddProperty("planarfigure.line.width", mitk::FloatProperty::New(2.0));
node->AddProperty("planarfigure.shadow.widthmodifier", mitk::FloatProperty::New(2.0));
node->AddProperty("planarfigure.outline.width", mitk::FloatProperty::New(2.0));
node->AddProperty("planarfigure.helperline.width", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.default.line.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.default.outline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.default.helperline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.default.markerline.color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
node->AddProperty("planarfigure.default.markerline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.default.marker.color", mitk::ColorProperty::New(1.0, 1.0, 1.0));
node->AddProperty("planarfigure.default.marker.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.hover.line.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
node->AddProperty("planarfigure.hover.line.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.hover.outline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
node->AddProperty("planarfigure.hover.outline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.hover.helperline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
node->AddProperty("planarfigure.hover.helperline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.hover.markerline.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
node->AddProperty("planarfigure.hover.markerline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.hover.marker.color", mitk::ColorProperty::New(0.0, 1.0, 0.0));
node->AddProperty("planarfigure.hover.marker.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.selected.line.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
node->AddProperty("planarfigure.selected.line.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.selected.outline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
node->AddProperty("planarfigure.selected.outline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.selected.helperline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
node->AddProperty("planarfigure.selected.helperline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.selected.markerline.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
node->AddProperty("planarfigure.selected.markerline.opacity", mitk::FloatProperty::New(1.0));
node->AddProperty("planarfigure.selected.marker.color", mitk::ColorProperty::New(1.0, 0.0, 0.0));
node->AddProperty("planarfigure.selected.marker.opacity", mitk::FloatProperty::New(1.0));
}
void mitk::PlanarFigureMapper2D::RenderControlPoints(const mitk::PlanarFigure *planarFigure,
const PlanarFigureDisplayMode lineDisplayMode,
const mitk::PlaneGeometry *planarFigurePlaneGeometry,
const mitk::PlaneGeometry *rendererPlaneGeometry,
mitk::BaseRenderer *renderer)
{
bool isEditable = true;
m_DataNode->GetBoolProperty("planarfigure.iseditable", isEditable);
PlanarFigureDisplayMode pointDisplayMode = PF_DEFAULT;
const auto selectedControlPointsIdx = (unsigned int)planarFigure->GetSelectedControlPoint();
const unsigned int numberOfControlPoints = planarFigure->GetNumberOfControlPoints();
// Draw markers at control points (selected control point will be colored)
for (unsigned int i = 0; i < numberOfControlPoints; ++i)
{
// Only if planar figure is marked as editable: display markers (control points) in a
// different style if mouse is over them or they are selected
if (isEditable)
{
if (i == selectedControlPointsIdx)
{
pointDisplayMode = PF_SELECTED;
}
else if (m_IsHovering && isEditable)
{
pointDisplayMode = PF_HOVER;
}
}
if (m_MarkerOpacity[pointDisplayMode] == 0 && m_MarkerlineOpacity[pointDisplayMode] == 0)
{
continue;
}
if (m_DrawOutline)
{
// draw outlines for markers as well
// linewidth for the contour is only half, as full width looks
// much too thick!
this->DrawMarker(planarFigure->GetControlPoint(i),
m_OutlineColor[lineDisplayMode],
m_MarkerlineOpacity[pointDisplayMode],
m_OutlineColor[lineDisplayMode],
m_MarkerOpacity[pointDisplayMode],
m_OutlineWidth / 2,
m_ControlPointShape,
planarFigurePlaneGeometry,
rendererPlaneGeometry,
renderer);
}
this->DrawMarker(planarFigure->GetControlPoint(i),
m_MarkerlineColor[pointDisplayMode],
m_MarkerlineOpacity[pointDisplayMode],
m_MarkerColor[pointDisplayMode],
m_MarkerOpacity[pointDisplayMode],
m_LineWidth,
m_ControlPointShape,
planarFigurePlaneGeometry,
rendererPlaneGeometry,
renderer);
}
if (planarFigure->IsPreviewControlPointVisible())
{
this->DrawMarker(planarFigure->GetPreviewControlPoint(),
m_MarkerlineColor[PF_HOVER],
m_MarkerlineOpacity[PF_HOVER],
m_MarkerColor[PF_HOVER],
m_MarkerOpacity[PF_HOVER],
m_LineWidth,
m_ControlPointShape,
planarFigurePlaneGeometry,
rendererPlaneGeometry,
renderer);
}
}
void mitk::PlanarFigureMapper2D::RenderAnnotations(mitk::BaseRenderer *,
const std::string name,
const mitk::Point2D anchorPoint,
float globalOpacity,
const PlanarFigureDisplayMode lineDisplayMode,
double &annotationOffset)
{
if (anchorPoint[0] < mitk::eps || anchorPoint[1] < mitk::eps)
{
return;
}
vtkTextProperty* textProp = vtkTextProperty::New();
textProp->SetFontSize(m_AnnotationSize);
textProp->SetFontFamilyAsString(m_AnnotationFontFamily.c_str());
textProp->SetJustificationToLeft();
textProp->SetOpacity(globalOpacity);
textProp->SetShadow(0);
textProp->SetBold(m_DrawAnnotationBold);
textProp->SetItalic(m_DrawAnnotationItalic);
mitk::Point2D offset;
offset.Fill(5);
mitk::Point2D scaledAnchorPoint;
scaledAnchorPoint[0] = anchorPoint[0] * m_DevicePixelRatio;
scaledAnchorPoint[1] = anchorPoint[1] * m_DevicePixelRatio;
offset[0] = offset[0] * m_DevicePixelRatio;
offset[1] = offset[1] * m_DevicePixelRatio;
if(m_DrawShadow)
{
textProp->SetColor(0.0,0.0,0.0);
this->m_Context->ApplyTextProp(textProp);
this->m_Context->DrawString(scaledAnchorPoint[0]+offset[0]+1, scaledAnchorPoint[1]+offset[1]-1, name.c_str());
}
textProp->SetColor(m_AnnotationColor[lineDisplayMode][0],
m_AnnotationColor[lineDisplayMode][1],
m_AnnotationColor[lineDisplayMode][2]);
this->m_Context->ApplyTextProp(textProp);
this->m_Context->DrawString(scaledAnchorPoint[0]+offset[0], scaledAnchorPoint[1]+offset[1], name.c_str());
annotationOffset -= 15.0;
// annotationOffset -= m_AnnotationAnnotation->GetBoundsOnDisplay( renderer ).Size[1];
textProp->Delete();
}
void mitk::PlanarFigureMapper2D::RenderQuantities(const mitk::PlanarFigure *planarFigure,
mitk::BaseRenderer *,
const mitk::Point2D anchorPoint,
double &annotationOffset,
float globalOpacity,
const PlanarFigureDisplayMode lineDisplayMode)
{
if (anchorPoint[0] < mitk::eps || anchorPoint[1] < mitk::eps)
{
return;
}
std::stringstream quantityString;
quantityString.setf(ios::fixed, ios::floatfield);
quantityString.precision(1);
bool firstActiveFeature = true;
for (unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i)
{
if (planarFigure->IsFeatureActive(i) && planarFigure->IsFeatureVisible(i))
{
if (!firstActiveFeature)
{
quantityString << " x ";
}
quantityString << planarFigure->GetQuantity(i) << " ";
quantityString << planarFigure->GetFeatureUnit(i);
firstActiveFeature = false;
}
}
vtkTextProperty* textProp = vtkTextProperty::New();
textProp->SetFontSize(m_AnnotationSize);
textProp->SetFontFamilyAsString(m_AnnotationFontFamily.c_str());
textProp->SetJustificationToLeft();
textProp->SetOpacity(globalOpacity);
textProp->SetShadow(0);
textProp->SetBold(m_DrawAnnotationBold);
textProp->SetItalic(m_DrawAnnotationItalic);
mitk::Point2D offset;
offset.Fill(5);
mitk::Point2D scaledAnchorPoint;
scaledAnchorPoint[0] = anchorPoint[0] * m_DevicePixelRatio;
scaledAnchorPoint[1] = anchorPoint[1] * m_DevicePixelRatio;
offset[0] = offset[0] * m_DevicePixelRatio;
offset[1] = offset[1] * m_DevicePixelRatio;
if(m_DrawShadow)
{
textProp->SetColor(0,0,0);
this->m_Context->ApplyTextProp(textProp);
this->m_Context->DrawString(scaledAnchorPoint[0]+offset[0]+1, scaledAnchorPoint[1]+offset[1]-1, quantityString.str().c_str());
}
textProp->SetColor(m_AnnotationColor[lineDisplayMode][0],
m_AnnotationColor[lineDisplayMode][1],
m_AnnotationColor[lineDisplayMode][2]);
this->m_Context->ApplyTextProp(textProp);
this->m_Context->DrawString(scaledAnchorPoint[0]+offset[0], scaledAnchorPoint[1]+offset[1], quantityString.str().c_str());
annotationOffset -= 15.0;
// annotationOffset -= m_AnnotationAnnotation->GetBoundsOnDisplay( renderer ).Size[1];
textProp->Delete();
}
void mitk::PlanarFigureMapper2D::RenderLines(const PlanarFigureDisplayMode lineDisplayMode,
mitk::PlanarFigure *planarFigure,
mitk::Point2D &anchorPoint,
const mitk::PlaneGeometry *planarFigurePlaneGeometry,
const mitk::PlaneGeometry *rendererPlaneGeometry,
const mitk::BaseRenderer *renderer)
{
// If we want to draw an outline, we do it here
if (m_DrawOutline)
{
const float *color = m_OutlineColor[lineDisplayMode];
const float opacity = m_OutlineOpacity[lineDisplayMode];
// set the color and opacity here as it is common for all outlines
this->m_Context->GetPen()->SetColorF((double)color[0], (double)color[1], (double)color[2], opacity);
this->m_Context->GetPen()->SetWidth(m_OutlineWidth);
if (m_DrawDashed)
this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
else
this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
// Draw the outline for all polylines if requested
this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
this->m_Context->GetPen()->SetWidth(m_HelperlineWidth);
if (m_DrawHelperDashed)
this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
else
this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
// Draw the outline for all helper objects if requested
this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
}
// If we want to draw a shadow, we do it here
if (m_DrawShadow)
{
// determine the shadow opacity
const float opacity = m_OutlineOpacity[lineDisplayMode];
float shadowOpacity = 0.0f;
if (opacity > 0.2f)
shadowOpacity = opacity - 0.2f;
// set the color and opacity here as it is common for all shadows
this->m_Context->GetPen()->SetColorF(0, 0, 0, shadowOpacity);
this->m_Context->GetPen()->SetWidth(m_OutlineWidth * m_ShadowWidthFactor);
if (m_DrawDashed)
this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
else
this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
// Draw the outline for all polylines if requested
this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
this->m_Context->GetPen()->SetWidth(m_HelperlineWidth);
if (m_DrawHelperDashed)
this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
else
this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
// Draw the outline for all helper objects if requested
this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
}
// set this in brackets to avoid duplicate variables in the same scope
{
const float *color = m_LineColor[lineDisplayMode];
const float opacity = m_LineOpacity[lineDisplayMode];
// set the color and opacity here as it is common for all mainlines
this->m_Context->GetPen()->SetColorF((double)color[0], (double)color[1], (double)color[2], (double)opacity);
this->m_Context->GetPen()->SetWidth(m_LineWidth);
if (m_DrawDashed)
this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
else
this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
// Draw the main line for all polylines
this->DrawMainLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
const float *helperColor = m_HelperlineColor[lineDisplayMode];
const float helperOpacity = m_HelperlineOpacity[lineDisplayMode];
// we only set the color for the helperlines as the linewidth is unchanged
this->m_Context->GetPen()->SetColorF((double)helperColor[0], (double)helperColor[1], (double)helperColor[2], (double)helperOpacity);
this->m_Context->GetPen()->SetWidth(m_HelperlineWidth);
if (m_DrawHelperDashed)
this->m_Context->GetPen()->SetLineType(vtkPen::DASH_LINE);
else
this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
// Draw helper objects
this->DrawHelperLines(planarFigure, anchorPoint, planarFigurePlaneGeometry, rendererPlaneGeometry, renderer);
}
if (m_DrawDashed || m_DrawHelperDashed)
this->m_Context->GetPen()->SetLineType(vtkPen::SOLID_LINE);
}
diff --git a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
index 2724e47848..103e6de46a 100644
--- a/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
+++ b/Modules/QtWidgets/include/QmitkMxNMultiWidget.h
@@ -1,136 +1,136 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef QmitkMxNMultiWidget_h
#define QmitkMxNMultiWidget_h
#include "MitkQtWidgetsExports.h"
// qt widgets module
#include "QmitkAbstractMultiWidget.h"
#include <QmitkSynchronizedNodeSelectionWidget.h>
#include <QmitkSynchronizedWidgetConnector.h>
#include <nlohmann/json.hpp>
class QSplitter;
/**
* @brief The 'QmitkMxNMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once.
* Render windows can dynamically be added and removed to change the layout of the multi widget. This
* is done by using the 'SetLayout'-function to define a layout. This will automatically add or remove
* the appropriate number of render window widgets.
*/
class MITKQTWIDGETS_EXPORT QmitkMxNMultiWidget : public QmitkAbstractMultiWidget
{
Q_OBJECT
public:
QmitkMxNMultiWidget(QWidget* parent = nullptr,
Qt::WindowFlags f = 0,
- const QString& multiWidgetName = "mxnmulti");
+ const QString& multiWidgetName = "mxn");
~QmitkMxNMultiWidget();
void InitializeMultiWidget() override;
void Synchronize(bool synchronized) override;
QmitkRenderWindow* GetRenderWindow(const QString& widgetName) const override;
QmitkRenderWindow* GetRenderWindow(const mitk::AnatomicalPlane& orientation) const override;
void SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget) override;
/**
* @brief Initialize the active render windows of the MxNMultiWidget to the given geometry.
*
* @param geometry The geometry to be used to initialize / update the
* active render window's time and slice navigation controller.
* @param resetCamera If true, the camera and crosshair will be reset to the default view (centered, no zoom).
* If false, the current crosshair position and the camera zoom will be stored and reset
* after the reference geometry has been updated.
*/
void InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera) override;
/**
* @brief Forward the given time geometry to all base renderers, so that they can store it as their
* interaction reference geometry.
* This will update the alignment status of the reference geometry for each base renderer.
* For more details, see 'BaseRenderer::SetInteractionReferenceGeometry'.
* Overridem from 'QmitkAbstractMultiWidget'.
*/
void SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry) override;
/**
* @brief Returns true if the render windows are coupled; false if not.
*
* For the MxNMultiWidget the render windows are typically decoupled.
*/
bool HasCoupledRenderWindows() const override;
void SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName) override;
const mitk::Point3D GetSelectedPosition(const QString& widgetName) const override;
void SetCrosshairVisibility(bool visible) override;
bool GetCrosshairVisibility() const override;
void SetCrosshairGap(unsigned int gapSize) override;
void ResetCrosshair() override;
void SetWidgetPlaneMode(int userMode) override;
mitk::SliceNavigationController* GetTimeNavigationController();
void EnableCrosshair();
void DisableCrosshair();
public Q_SLOTS:
// mouse events
void wheelEvent(QWheelEvent* e) override;
void mousePressEvent(QMouseEvent* e) override;
void moveEvent(QMoveEvent* e) override;
void LoadLayout(const nlohmann::json* jsonData);
void SaveLayout(std::ostream* outStream);
Q_SIGNALS:
void WheelMoved(QWheelEvent *);
void Moved();
void UpdateUtilityWidgetViewPlanes();
void LayoutChanged();
protected:
void RemoveRenderWindowWidget() override;
private:
void SetLayoutImpl() override;
void SetInteractionSchemeImpl() override { }
QmitkAbstractMultiWidget::RenderWindowWidgetPointer CreateRenderWindowWidget();
void SetInitialSelection();
void ToggleSynchronization(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget);
static nlohmann::json BuildJSONFromLayout(const QSplitter* splitter);
QSplitter* BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter = nullptr);
mitk::SliceNavigationController* m_TimeNavigationController;
std::unique_ptr<QmitkSynchronizedWidgetConnector> m_SynchronizedWidgetConnector;
bool m_CrosshairVisibility;
};
#endif
diff --git a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
index 3b2f599304..40ac5e11a1 100644
--- a/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
+++ b/Modules/QtWidgets/src/QmitkMxNMultiWidget.cpp
@@ -1,633 +1,633 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkMxNMultiWidget.h"
// mitk core
#include <mitkDisplayActionEventFunctions.h>
#include <mitkDisplayActionEventHandlerDesynchronized.h>
#include <mitkDisplayActionEventHandlerSynchronized.h>
#include <mitkNodePredicateNot.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateProperty.h>
// mitk qt widget
#include <QmitkRenderWindowUtilityWidget.h>
#include <QmitkRenderWindowWidget.h>
// qt
#include <QGridLayout>
#include <QMessageBox>
#include <QSplitter>
#include <fstream>
QmitkMxNMultiWidget::QmitkMxNMultiWidget(QWidget* parent,
Qt::WindowFlags f/* = 0*/,
- const QString& multiWidgetName/* = "mxnmulti"*/)
+ const QString& multiWidgetName/* = "mxn"*/)
: QmitkAbstractMultiWidget(parent, f, multiWidgetName)
, m_TimeNavigationController(nullptr)
, m_SynchronizedWidgetConnector(std::make_unique<QmitkSynchronizedWidgetConnector>())
, 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();
}
this->SetInitialSelection();
}
void QmitkMxNMultiWidget::Synchronize(bool synchronized)
{
if (synchronized)
{
SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerSynchronized>());
}
else
{
SetDisplayActionEventHandler(std::make_unique<mitk::DisplayActionEventHandlerDesynchronized>());
}
auto displayActionEventHandler = GetDisplayActionEventHandler();
if (nullptr != displayActionEventHandler)
{
displayActionEventHandler->InitActions();
}
}
QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const QString& widgetName) const
{
if ("axial" == widgetName || "sagittal" == widgetName || "coronal" == widgetName || "3d" == widgetName)
{
return GetActiveRenderWindowWidget()->GetRenderWindow();
}
return QmitkAbstractMultiWidget::GetRenderWindow(widgetName);
}
QmitkRenderWindow* QmitkMxNMultiWidget::GetRenderWindow(const mitk::AnatomicalPlane& /*orientation*/) const
{
// currently no mapping between plane orientation and render windows
// simply return the currently active render window
return GetActiveRenderWindowWidget()->GetRenderWindow();
}
void QmitkMxNMultiWidget::SetActiveRenderWindowWidget(RenderWindowWidgetPointer activeRenderWindowWidget)
{
auto currentActiveRenderWindowWidget = GetActiveRenderWindowWidget();
if (currentActiveRenderWindowWidget == activeRenderWindowWidget)
{
return;
}
// reset the decoration color of the previously active render window widget
if (nullptr != currentActiveRenderWindowWidget)
{
auto decorationColor = currentActiveRenderWindowWidget->GetDecorationColor();
QColor hexColor(decorationColor[0] * 255, decorationColor[1] * 255, decorationColor[2] * 255);
currentActiveRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid " +
hexColor.name(QColor::HexRgb) + "; }");
}
// set the new decoration color of the currently active render window widget
if (nullptr != activeRenderWindowWidget)
{
activeRenderWindowWidget->setStyleSheet("QmitkRenderWindowWidget { border: 2px solid #FF6464; }");
}
QmitkAbstractMultiWidget::SetActiveRenderWindowWidget(activeRenderWindowWidget);
}
void QmitkMxNMultiWidget::InitializeViews(const mitk::TimeGeometry* geometry, bool resetCamera)
{
auto* renderingManager = mitk::RenderingManager::GetInstance();
mitk::Point3D currentPosition = mitk::Point3D();
unsigned int imageTimeStep = 0;
if (!resetCamera)
{
// store the current position to set it again later, if the camera should not be reset
currentPosition = this->GetSelectedPosition("");
// store the current time step to set it again later, if the camera should not be reset
const auto currentTimePoint = renderingManager->GetTimeNavigationController()->GetSelectedTimePoint();
if (geometry->IsValidTimePoint(currentTimePoint))
{
imageTimeStep = geometry->TimePointToTimeStep(currentTimePoint);
}
}
// initialize active render window
renderingManager->InitializeView(
this->GetActiveRenderWindowWidget()->GetRenderWindow()->GetVtkRenderWindow(), geometry, resetCamera);
if (!resetCamera)
{
this->SetSelectedPosition(currentPosition, "");
renderingManager->GetTimeNavigationController()->GetTime()->SetPos(imageTimeStep);
}
}
void QmitkMxNMultiWidget::SetInteractionReferenceGeometry(const mitk::TimeGeometry* referenceGeometry)
{
// Set the interaction reference referenceGeometry for all render windows.
auto allRenderWindows = this->GetRenderWindows();
for (auto& renderWindow : allRenderWindows)
{
auto* baseRenderer = mitk::BaseRenderer::GetInstance(renderWindow->GetRenderWindow());
baseRenderer->SetInteractionReferenceGeometry(referenceGeometry);
}
}
bool QmitkMxNMultiWidget::HasCoupledRenderWindows() const
{
return false;
}
void QmitkMxNMultiWidget::SetSelectedPosition(const mitk::Point3D& newPosition, const QString& widgetName)
{
RenderWindowWidgetPointer renderWindowWidget;
if (widgetName.isNull() || widgetName.isEmpty())
{
renderWindowWidget = GetActiveRenderWindowWidget();
}
else
{
renderWindowWidget = GetRenderWindowWidget(widgetName);
}
if (nullptr != renderWindowWidget)
{
renderWindowWidget->GetSliceNavigationController()->SelectSliceByPoint(newPosition);
return;
}
MITK_ERROR << "Position can not be set for an unknown render window widget.";
}
const mitk::Point3D QmitkMxNMultiWidget::GetSelectedPosition(const QString& widgetName) const
{
RenderWindowWidgetPointer renderWindowWidget;
if (widgetName.isNull() || widgetName.isEmpty())
{
renderWindowWidget = GetActiveRenderWindowWidget();
}
else
{
renderWindowWidget = GetRenderWindowWidget(widgetName);
}
if (nullptr != renderWindowWidget)
{
return renderWindowWidget->GetCrosshairPosition();
}
MITK_ERROR << "Crosshair position can not be retrieved.";
return mitk::Point3D(0.0);
}
void QmitkMxNMultiWidget::SetCrosshairVisibility(bool visible)
{
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return;
}
auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
renderWindowWidget->SetCrosshairVisibility(visible);
}
bool QmitkMxNMultiWidget::GetCrosshairVisibility() const
{
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return false;
}
auto renderWindowWidget = this->GetRenderWindowWidget(renderWindow);
return renderWindowWidget->GetCrosshairVisibility();
}
void QmitkMxNMultiWidget::SetCrosshairGap(unsigned int gapSize)
{
auto renderWindowWidgets = this->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : renderWindowWidgets)
{
renderWindowWidget.second->SetCrosshairGap(gapSize);
}
}
void QmitkMxNMultiWidget::ResetCrosshair()
{
auto dataStorage = GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
// get the specific render window that sent the signal
QmitkRenderWindow* renderWindow = qobject_cast<QmitkRenderWindow*>(sender());
if (nullptr == renderWindow)
{
return;
}
mitk::RenderingManager::GetInstance()->InitializeViewByBoundingObjects(renderWindow->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::EnableCrosshair()
{
auto renderWindowWidgets = this->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : renderWindowWidgets)
{
renderWindowWidget.second->EnableCrosshair();
}
}
void QmitkMxNMultiWidget::DisableCrosshair()
{
auto renderWindowWidgets = this->GetRenderWindowWidgets();
for (const auto& renderWindowWidget : renderWindowWidgets)
{
renderWindowWidget.second->DisableCrosshair();
}
}
//////////////////////////////////////////////////////////////////////////
// PUBLIC SLOTS
// MOUSE EVENTS
//////////////////////////////////////////////////////////////////////////
void QmitkMxNMultiWidget::wheelEvent(QWheelEvent* e)
{
emit WheelMoved(e);
}
void QmitkMxNMultiWidget::mousePressEvent(QMouseEvent*)
{
// nothing here, but necessary for mouse interactions (.xml-configuration files)
}
void QmitkMxNMultiWidget::moveEvent(QMoveEvent* e)
{
QWidget::moveEvent(e);
// it is necessary to readjust the position of the overlays as the MultiWidget has moved
// unfortunately it's not done by QmitkRenderWindow::moveEvent -> must be done here
emit Moved();
}
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);
}
QmitkAbstractMultiWidget::RenderWindowWidgetPointer QmitkMxNMultiWidget::CreateRenderWindowWidget()
{
// create the render window widget and connect signal / slot
QString renderWindowWidgetName = GetNameFromIndex(GetNumberOfRenderWindowWidgets());
RenderWindowWidgetPointer renderWindowWidget = std::make_shared<QmitkRenderWindowWidget>(this, renderWindowWidgetName, GetDataStorage());
renderWindowWidget->SetCornerAnnotationText(renderWindowWidgetName.toStdString());
AddRenderWindowWidget(renderWindowWidgetName, renderWindowWidget);
auto renderWindow = renderWindowWidget->GetRenderWindow();
QmitkRenderWindowUtilityWidget* utilityWidget = new QmitkRenderWindowUtilityWidget(this, renderWindow, GetDataStorage());
renderWindowWidget->AddUtilityWidget(utilityWidget);
connect(utilityWidget, &QmitkRenderWindowUtilityWidget::SynchronizationToggled,
this, &QmitkMxNMultiWidget::ToggleSynchronization);
connect(this, &QmitkMxNMultiWidget::UpdateUtilityWidgetViewPlanes,
utilityWidget, &QmitkRenderWindowUtilityWidget::UpdateViewPlaneSelection);
// needs to be done after 'QmitkRenderWindowUtilityWidget::ToggleSynchronization' has been connected
// initially synchronize the node selection widget
utilityWidget->ToggleSynchronization(true);
auto layoutManager = GetMultiWidgetLayoutManager();
connect(renderWindow, &QmitkRenderWindow::LayoutDesignChanged, layoutManager, &QmitkMultiWidgetLayoutManager::SetLayoutDesign);
connect(renderWindow, &QmitkRenderWindow::ResetView, this, &QmitkMxNMultiWidget::ResetCrosshair);
connect(renderWindow, &QmitkRenderWindow::CrosshairVisibilityChanged, this, &QmitkMxNMultiWidget::SetCrosshairVisibility);
connect(renderWindow, &QmitkRenderWindow::CrosshairRotationModeChanged, this, &QmitkMxNMultiWidget::SetWidgetPlaneMode);
// connect time navigation controller to react on referenceGeometry 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);
return renderWindowWidget;
}
void QmitkMxNMultiWidget::LoadLayout(const nlohmann::json* jsonData)
{
if ((*jsonData).is_null())
{
QMessageBox::warning(this, "Load layout", "Could not read window layout");
return;
}
unsigned int windowCounter = 0;
try
{
auto version = jsonData->at("version").get<std::string>();
if (version != "1.0")
{
QMessageBox::warning(this, "Load layout", "Unknown layout version, could not load");
return;
}
delete this->layout();
auto content = BuildLayoutFromJSON(jsonData, &windowCounter);
auto hBoxLayout = new QHBoxLayout(this);
this->setLayout(hBoxLayout);
hBoxLayout->addWidget(content);
emit UpdateUtilityWidgetViewPlanes();
}
catch (nlohmann::json::out_of_range& e)
{
MITK_ERROR << "Error in loading window layout from JSON: " << e.what();
return;
}
while (GetNumberOfRenderWindowWidgets() > windowCounter)
{
RemoveRenderWindowWidget();
}
EnableCrosshair();
emit LayoutChanged();
}
void QmitkMxNMultiWidget::SaveLayout(std::ostream* outStream)
{
if (outStream == nullptr)
{
return;
}
auto layout = this->layout();
if (layout == nullptr)
return;
// There should only ever be one item: a splitter
auto widget = layout->itemAt(0)->widget();
auto splitter = dynamic_cast<QSplitter*>(widget);
if (!splitter)
{
MITK_ERROR << "Tried to save unexpected layout format. Make sure the layout of this instance contains a single QSplitter.";
return;
}
auto layoutJSON = BuildJSONFromLayout(splitter);
layoutJSON["version"] = "1.0";
layoutJSON["name"] = "Custom Layout";
*outStream << std::setw(4) << layoutJSON << std::endl;
}
nlohmann::json QmitkMxNMultiWidget::BuildJSONFromLayout(const QSplitter* splitter)
{
nlohmann::json resultJSON;
resultJSON["isWindow"] = false;
resultJSON["vertical"] = (splitter->orientation() == Qt::Vertical) ? true : false;
auto sizes = splitter->sizes();
auto content = nlohmann::json::array();
auto countSplitter = splitter->count();
for (int i = 0; i < countSplitter; ++i)
{
auto widget = splitter->widget(i);
nlohmann::json widgetJSON;
if (auto widgetSplitter = dynamic_cast<QSplitter*>(widget); widgetSplitter)
{
widgetJSON = BuildJSONFromLayout(widgetSplitter);
}
else if (auto widgetWindow = dynamic_cast<QmitkRenderWindowWidget*>(widget); widgetWindow)
{
widgetJSON["isWindow"] = true;
widgetJSON["viewDirection"] = widgetWindow->GetSliceNavigationController()->GetViewDirectionAsString();
}
widgetJSON["size"] = sizes[i];
content.push_back(widgetJSON);
}
resultJSON["content"] = content;
return resultJSON;
}
QSplitter* QmitkMxNMultiWidget::BuildLayoutFromJSON(const nlohmann::json* jsonData, unsigned int* windowCounter, QSplitter* parentSplitter)
{
bool vertical = jsonData->at("vertical").get<bool>();
auto orientation = vertical ? Qt::Vertical : Qt::Horizontal;
auto split = new QSplitter(orientation, parentSplitter);
QList<int> sizes;
for (auto object : jsonData->at("content"))
{
bool isWindow = object["isWindow"].get<bool>();
int size = object["size"].get<int>();
sizes.append(size);
if (isWindow)
{
auto viewDirection = object["viewDirection"].get<std::string>();
mitk::AnatomicalPlane viewPlane = mitk::AnatomicalPlane::Sagittal;
if (viewDirection == "Axial")
{
viewPlane = mitk::AnatomicalPlane::Axial;
}
else if (viewDirection == "Coronal")
{
viewPlane = mitk::AnatomicalPlane::Coronal;
}
else if (viewDirection == "Original")
{
viewPlane = mitk::AnatomicalPlane::Original;
}
else if (viewDirection == "Sagittal")
{
viewPlane = mitk::AnatomicalPlane::Sagittal;
}
QmitkAbstractMultiWidget::RenderWindowWidgetPointer window = nullptr;
QString renderWindowName;
QmitkAbstractMultiWidget::RenderWindowWidgetMap::iterator it;
// repurpose existing render windows as far as they already exist
if (*windowCounter < GetRenderWindowWidgets().size())
{
renderWindowName = this->GetNameFromIndex(*windowCounter);
auto renderWindowWidgets = GetRenderWindowWidgets();
it = renderWindowWidgets.find(renderWindowName);
if (it != renderWindowWidgets.end())
{
window = it->second;
}
else
{
MITK_ERROR << "Could not find render window " << renderWindowName.toStdString() << ", although it should be there.";
}
}
if (window == nullptr)
{
window = CreateRenderWindowWidget();
}
window->GetSliceNavigationController()->SetDefaultViewDirection(viewPlane);
window->GetSliceNavigationController()->Update();
split->addWidget(window.get());
window->show();
(*windowCounter)++;
}
else
{
auto subSplitter = BuildLayoutFromJSON(&object, windowCounter, split);
split->addWidget(subSplitter);
}
}
split->setSizes(sizes);
return split;
}
void QmitkMxNMultiWidget::SetInitialSelection()
{
auto dataStorage = this->GetDataStorage();
if (nullptr == dataStorage)
{
return;
}
mitk::NodePredicateAnd::Pointer noHelperObjects = mitk::NodePredicateAnd::New();
noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
noHelperObjects->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("hidden object")));
auto allNodes = dataStorage->GetSubset(noHelperObjects);
QmitkSynchronizedNodeSelectionWidget::NodeList currentSelection;
for (auto& node : *allNodes)
{
currentSelection.append(node);
}
m_SynchronizedWidgetConnector->ChangeSelection(currentSelection);
}
void QmitkMxNMultiWidget::ToggleSynchronization(QmitkSynchronizedNodeSelectionWidget* synchronizedWidget)
{
bool synchronized = synchronizedWidget->IsSynchronized();
if (synchronized)
{
m_SynchronizedWidgetConnector->ConnectWidget(synchronizedWidget);
m_SynchronizedWidgetConnector->SynchronizeWidget(synchronizedWidget);
}
else
{
m_SynchronizedWidgetConnector->DisconnectWidget(synchronizedWidget);
}
}
diff --git a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
index 59772bcbac..fee5a07e50 100644
--- a/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
+++ b/Plugins/org.mitk.gui.qt.mxnmultiwidgeteditor/src/QmitkMxNMultiWidgetEditor.cpp
@@ -1,244 +1,244 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "QmitkMxNMultiWidgetEditor.h"
#include <mitkCoreServices.h>
#include <mitkIPreferencesService.h>
#include <mitkIPreferences.h>
#include <berryIWorkbenchPage.h>
#include <berryIWorkbenchPartConstants.h>
#include <berryUIException.h>
// mxn multi widget editor plugin
#include "QmitkMultiWidgetDecorationManager.h"
// mitk qt widgets module
#include <QmitkMxNMultiWidget.h>
#include <QmitkInteractionSchemeToolBar.h>
#include <QmitkMultiWidgetConfigurationToolBar.h>
// qt
#include <QHBoxLayout>
const QString QmitkMxNMultiWidgetEditor::EDITOR_ID = "org.mitk.editors.mxnmultiwidget";
struct QmitkMxNMultiWidgetEditor::Impl final
{
Impl();
~Impl() = default;
QmitkInteractionSchemeToolBar* m_InteractionSchemeToolBar;
QmitkMultiWidgetConfigurationToolBar* m_ConfigurationToolBar;
};
QmitkMxNMultiWidgetEditor::Impl::Impl()
: m_InteractionSchemeToolBar(nullptr)
, m_ConfigurationToolBar(nullptr)
{
// nothing here
}
//////////////////////////////////////////////////////////////////////////
// QmitkMxNMultiWidgetEditor
//////////////////////////////////////////////////////////////////////////
QmitkMxNMultiWidgetEditor::QmitkMxNMultiWidgetEditor()
: QmitkAbstractMultiWidgetEditor()
, m_Impl(std::make_unique<Impl>())
{
// nothing here
}
QmitkMxNMultiWidgetEditor::~QmitkMxNMultiWidgetEditor()
{
GetSite()->GetPage()->RemovePartListener(this);
}
berry::IPartListener::Events::Types QmitkMxNMultiWidgetEditor::GetPartEventTypes() const
{
return Events::CLOSED | Events::OPENED | Events::HIDDEN | Events::VISIBLE;
}
void QmitkMxNMultiWidgetEditor::PartClosed(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->ActivateMenuWidget(false);
}
}
}
void QmitkMxNMultiWidgetEditor::PartOpened(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->EnableCrosshair();
multiWidget->ActivateMenuWidget(true);
}
}
}
void QmitkMxNMultiWidgetEditor::PartHidden(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->ActivateMenuWidget(false);
}
}
}
void QmitkMxNMultiWidgetEditor::PartVisible(const berry::IWorkbenchPartReference::Pointer& partRef)
{
if (partRef->GetId() == QmitkMxNMultiWidgetEditor::EDITOR_ID)
{
const auto& multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
multiWidget->ActivateMenuWidget(true);
}
}
}
void QmitkMxNMultiWidgetEditor::OnLayoutSet(int row, int column)
{
const auto &multiWidget = dynamic_cast<QmitkMxNMultiWidget*>(GetMultiWidget());
if (nullptr != multiWidget)
{
QmitkAbstractMultiWidgetEditor::OnLayoutSet(row, column);
multiWidget->EnableCrosshair();
}
}
void QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged(mitk::InteractionSchemeSwitcher::InteractionScheme scheme)
{
const auto &multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return;
}
if (mitk::InteractionSchemeSwitcher::PACSStandard == scheme)
{
m_Impl->m_InteractionSchemeToolBar->setVisible(true);
}
else
{
m_Impl->m_InteractionSchemeToolBar->setVisible(false);
}
QmitkAbstractMultiWidgetEditor::OnInteractionSchemeChanged(scheme);
}
//////////////////////////////////////////////////////////////////////////
// PRIVATE
//////////////////////////////////////////////////////////////////////////
void QmitkMxNMultiWidgetEditor::SetFocus()
{
const auto& multiWidget = GetMultiWidget();
if (nullptr != multiWidget)
{
multiWidget->setFocus();
}
}
void QmitkMxNMultiWidgetEditor::CreateQtPartControl(QWidget* parent)
{
QHBoxLayout *layout = new QHBoxLayout(parent);
layout->setContentsMargins(0, 0, 0, 0);
auto* preferences = this->GetPreferences();
auto multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
- multiWidget = new QmitkMxNMultiWidget(parent, 0, nullptr);
+ multiWidget = new QmitkMxNMultiWidget(parent);
// create left toolbar: interaction scheme toolbar to switch how the render window navigation behaves in PACS mode
if (nullptr == m_Impl->m_InteractionSchemeToolBar)
{
m_Impl->m_InteractionSchemeToolBar = new QmitkInteractionSchemeToolBar(parent);
layout->addWidget(m_Impl->m_InteractionSchemeToolBar);
}
m_Impl->m_InteractionSchemeToolBar->SetInteractionEventHandler(multiWidget->GetInteractionEventHandler());
multiWidget->SetDataStorage(GetDataStorage());
multiWidget->InitializeMultiWidget();
SetMultiWidget(multiWidget);
connect(static_cast<QmitkMxNMultiWidget*>(multiWidget), &QmitkMxNMultiWidget::LayoutChanged,
this, &QmitkMxNMultiWidgetEditor::OnLayoutChanged);
}
layout->addWidget(multiWidget);
// create right toolbar: configuration toolbar to change the render window widget layout
if (nullptr == m_Impl->m_ConfigurationToolBar)
{
m_Impl->m_ConfigurationToolBar = new QmitkMultiWidgetConfigurationToolBar(multiWidget);
layout->addWidget(m_Impl->m_ConfigurationToolBar);
}
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LayoutSet,
this, &QmitkMxNMultiWidgetEditor::OnLayoutSet);
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::Synchronized,
this, &QmitkMxNMultiWidgetEditor::OnSynchronize);
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::InteractionSchemeChanged,
this, &QmitkMxNMultiWidgetEditor::OnInteractionSchemeChanged);
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::SaveLayout,
static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::SaveLayout, Qt::DirectConnection);
connect(m_Impl->m_ConfigurationToolBar, &QmitkMultiWidgetConfigurationToolBar::LoadLayout,
static_cast<QmitkMxNMultiWidget*>(GetMultiWidget()), &QmitkMxNMultiWidget::LoadLayout);
GetSite()->GetPage()->AddPartListener(this);
OnPreferencesChanged(preferences);
}
void QmitkMxNMultiWidgetEditor::OnPreferencesChanged(const mitk::IPreferences* preferences)
{
const auto& multiWidget = GetMultiWidget();
if (nullptr == multiWidget)
{
return;
}
// update decoration preferences
//m_Impl->m_MultiWidgetDecorationManager->DecorationPreferencesChanged(preferences);
int crosshairGapSize = preferences->GetInt("crosshair gap size", 32);
multiWidget->SetCrosshairGap(crosshairGapSize);
// zooming and panning preferences
bool constrainedZooming = preferences->GetBool("Use constrained zooming and panning", true);
mitk::RenderingManager::GetInstance()->SetConstrainedPanningZooming(constrainedZooming);
bool PACSInteractionScheme = preferences->GetBool("PACS like mouse interaction", false);
OnInteractionSchemeChanged(PACSInteractionScheme ?
mitk::InteractionSchemeSwitcher::PACSStandard :
mitk::InteractionSchemeSwitcher::MITKStandard);
mitk::RenderingManager::GetInstance()->RequestUpdateAll();
}
void QmitkMxNMultiWidgetEditor::OnLayoutChanged()
{
FirePropertyChange(berry::IWorkbenchPartConstants::PROP_INPUT);
}