diff --git a/Modules/PlanarFigure/include/mitkPlanarFigureInteractor.h b/Modules/PlanarFigure/include/mitkPlanarFigureInteractor.h
index 6a22193017..63a3f33642 100644
--- a/Modules/PlanarFigure/include/mitkPlanarFigureInteractor.h
+++ b/Modules/PlanarFigure/include/mitkPlanarFigureInteractor.h
@@ -1,197 +1,198 @@
/*============================================================================
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 MITKPLANARFIGUREINTERACTOR_H
#define MITKPLANARFIGUREINTERACTOR_H
#include <MitkPlanarFigureExports.h>
#include "mitkCommon.h"
#include "mitkDataInteractor.h"
#include "mitkNumericTypes.h"
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
namespace mitk
{
class DataNode;
class PlaneGeometry;
class PlanarFigure;
class PositionEvent;
class BaseRenderer;
class InteractionPositionEvent;
class StateMachineAction;
#pragma GCC visibility push(default)
// Define events for PlanarFigure interaction notifications
itkEventMacro(PlanarFigureEvent, itk::AnyEvent);
itkEventMacro(StartPlacementPlanarFigureEvent, PlanarFigureEvent);
itkEventMacro(EndPlacementPlanarFigureEvent, PlanarFigureEvent);
itkEventMacro(SelectPlanarFigureEvent, PlanarFigureEvent);
itkEventMacro(StartInteractionPlanarFigureEvent, PlanarFigureEvent);
itkEventMacro(EndInteractionPlanarFigureEvent, PlanarFigureEvent);
itkEventMacro(StartHoverPlanarFigureEvent, PlanarFigureEvent);
itkEventMacro(EndHoverPlanarFigureEvent, PlanarFigureEvent);
itkEventMacro(ContextMenuPlanarFigureEvent, PlanarFigureEvent);
+ itkEventMacro(PointMovedPlanarFigureEvent, PlanarFigureEvent);
#pragma GCC visibility pop
/**
* \brief Interaction with mitk::PlanarFigure objects via control-points
*
* @ingroup MitkPlanarFigureModule
*/
class MITKPLANARFIGURE_EXPORT PlanarFigureInteractor : public DataInteractor
{
public:
mitkClassMacro(PlanarFigureInteractor, DataInteractor);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/** \brief Sets the amount of precision */
void SetPrecision(ScalarType precision);
/** \brief Sets the minimal distance between two control points. */
void SetMinimumPointDistance(ScalarType minimumDistance);
protected:
PlanarFigureInteractor();
~PlanarFigureInteractor() override;
void ConnectActionsAndFunctions() override;
//////// Conditions ////////
bool CheckFigurePlaced(const InteractionEvent *interactionEvent);
bool CheckFigureHovering(const InteractionEvent *interactionEvent);
bool CheckControlPointHovering(const InteractionEvent *interactionEvent);
bool CheckSelection(const InteractionEvent *interactionEvent);
bool CheckPointValidity(const InteractionEvent *interactionEvent);
bool CheckFigureFinished(const InteractionEvent *interactionEvent);
bool CheckResetOnPointSelect(const InteractionEvent *interactionEvent);
bool CheckFigureOnRenderingGeometry(const InteractionEvent *interactionEvent);
bool CheckMinimalFigureFinished(const InteractionEvent *interactionEvent);
bool CheckFigureIsExtendable(const InteractionEvent *interactionEvent);
bool CheckFigureIsDeletable(const InteractionEvent *interactionEvent);
bool CheckFigureIsEditable(const InteractionEvent *interactionEvent);
//////// Actions ////////
void FinalizeFigure(StateMachineAction *, InteractionEvent *interactionEvent);
void MoveCurrentPoint(StateMachineAction *, InteractionEvent *interactionEvent);
void DeselectPoint(StateMachineAction *, InteractionEvent *interactionEvent);
void AddPoint(StateMachineAction *, InteractionEvent *interactionEvent);
void AddInitialPoint(StateMachineAction *, InteractionEvent *interactionEvent);
void StartHovering(StateMachineAction *, InteractionEvent *interactionEvent);
void EndHovering(StateMachineAction *, InteractionEvent *interactionEvent);
void DeleteFigure(StateMachineAction *, InteractionEvent *interactionEvent);
void PerformPointResetOnSelect(StateMachineAction *, InteractionEvent *interactionEvent);
void SetPreviewPointPosition(StateMachineAction *, InteractionEvent *interactionEvent);
void HidePreviewPoint(StateMachineAction *, InteractionEvent *interactionEvent);
void HideControlPoints(StateMachineAction *, InteractionEvent *interactionEvent);
void RemoveSelectedPoint(StateMachineAction *, InteractionEvent *interactionEvent);
void RequestContextMenu(StateMachineAction *, InteractionEvent *interactionEvent);
void SelectFigure(StateMachineAction *, InteractionEvent *interactionEvent);
void SelectPoint(StateMachineAction *, InteractionEvent *interactionEvent);
void EndInteraction(StateMachineAction *, InteractionEvent *interactionEvent);
bool FilterEvents(InteractionEvent *interactionEvent, DataNode *) override;
/**
\brief Used when clicking to determine if a point is too close to the previous point.
*/
bool IsMousePositionAcceptableAsNewControlPoint(const mitk::InteractionPositionEvent *positionEvent,
const PlanarFigure *);
bool TransformPositionEventToPoint2D(const InteractionPositionEvent *positionEvent,
const PlaneGeometry *planarFigureGeometry,
Point2D &point2D);
bool TransformObjectToDisplay(const mitk::Point2D &point2D,
mitk::Point2D &displayPoint,
const mitk::PlaneGeometry *objectGeometry,
const mitk::PlaneGeometry *rendererGeometry,
const mitk::BaseRenderer *renderer) const;
/** \brief Returns true if the first specified point is in proximity of the line defined
* the other two point; false otherwise.
*
* Proximity is defined as the rectangle around the line with pre-defined distance
* from the line. */
bool IsPointNearLine(const mitk::Point2D &point,
const mitk::Point2D &startPoint,
const mitk::Point2D &endPoint,
mitk::Point2D &projectedPoint) const;
/** \brief Returns true if the point contained in the passed event (in display coordinates)
* is over the planar figure (with a pre-defined tolerance range); false otherwise. */
int IsPositionOverFigure(const InteractionPositionEvent *positionEvent,
PlanarFigure *planarFigure,
const PlaneGeometry *planarFigureGeometry,
const PlaneGeometry *rendererGeometry,
Point2D &pointProjectedOntoLine) const;
/** \brief Returns the index of the marker (control point) over which the point contained
* in the passed event (in display coordinates) currently is; -1 if the point is not over
* a marker. */
int IsPositionInsideMarker(const InteractionPositionEvent *positionEvent,
const PlanarFigure *planarFigure,
const PlaneGeometry *planarFigureGeometry,
const PlaneGeometry *rendererGeometry,
const BaseRenderer *renderer) const;
void LogPrintPlanarFigureQuantities(const PlanarFigure *planarFigure);
void ConfigurationChanged() override;
private:
/** \brief to store the value of precision to pick a point */
ScalarType m_Precision;
/** \brief Store the minimal distance between two control points. */
ScalarType m_MinimumPointDistance;
/** \brief True if the mouse is currently hovering over the image. */
bool m_IsHovering;
};
}
#endif // MITKPLANARFIGUREINTERACTOR_H
diff --git a/Modules/PlanarFigure/src/Interactions/mitkPlanarFigureInteractor.cpp b/Modules/PlanarFigure/src/Interactions/mitkPlanarFigureInteractor.cpp
index 363c3ef628..706ac0b24b 100644
--- a/Modules/PlanarFigure/src/Interactions/mitkPlanarFigureInteractor.cpp
+++ b/Modules/PlanarFigure/src/Interactions/mitkPlanarFigureInteractor.cpp
@@ -1,1113 +1,1115 @@
/*============================================================================
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 PLANARFIGUREINTERACTOR_DBG MITK_DEBUG("PlanarFigureInteractor") << __LINE__ << ": "
#include "mitkPlanarFigureInteractor.h"
#include "mitkPlanarBezierCurve.h"
#include "mitkPlanarCircle.h"
#include "mitkPlanarFigure.h"
#include "mitkPlanarPolygon.h"
#include "mitkInteractionPositionEvent.h"
#include "mitkInternalEvent.h"
#include "mitkBaseRenderer.h"
#include "mitkRenderingManager.h"
#include "mitkAbstractTransformGeometry.h"
#include "mitkPlaneGeometry.h"
mitk::PlanarFigureInteractor::PlanarFigureInteractor()
: DataInteractor()
, m_Precision(6.5)
, m_MinimumPointDistance(25.0)
, m_IsHovering(false)
{
}
mitk::PlanarFigureInteractor::~PlanarFigureInteractor()
{
}
void mitk::PlanarFigureInteractor::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("figure_is_on_current_slice", CheckFigureOnRenderingGeometry);
CONNECT_CONDITION("figure_is_placed", CheckFigurePlaced);
CONNECT_CONDITION("minimal_figure_is_finished", CheckMinimalFigureFinished);
CONNECT_CONDITION("hovering_above_figure", CheckFigureHovering);
CONNECT_CONDITION("hovering_above_point", CheckControlPointHovering);
CONNECT_CONDITION("figure_is_selected", CheckSelection);
CONNECT_CONDITION("point_is_valid", CheckPointValidity);
CONNECT_CONDITION("figure_is_finished", CheckFigureFinished);
CONNECT_CONDITION("reset_on_point_select_needed", CheckResetOnPointSelect);
CONNECT_CONDITION("points_can_be_added_or_removed", CheckFigureIsExtendable);
CONNECT_CONDITION("figure_can_be_deleted", CheckFigureIsDeletable);
CONNECT_CONDITION("figure_is_editable", CheckFigureIsEditable);
CONNECT_FUNCTION("finalize_figure", FinalizeFigure);
CONNECT_FUNCTION("hide_preview_point", HidePreviewPoint)
CONNECT_FUNCTION("hide_control_points", HideControlPoints)
CONNECT_FUNCTION("set_preview_point_position", SetPreviewPointPosition)
CONNECT_FUNCTION("move_current_point", MoveCurrentPoint);
CONNECT_FUNCTION("deselect_point", DeselectPoint);
CONNECT_FUNCTION("add_new_point", AddPoint);
CONNECT_FUNCTION("add_initial_point", AddInitialPoint);
CONNECT_FUNCTION("remove_selected_point", RemoveSelectedPoint);
CONNECT_FUNCTION("request_context_menu", RequestContextMenu);
CONNECT_FUNCTION("select_figure", SelectFigure);
CONNECT_FUNCTION("select_point", SelectPoint);
CONNECT_FUNCTION("end_interaction", EndInteraction);
CONNECT_FUNCTION("start_hovering", StartHovering)
CONNECT_FUNCTION("end_hovering", EndHovering);
CONNECT_FUNCTION("delete_figure", DeleteFigure);
CONNECT_FUNCTION("reset_on_point_select", PerformPointResetOnSelect);
}
bool mitk::PlanarFigureInteractor::CheckFigurePlaced(const InteractionEvent * /*interactionEvent*/)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return false;
}
bool isFigureFinished = false;
planarFigure->GetPropertyList()->GetBoolProperty("initiallyplaced", isFigureFinished);
return planarFigure->IsPlaced() && isFigureFinished;
}
void mitk::PlanarFigureInteractor::MoveCurrentPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
bool isEditable = true;
GetDataNode()->GetBoolProperty("planarfigure.iseditable", isEditable);
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
auto planarFigureGeometry = planarFigure->GetPlaneGeometry();
if (nullptr == planarFigureGeometry)
{
return;
}
auto abstractTransformGeometry = dynamic_cast<AbstractTransformGeometry*>(planarFigure->GetGeometry(0));
if (nullptr != abstractTransformGeometry)
{
return;
}
// Extract point in 2D world coordinates (relative to PlaneGeometry of PlanarFigure)
Point2D point2D;
if (!this->TransformPositionEventToPoint2D(positionEvent, planarFigureGeometry, point2D) || !isEditable)
{
return;
}
planarFigure->InvokeEvent(StartInteractionPlanarFigureEvent());
// check if the control points shall be hidden during interaction
bool hidecontrolpointsduringinteraction = false;
GetDataNode()->GetBoolProperty("planarfigure.hidecontrolpointsduringinteraction", hidecontrolpointsduringinteraction);
// hide the control points if necessary
// interactionEvent->GetSender()->GetDataStorage()->BlockNodeModifiedEvents( true );
GetDataNode()->SetBoolProperty("planarfigure.drawcontrolpoints", !hidecontrolpointsduringinteraction);
// interactionEvent->GetSender()->GetDataStorage()->BlockNodeModifiedEvents( false );
// Move current control point to this point
planarFigure->SetCurrentControlPoint(point2D);
// Re-evaluate features
planarFigure->EvaluateFeatures();
// Update rendered scene
RenderingManager::GetInstance()->RequestUpdateAll();
+
+ planarFigure->InvokeEvent(PointMovedPlanarFigureEvent());
}
void mitk::PlanarFigureInteractor::FinalizeFigure(StateMachineAction *, InteractionEvent *)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
planarFigure->Modified();
planarFigure->DeselectControlPoint();
planarFigure->RemoveLastControlPoint();
planarFigure->SetProperty("initiallyplaced", mitk::BoolProperty::New(true));
GetDataNode()->SetBoolProperty("planarfigure.drawcontrolpoints", true);
GetDataNode()->Modified();
planarFigure->InvokeEvent(EndPlacementPlanarFigureEvent());
planarFigure->InvokeEvent(EndInteractionPlanarFigureEvent());
// Shape might change when figure is finalized, e.g., smoothing of subdivision polygon
planarFigure->EvaluateFeatures();
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PlanarFigureInteractor::EndInteraction(StateMachineAction *, InteractionEvent *)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
GetDataNode()->SetBoolProperty("planarfigure.drawcontrolpoints", true);
planarFigure->Modified();
planarFigure->InvokeEvent(EndInteractionPlanarFigureEvent());
RenderingManager::GetInstance()->RequestUpdateAll();
}
bool mitk::PlanarFigureInteractor::FilterEvents(InteractionEvent *interactionEvent, mitk::DataNode * /*dataNode*/)
{
if (interactionEvent->GetSender() == nullptr)
return false;
if (interactionEvent->GetSender()->GetMapperID() == BaseRenderer::Standard3D)
return false;
return true;
}
void mitk::PlanarFigureInteractor::EndHovering(StateMachineAction *, InteractionEvent *)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
planarFigure->ResetPreviewContolPoint();
// Invoke end-hover event once the mouse is exiting the figure area
m_IsHovering = false;
planarFigure->InvokeEvent(EndHoverPlanarFigureEvent());
// Set bool property to indicate that planar figure is no longer in "hovering" mode
GetDataNode()->SetBoolProperty("planarfigure.ishovering", false);
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PlanarFigureInteractor::DeleteFigure(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
planarFigure->RemoveAllObservers();
GetDataNode()->RemoveAllObservers();
interactionEvent->GetSender()->GetDataStorage()->Remove(GetDataNode());
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PlanarFigureInteractor::PerformPointResetOnSelect(StateMachineAction *, InteractionEvent *)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
planarFigure->ResetOnPointSelect();
}
bool mitk::PlanarFigureInteractor::CheckMinimalFigureFinished(const InteractionEvent * /*interactionEvent*/)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return false;
}
return planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMinimumNumberOfControlPoints();
}
bool mitk::PlanarFigureInteractor::CheckFigureFinished(const InteractionEvent * /*interactionEvent*/)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return false;
}
return planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints();
}
bool mitk::PlanarFigureInteractor::CheckFigureIsExtendable(const InteractionEvent * /*interactionEvent*/)
{
bool isExtendable(false);
GetDataNode()->GetBoolProperty("planarfigure.isextendable", isExtendable);
return isExtendable;
}
bool mitk::PlanarFigureInteractor::CheckFigureIsDeletable(const InteractionEvent * /*interactionEvent*/)
{
bool isDeletable(true);
GetDataNode()->GetBoolProperty("planarfigure.isdeletable", isDeletable);
return isDeletable;
}
bool mitk::PlanarFigureInteractor::CheckFigureIsEditable(const InteractionEvent * /*interactionEvent*/)
{
bool isEditable(true);
GetDataNode()->GetBoolProperty("planarfigure.iseditable", isEditable);
return isEditable;
}
void mitk::PlanarFigureInteractor::DeselectPoint(StateMachineAction *, InteractionEvent * /*interactionEvent*/)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
const bool wasSelected = planarFigure->DeselectControlPoint();
if (wasSelected)
{
// Issue event so that listeners may update themselves
planarFigure->Modified();
planarFigure->InvokeEvent(EndInteractionPlanarFigureEvent());
GetDataNode()->SetBoolProperty("planarfigure.drawcontrolpoints", true);
GetDataNode()->Modified();
}
}
void mitk::PlanarFigureInteractor::AddPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
/*
* Added check for "initiallyplaced" due to bug 13097:
*
* There are two possible cases in which a point can be inserted into a PlanarPolygon:
*
* 1. The figure is currently drawn -> the point will be appended at the end of the figure
* 2. A point is inserted at a userdefined position after the initial placement of the figure is finished
*
* In the second case we need to determine the proper insertion index. In the first case the index always has
* to be -1 so that the point is appended to the end.
*
* These changes are necessary because of a macOS specific issue: If a users draws a PlanarPolygon then the
* next point to be added moves according to the mouse position. If then the user left clicks in order to add
* a point one would assume the last move position is identical to the left click position. This is actually the
* case for windows and linux but somehow NOT for mac. Because of the insertion logic of a new point in the
* PlanarFigure then for mac the wrong current selected point is determined.
*
* With this check here this problem can be avoided. However a redesign of the insertion logic should be considered
*/
const DataNode::Pointer node = this->GetDataNode();
const BaseData::Pointer data = node->GetData();
bool isFigureFinished = false;
data->GetPropertyList()->GetBoolProperty("initiallyplaced", isFigureFinished);
bool selected = false;
bool isEditable = true;
node->GetBoolProperty("selected", selected);
node->GetBoolProperty("planarfigure.iseditable", isEditable);
if (!selected || !isEditable)
{
return;
}
auto planarFigure = dynamic_cast<PlanarFigure*>(data.GetPointer());
if (nullptr == planarFigure)
{
return;
}
// We can't derive a new control point from a polyline of a Bezier curve
// as all control points contribute to each polyline point.
if (dynamic_cast<PlanarBezierCurve *>(planarFigure) != nullptr && isFigureFinished)
return;
auto planarFigureGeometry = planarFigure->GetPlaneGeometry();
if (nullptr == planarFigureGeometry)
{
return;
}
auto abstractTransformGeometry = dynamic_cast<AbstractTransformGeometry*>(planarFigure->GetGeometry(0));
if (nullptr != abstractTransformGeometry)
{
return;
}
// If the planarFigure already has reached the maximum number
if (planarFigure->GetNumberOfControlPoints() >= planarFigure->GetMaximumNumberOfControlPoints())
{
return;
}
// Extract point in 2D world coordinates (relative to PlaneGeometry of
// PlanarFigure)
Point2D point2D, projectedPoint;
if (!this->TransformPositionEventToPoint2D(positionEvent, planarFigureGeometry, point2D))
{
return;
}
// TODO: check segment of polyline we clicked in
int nextIndex = -1;
// We only need to check which position to insert the control point
// when interacting with a PlanarPolygon. For all other types
// new control points will always be appended
const mitk::BaseRenderer *renderer = interactionEvent->GetSender();
const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
if (dynamic_cast<mitk::PlanarPolygon *>(planarFigure) && isFigureFinished)
{
nextIndex =
this->IsPositionOverFigure(positionEvent, planarFigure, planarFigureGeometry, projectionPlane, projectedPoint);
}
// Add point as new control point
if (planarFigure->IsPreviewControlPointVisible())
{
point2D = planarFigure->GetPreviewControlPoint();
}
planarFigure->AddControlPoint(point2D, planarFigure->GetControlPointForPolylinePoint(nextIndex, 0));
if (planarFigure->IsPreviewControlPointVisible())
{
planarFigure->SelectControlPoint(nextIndex);
planarFigure->ResetPreviewContolPoint();
}
// Re-evaluate features
planarFigure->EvaluateFeatures();
// this->LogPrintPlanarFigureQuantities( planarFigure );
// Update rendered scene
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PlanarFigureInteractor::AddInitialPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
mitk::BaseRenderer *renderer = interactionEvent->GetSender();
auto abstractTransformGeometry = dynamic_cast<AbstractTransformGeometry*>(planarFigure->GetGeometry(0));
// Invoke event to notify listeners that placement of this PF starts now
planarFigure->InvokeEvent(StartPlacementPlanarFigureEvent());
// Use PlaneGeometry of the renderer clicked on for this PlanarFigure
auto *planeGeometry = const_cast<mitk::PlaneGeometry *>(
dynamic_cast<const mitk::PlaneGeometry *>(renderer->GetSliceNavigationController()->GetCurrentPlaneGeometry()));
if (planeGeometry != nullptr && abstractTransformGeometry == nullptr)
{
planarFigure->SetPlaneGeometry(planeGeometry);
}
else
{
return;
}
// Extract point in 2D world coordinates (relative to PlaneGeometry of
// PlanarFigure)
Point2D point2D;
if (!this->TransformPositionEventToPoint2D(positionEvent, planeGeometry, point2D))
{
return;
}
// Place PlanarFigure at this point
planarFigure->PlaceFigure(point2D);
// Re-evaluate features
planarFigure->EvaluateFeatures();
// this->LogPrintPlanarFigureQuantities( planarFigure );
// Set a bool property indicating that the figure has been placed in
// the current RenderWindow. This is required so that the same render
// window can be re-aligned to the PlaneGeometry of the PlanarFigure later
// on in an application.
GetDataNode()->SetBoolProperty("PlanarFigureInitializedWindow", true, renderer);
// Update rendered scene
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PlanarFigureInteractor::StartHovering(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
if (!m_IsHovering)
{
// Invoke hover event once when the mouse is entering the figure area
m_IsHovering = true;
planarFigure->InvokeEvent(StartHoverPlanarFigureEvent());
// Set bool property to indicate that planar figure is currently in "hovering" mode
GetDataNode()->SetBoolProperty("planarfigure.ishovering", true);
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
void mitk::PlanarFigureInteractor::SetPreviewPointPosition(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
const mitk::BaseRenderer *renderer = interactionEvent->GetSender();
planarFigure->DeselectControlPoint();
mitk::Point2D pointProjectedOntoLine = positionEvent->GetPointerPositionOnScreen();
bool selected(false);
bool isExtendable(false);
bool isEditable(true);
GetDataNode()->GetBoolProperty("selected", selected);
GetDataNode()->GetBoolProperty("planarfigure.isextendable", isExtendable);
GetDataNode()->GetBoolProperty("planarfigure.iseditable", isEditable);
if (selected && isExtendable && isEditable)
{
renderer->DisplayToPlane(pointProjectedOntoLine, pointProjectedOntoLine);
planarFigure->SetPreviewControlPoint(pointProjectedOntoLine);
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::PlanarFigureInteractor::HideControlPoints(StateMachineAction *, InteractionEvent * /*interactionEvent*/)
{
GetDataNode()->SetBoolProperty("planarfigure.drawcontrolpoints", false);
}
void mitk::PlanarFigureInteractor::HidePreviewPoint(StateMachineAction *, InteractionEvent *)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
planarFigure->ResetPreviewContolPoint();
RenderingManager::GetInstance()->RequestUpdateAll();
}
bool mitk::PlanarFigureInteractor::CheckFigureHovering(const InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return false;
}
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return false;
}
auto planarFigureGeometry = planarFigure->GetPlaneGeometry();
if (nullptr == planarFigureGeometry)
{
return false;
}
auto abstractTransformGeometry = dynamic_cast<AbstractTransformGeometry*>(planarFigure->GetGeometry(0));
if (nullptr != abstractTransformGeometry)
{
return false;
}
const mitk::BaseRenderer *renderer = interactionEvent->GetSender();
const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
mitk::Point2D pointProjectedOntoLine;
int previousControlPoint = this->IsPositionOverFigure(
positionEvent, planarFigure, planarFigureGeometry, projectionPlane, pointProjectedOntoLine);
bool isHovering = (previousControlPoint != -1);
return isHovering;
}
bool mitk::PlanarFigureInteractor::CheckControlPointHovering(const InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return false;
}
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return false;
}
auto planarFigureGeometry = planarFigure->GetPlaneGeometry();
if (nullptr == planarFigureGeometry)
{
return false;
}
auto abstractTransformGeometry = dynamic_cast<AbstractTransformGeometry*>(planarFigure->GetGeometry(0));
if (nullptr != abstractTransformGeometry)
{
return false;
}
const mitk::BaseRenderer *renderer = interactionEvent->GetSender();
const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
int pointIndex = -1;
pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
positionEvent, planarFigure, planarFigureGeometry, projectionPlane, renderer);
return pointIndex >= 0;
}
bool mitk::PlanarFigureInteractor::CheckSelection(const InteractionEvent * /*interactionEvent*/)
{
bool selected = false;
GetDataNode()->GetBoolProperty("selected", selected);
return selected;
}
void mitk::PlanarFigureInteractor::SelectFigure(StateMachineAction *, InteractionEvent * /*interactionEvent*/)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
planarFigure->InvokeEvent(SelectPlanarFigureEvent());
}
void mitk::PlanarFigureInteractor::SelectPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
auto planarFigureGeometry = planarFigure->GetPlaneGeometry();
if (nullptr == planarFigureGeometry)
{
return;
}
auto abstractTransformGeometry = dynamic_cast<AbstractTransformGeometry*>(planarFigure->GetGeometry(0));
if (nullptr != abstractTransformGeometry)
{
return;
}
const mitk::BaseRenderer *renderer = interactionEvent->GetSender();
const PlaneGeometry *projectionPlane = renderer->GetCurrentWorldPlaneGeometry();
const int pointIndex = mitk::PlanarFigureInteractor::IsPositionInsideMarker(
positionEvent, planarFigure, planarFigureGeometry, projectionPlane, renderer);
if (pointIndex >= 0)
{
// If mouse is above control point, mark it as selected
planarFigure->SelectControlPoint(pointIndex);
}
else
{
planarFigure->DeselectControlPoint();
}
}
bool mitk::PlanarFigureInteractor::CheckPointValidity(const InteractionEvent *interactionEvent)
{
// Check if the distance of the current point to the previously set point in display coordinates
// is sufficient (if a previous point exists)
auto positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return false;
}
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return false;
}
return IsMousePositionAcceptableAsNewControlPoint(positionEvent, planarFigure);
}
void mitk::PlanarFigureInteractor::RemoveSelectedPoint(StateMachineAction *, InteractionEvent *interactionEvent)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
const int selectedControlPoint = planarFigure->GetSelectedControlPoint();
planarFigure->RemoveControlPoint(selectedControlPoint);
// Re-evaluate features
planarFigure->EvaluateFeatures();
planarFigure->Modified();
GetDataNode()->SetBoolProperty("planarfigure.drawcontrolpoints", true);
planarFigure->InvokeEvent(EndInteractionPlanarFigureEvent());
RenderingManager::GetInstance()->RequestUpdateAll();
mitk::BaseRenderer *renderer = interactionEvent->GetSender();
HandleEvent(mitk::InternalEvent::New(renderer, this, "Dummy-Event"), GetDataNode());
}
void mitk::PlanarFigureInteractor::RequestContextMenu(StateMachineAction *, InteractionEvent * /*interactionEvent*/)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return;
}
bool selected = false;
GetDataNode()->GetBoolProperty("selected", selected);
// no need to invoke this if the figure is already selected
if (!selected)
{
planarFigure->InvokeEvent(SelectPlanarFigureEvent());
}
planarFigure->InvokeEvent(ContextMenuPlanarFigureEvent());
}
bool mitk::PlanarFigureInteractor::CheckResetOnPointSelect(const InteractionEvent * /*interactionEvent*/)
{
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return false;
}
bool isEditable = true;
GetDataNode()->GetBoolProperty("planarfigure.iseditable", isEditable);
// Reset the PlanarFigure if required
return isEditable && planarFigure->ResetOnPointSelectNeeded();
}
bool mitk::PlanarFigureInteractor::CheckFigureOnRenderingGeometry(const InteractionEvent *interactionEvent)
{
auto positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return false;
}
const mitk::Point3D worldPoint3D = positionEvent->GetPositionInWorld();
auto planarFigure = dynamic_cast<PlanarFigure*>(GetDataNode()->GetData());
if (nullptr == planarFigure)
{
return false;
}
auto planarFigureGeometry = planarFigure->GetPlaneGeometry();
if (nullptr == planarFigureGeometry)
{
return false;
}
auto abstractTransformGeometry = dynamic_cast<AbstractTransformGeometry*>(planarFigure->GetGeometry(0));
if (nullptr != abstractTransformGeometry)
{
return false;
}
const double planeThickness = planarFigureGeometry->GetExtentInMM(2);
return planarFigureGeometry->Distance(worldPoint3D) <= planeThickness;
}
void mitk::PlanarFigureInteractor::SetPrecision(mitk::ScalarType precision)
{
m_Precision = precision;
}
void mitk::PlanarFigureInteractor::SetMinimumPointDistance(ScalarType minimumDistance)
{
m_MinimumPointDistance = minimumDistance;
}
bool mitk::PlanarFigureInteractor::TransformPositionEventToPoint2D(const InteractionPositionEvent *positionEvent,
const PlaneGeometry *planarFigureGeometry,
Point2D &point2D)
{
if (nullptr == positionEvent || nullptr == planarFigureGeometry)
{
return false;
}
const mitk::Point3D worldPoint3D = positionEvent->GetPositionInWorld();
// TODO: proper handling of distance tolerance
if (planarFigureGeometry->Distance(worldPoint3D) > 0.1)
{
return false;
}
// Project point onto plane of this PlanarFigure
planarFigureGeometry->Map(worldPoint3D, point2D);
return true;
}
bool mitk::PlanarFigureInteractor::TransformObjectToDisplay(const mitk::Point2D &point2D,
mitk::Point2D &displayPoint,
const mitk::PlaneGeometry *objectGeometry,
const mitk::PlaneGeometry *rendererGeometry,
const mitk::BaseRenderer *renderer) const
{
if (nullptr == objectGeometry || nullptr == rendererGeometry || nullptr == renderer)
{
return false;
}
mitk::Point3D point3D;
// Map circle point from local 2D geometry into 3D world space
objectGeometry->Map(point2D, point3D);
const double planeThickness = objectGeometry->GetExtentInMM(2);
// TODO: proper handling of distance tolerance
if (rendererGeometry->Distance(point3D) < planeThickness / 3.0)
{
// Project 3D world point onto display geometry
renderer->WorldToDisplay(point3D, displayPoint);
return true;
}
return false;
}
bool mitk::PlanarFigureInteractor::IsPointNearLine(const mitk::Point2D &point,
const mitk::Point2D &startPoint,
const mitk::Point2D &endPoint,
mitk::Point2D &projectedPoint) const
{
mitk::Vector2D n1 = endPoint - startPoint;
n1.Normalize();
// Determine dot products between line vector and startpoint-point / endpoint-point vectors
const double l1 = n1 * (point - startPoint);
const double l2 = -n1 * (point - endPoint);
// Determine projection of specified point onto line defined by start / end point
const mitk::Point2D crossPoint = startPoint + n1 * l1;
projectedPoint = crossPoint;
const float dist1 = crossPoint.SquaredEuclideanDistanceTo(point);
const float dist2 = endPoint.SquaredEuclideanDistanceTo(point);
const float dist3 = startPoint.SquaredEuclideanDistanceTo(point);
// Point is inside encompassing rectangle IF
// - its distance to its projected point is small enough
// - it is not further outside of the line than the defined tolerance
if (((dist1 < 20.0) && (l1 > 0.0) && (l2 > 0.0)) || dist2 < 20.0 || dist3 < 20.0)
{
return true;
}
return false;
}
int mitk::PlanarFigureInteractor::IsPositionOverFigure(const InteractionPositionEvent *positionEvent,
PlanarFigure *planarFigure,
const PlaneGeometry *planarFigureGeometry,
const PlaneGeometry *rendererGeometry,
Point2D &pointProjectedOntoLine) const
{
if (nullptr == positionEvent || nullptr == planarFigure || nullptr == planarFigureGeometry
|| nullptr == rendererGeometry)
{
return -1;
}
mitk::Point2D displayPosition = positionEvent->GetPointerPositionOnScreen();
// Iterate over all polylines of planar figure, and check if
// any one is close to the current display position
typedef mitk::PlanarFigure::PolyLineType VertexContainerType;
Point2D polyLinePoint;
Point2D firstPolyLinePoint;
Point2D previousPolyLinePoint;
for (unsigned short loop = 0; loop < planarFigure->GetPolyLinesSize(); ++loop)
{
const VertexContainerType polyLine = planarFigure->GetPolyLine(loop);
bool firstPoint(true);
for (auto it = polyLine.begin(); it != polyLine.end(); ++it)
{
// Get plane coordinates of this point of polyline (if possible)
if (!this->TransformObjectToDisplay(
*it, polyLinePoint, planarFigureGeometry, rendererGeometry, positionEvent->GetSender()))
{
break; // Poly line invalid (not on current 2D plane) --> skip it
}
if (firstPoint)
{
firstPolyLinePoint = polyLinePoint;
firstPoint = false;
}
else if (this->IsPointNearLine(displayPosition, previousPolyLinePoint, polyLinePoint, pointProjectedOntoLine))
{
// Point is close enough to line segment --> Return index of the segment
return std::distance(polyLine.begin(), it);
}
previousPolyLinePoint = polyLinePoint;
}
// For closed figures, also check last line segment
if (planarFigure->IsClosed() &&
this->IsPointNearLine(displayPosition, polyLinePoint, firstPolyLinePoint, pointProjectedOntoLine))
{
return 0; // Return index of first control point
}
}
return -1;
}
int mitk::PlanarFigureInteractor::IsPositionInsideMarker(const InteractionPositionEvent *positionEvent,
const PlanarFigure *planarFigure,
const PlaneGeometry *planarFigureGeometry,
const PlaneGeometry *rendererGeometry,
const BaseRenderer *renderer) const
{
if (nullptr == positionEvent || nullptr == planarFigure || nullptr == planarFigureGeometry
|| nullptr == rendererGeometry || nullptr == renderer)
{
return -1;
}
const mitk::Point2D displayPosition = positionEvent->GetPointerPositionOnScreen();
// Iterate over all control points of planar figure, and check if
// any one is close to the current display position
mitk::Point2D displayControlPoint;
const int numberOfControlPoints = planarFigure->GetNumberOfControlPoints();
for (int i = 0; i < numberOfControlPoints; i++)
{
if (this->TransformObjectToDisplay(
planarFigure->GetControlPoint(i), displayControlPoint, planarFigureGeometry, rendererGeometry, renderer))
{
// TODO: variable size of markers
if (displayPosition.SquaredEuclideanDistanceTo(displayControlPoint) < 20.0)
{
return i;
}
}
}
return -1;
}
void mitk::PlanarFigureInteractor::LogPrintPlanarFigureQuantities(const PlanarFigure *planarFigure)
{
if (nullptr == planarFigure)
{
MITK_INFO << "PlanarFigure invalid.";
}
MITK_INFO << "PlanarFigure: " << planarFigure->GetNameOfClass();
for (unsigned int i = 0; i < planarFigure->GetNumberOfFeatures(); ++i)
{
MITK_INFO << "* " << planarFigure->GetFeatureName(i) << ": " << planarFigure->GetQuantity(i) << " "
<< planarFigure->GetFeatureUnit(i);
}
}
bool mitk::PlanarFigureInteractor::IsMousePositionAcceptableAsNewControlPoint(
const mitk::InteractionPositionEvent *positionEvent, const PlanarFigure *planarFigure)
{
if (nullptr == positionEvent || nullptr == planarFigure)
{
return false;
}
const BaseRenderer *renderer = positionEvent->GetSender();
if (nullptr == renderer)
{
return false;
}
// Get the timestep to support 3D+t
const int timeStep(renderer->GetTimeStep(planarFigure));
bool tooClose(false);
auto planarFigureGeometry = dynamic_cast<mitk::PlaneGeometry*>(planarFigure->GetGeometry(timeStep));
if (nullptr == planarFigureGeometry)
{
return false;
}
auto abstractTransformGeometry = dynamic_cast<AbstractTransformGeometry*>(planarFigure->GetGeometry(timeStep));
if (nullptr != abstractTransformGeometry)
{
return false;
}
Point2D point2D;
// Get the point2D from the positionEvent
if (!this->TransformPositionEventToPoint2D(positionEvent, planarFigureGeometry, point2D))
{
return false;
}
// apply the controlPoint constraints of the planarFigure to get the
// coordinates that would actually be used.
const Point2D correctedPoint = const_cast<PlanarFigure *>(planarFigure)->ApplyControlPointConstraints(0, point2D);
// map the 2D coordinates of the new point to world-coordinates
// and transform those to display-coordinates
mitk::Point3D newPoint3D;
planarFigureGeometry->Map(correctedPoint, newPoint3D);
mitk::Point2D newDisplayPosition;
renderer->WorldToDisplay(newPoint3D, newDisplayPosition);
const int selectedControlPoint = planarFigure->GetSelectedControlPoint();
for (int i = 0; i < (int)planarFigure->GetNumberOfControlPoints(); ++i)
{
if (i != selectedControlPoint)
{
// Try to convert previous point to current display coordinates
mitk::Point3D previousPoint3D;
// map the 2D coordinates of the control-point to world-coordinates
planarFigureGeometry->Map(planarFigure->GetControlPoint(i), previousPoint3D);
if (renderer->GetCurrentWorldPlaneGeometry()->Distance(previousPoint3D) < 0.1) // ugly, but assert makes this work
{
mitk::Point2D previousDisplayPosition;
// transform the world-coordinates into display-coordinates
renderer->WorldToDisplay(previousPoint3D, previousDisplayPosition);
// Calculate the distance. We use display-coordinates here to make
// the check independent of the zoom-level of the rendering scene.
const double a = newDisplayPosition[0] - previousDisplayPosition[0];
const double b = newDisplayPosition[1] - previousDisplayPosition[1];
// If point is to close, do not set a new point
tooClose = (a * a + b * b < m_MinimumPointDistance);
}
if (tooClose)
return false; // abort loop early
}
}
return !tooClose; // default
}
void mitk::PlanarFigureInteractor::ConfigurationChanged()
{
const mitk::PropertyList::Pointer properties = GetAttributes();
std::string precision = "";
if (properties->GetStringProperty("precision", precision))
{
m_Precision = atof(precision.c_str());
}
else
{
m_Precision = (ScalarType)6.5;
}
std::string minPointDistance = "";
if (properties->GetStringProperty("minPointDistance", minPointDistance))
{
m_MinimumPointDistance = atof(minPointDistance.c_str());
}
else
{
m_MinimumPointDistance = (ScalarType)25.0;
}
}
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
index 4989b86d7a..23872a6f83 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,880 +1,888 @@
/*============================================================================
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 "QmitkMeasurementView.h"
#include <QAction>
#include <QApplication>
#include <QClipboard>
#include <QGridLayout>
#include <QToolBar>
#include <QTextBrowser>
#include <QCheckBox>
#include <QGroupBox>
#include <mitkInteractionEventObserver.h>
#include <mitkCoreServices.h>
#include <mitkIPropertyFilters.h>
#include <mitkPropertyFilter.h>
#include <mitkVtkLayerController.h>
#include <mitkPlanarCircle.h>
#include <mitkPlanarEllipse.h>
#include <mitkPlanarPolygon.h>
#include <mitkPlanarAngle.h>
#include <mitkPlanarRectangle.h>
#include <mitkPlanarLine.h>
#include <mitkPlanarCross.h>
#include <mitkPlanarFourPointAngle.h>
#include <mitkPlanarDoubleEllipse.h>
#include <mitkPlanarBezierCurve.h>
#include <mitkPlanarSubdivisionPolygon.h>
#include <mitkPlanarFigureInteractor.h>
#include <mitkPlaneGeometry.h>
#include <mitkILinkedRenderWindowPart.h>
#include <mitkImage.h>
#include <mitkNodePredicateDataType.h>
#include <mitkNodePredicateProperty.h>
#include <mitkNodePredicateAnd.h>
#include <mitkNodePredicateNot.h>
#include <QmitkRenderWindow.h>
#include <QmitkSingleNodeSelectionWidget.h>
#include "ctkDoubleSpinBox.h"
#include "mitkPluginActivator.h"
#include "usModuleRegistry.h"
#include "mitkInteractionEventObserver.h"
#include "mitkDisplayInteractor.h"
#include "usGetModuleContext.h"
#include "usModuleContext.h"
#include <usModuleInitialization.h>
US_INITIALIZE_MODULE
struct QmitkPlanarFigureData
{
QmitkPlanarFigureData()
: m_EndPlacementObserverTag(0),
m_SelectObserverTag(0),
m_StartInteractionObserverTag(0),
- m_EndInteractionObserverTag(0)
+ m_EndInteractionObserverTag(0),
+ m_DuringInteractionObserverTag(0)
{
}
mitk::PlanarFigure::Pointer m_Figure;
unsigned int m_EndPlacementObserverTag;
unsigned int m_SelectObserverTag;
unsigned int m_StartInteractionObserverTag;
unsigned int m_EndInteractionObserverTag;
+ unsigned int m_DuringInteractionObserverTag;
};
struct QmitkMeasurementViewData
{
QmitkMeasurementViewData()
: m_LineCounter(0),
m_PathCounter(0),
m_AngleCounter(0),
m_FourPointAngleCounter(0),
m_CircleCounter(0),
m_EllipseCounter(0),
m_DoubleEllipseCounter(0),
m_RectangleCounter(0),
m_PolygonCounter(0),
m_BezierCurveCounter(0),
m_SubdivisionPolygonCounter(0),
m_UnintializedPlanarFigure(false),
m_ScrollEnabled(true),
m_Parent(nullptr),
m_SingleNodeSelectionWidget(nullptr),
m_DrawLine(nullptr),
m_DrawPath(nullptr),
m_DrawAngle(nullptr),
m_DrawFourPointAngle(nullptr),
m_DrawRectangle(nullptr),
m_DrawPolygon(nullptr),
m_DrawCircle(nullptr),
m_DrawEllipse(nullptr),
m_DrawDoubleEllipse(nullptr),
m_DrawBezierCurve(nullptr),
m_DrawSubdivisionPolygon(nullptr),
m_DrawActionsToolBar(nullptr),
m_DrawActionsGroup(nullptr),
m_SelectedPlanarFiguresText(nullptr),
m_CopyToClipboard(nullptr),
m_Layout(nullptr),
m_Radius(nullptr),
m_Thickness(nullptr),
m_FixedParameterBox(nullptr)
{
}
unsigned int m_LineCounter;
unsigned int m_PathCounter;
unsigned int m_AngleCounter;
unsigned int m_FourPointAngleCounter;
unsigned int m_CircleCounter;
unsigned int m_EllipseCounter;
unsigned int m_DoubleEllipseCounter;
unsigned int m_RectangleCounter;
unsigned int m_PolygonCounter;
unsigned int m_BezierCurveCounter;
unsigned int m_SubdivisionPolygonCounter;
QList<mitk::DataNode::Pointer> m_CurrentSelection;
std::map<mitk::DataNode::Pointer, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData;
mitk::DataNode::Pointer m_SelectedImageNode;
bool m_UnintializedPlanarFigure;
bool m_ScrollEnabled;
QWidget* m_Parent;
QLabel* m_SelectedImageLabel;
QmitkSingleNodeSelectionWidget* m_SingleNodeSelectionWidget;
QAction* m_DrawLine;
QAction* m_DrawPath;
QAction* m_DrawAngle;
QAction* m_DrawFourPointAngle;
QAction* m_DrawRectangle;
QAction* m_DrawPolygon;
QAction* m_DrawCircle;
QAction* m_DrawEllipse;
QAction* m_DrawDoubleEllipse;
QAction* m_DrawBezierCurve;
QAction* m_DrawSubdivisionPolygon;
QToolBar* m_DrawActionsToolBar;
QActionGroup* m_DrawActionsGroup;
QTextBrowser* m_SelectedPlanarFiguresText;
QPushButton* m_CopyToClipboard;
QGridLayout* m_Layout;
ctkDoubleSpinBox* m_Radius;
ctkDoubleSpinBox* m_Thickness;
QGroupBox* m_FixedParameterBox;
};
const std::string QmitkMeasurementView::VIEW_ID = "org.mitk.views.measurement";
QmitkMeasurementView::QmitkMeasurementView()
: d(new QmitkMeasurementViewData)
{
}
QmitkMeasurementView::~QmitkMeasurementView()
{
auto planarFigures = this->GetAllPlanarFigures();
for (auto it = planarFigures->Begin(); it != planarFigures->End(); ++it)
this->NodeRemoved(it.Value());
delete d;
}
void QmitkMeasurementView::CreateQtPartControl(QWidget* parent)
{
d->m_Parent = parent;
d->m_SingleNodeSelectionWidget = new QmitkSingleNodeSelectionWidget();
d->m_SingleNodeSelectionWidget->SetDataStorage(GetDataStorage());
d->m_SingleNodeSelectionWidget->SetNodePredicate(mitk::NodePredicateAnd::New(
mitk::TNodePredicateDataType<mitk::Image>::New(),
mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object"))));
d->m_SingleNodeSelectionWidget->SetSelectionIsOptional(true);
d->m_SingleNodeSelectionWidget->SetEmptyInfo(QStringLiteral("Please select a reference image"));
d->m_SingleNodeSelectionWidget->SetPopUpTitel(QStringLiteral("Select a reference image"));
d->m_DrawActionsToolBar = new QToolBar;
d->m_DrawActionsGroup = new QActionGroup(this);
d->m_DrawActionsGroup->setExclusive(true);
auto* currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/line.png"), tr("Draw Line"));
currentAction->setCheckable(true);
d->m_DrawLine = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/path.png"), tr("Draw Path"));
currentAction->setCheckable(true);
d->m_DrawPath = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/angle.png"), tr("Draw Angle"));
currentAction->setCheckable(true);
d->m_DrawAngle = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/four-point-angle.png"), tr("Draw Four Point Angle"));
currentAction->setCheckable(true);
d->m_DrawFourPointAngle = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/circle.png"), tr("Draw Circle"));
currentAction->setCheckable(true);
d->m_DrawCircle = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/ellipse.png"), tr("Draw Ellipse"));
currentAction->setCheckable(true);
d->m_DrawEllipse = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/doubleellipse.png"), tr("Draw Double Ellipse"));
currentAction->setCheckable(true);
d->m_DrawDoubleEllipse = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/rectangle.png"), tr("Draw Rectangle"));
currentAction->setCheckable(true);
d->m_DrawRectangle = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/polygon.png"), tr("Draw Polygon"));
currentAction->setCheckable(true);
d->m_DrawPolygon = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/beziercurve.png"), tr("Draw Bezier Curve"));
currentAction->setCheckable(true);
d->m_DrawBezierCurve = currentAction;
currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/subdivisionpolygon.png"), tr("Draw Subdivision Polygon"));
currentAction->setCheckable(true);
d->m_DrawSubdivisionPolygon = currentAction;
d->m_DrawActionsToolBar->setEnabled(false);
// fixed parameter section
auto fixedLayout = new QGridLayout();
d->m_FixedParameterBox = new QGroupBox();
d->m_FixedParameterBox->setCheckable(true);
d->m_FixedParameterBox->setChecked(false);
d->m_FixedParameterBox->setEnabled(false);
d->m_FixedParameterBox->setTitle("Fixed sized circle/double ellipse");
d->m_FixedParameterBox->setToolTip("If activated, circles and double ellipses (as rings) figures will always be created with the set parameters as fixed size.");
d->m_FixedParameterBox->setAlignment(Qt::AlignLeft);
auto labelRadius1 = new QLabel(QString("Radius"));
d->m_Radius = new ctkDoubleSpinBox();
d->m_Radius->setMinimum(0);
d->m_Radius->setValue(10);
d->m_Radius->setSuffix(" mm");
d->m_Radius->setAlignment(Qt::AlignLeft);
d->m_Radius->setToolTip("Sets the radius for following planar figures: circle, double ellipse (as ring).");
auto labelThickness = new QLabel(QString("Thickness"));
d->m_Thickness = new ctkDoubleSpinBox();
d->m_Thickness->setMinimum(0);
d->m_Thickness->setMaximum(10);
d->m_Thickness->setValue(5);
d->m_Thickness->setSuffix(" mm");
d->m_Thickness->setAlignment(Qt::AlignLeft);
d->m_Thickness->setToolTip("Sets the thickness for following planar figures: double ellipse (as ring).");
fixedLayout->addWidget(labelRadius1,0,0);
fixedLayout->addWidget(d->m_Radius,0,1);
fixedLayout->addWidget(labelThickness,1,0);
fixedLayout->addWidget(d->m_Thickness,1,1);
d->m_FixedParameterBox->setLayout(fixedLayout);
// planar figure details text
d->m_SelectedPlanarFiguresText = new QTextBrowser;
// copy to clipboard button
d->m_CopyToClipboard = new QPushButton(tr("Copy to Clipboard"));
d->m_SelectedImageLabel = new QLabel("Selected Image");
d->m_Layout = new QGridLayout;
d->m_Layout->addWidget(d->m_SelectedImageLabel, 0, 0);
d->m_Layout->addWidget(d->m_SingleNodeSelectionWidget, 0, 1, 1, 1);
d->m_Layout->addWidget(d->m_DrawActionsToolBar, 1, 0, 1, 2);
d->m_Layout->addWidget(d->m_FixedParameterBox, 2, 0, 1, 2);
d->m_Layout->addWidget(d->m_SelectedPlanarFiguresText, 3, 0, 1, 2);
d->m_Layout->addWidget(d->m_CopyToClipboard, 4, 0, 1, 2);
d->m_Parent->setLayout(d->m_Layout);
this->CreateConnections();
this->AddAllInteractors();
// placed after CreateConnections to trigger update of the current selection
d->m_SingleNodeSelectionWidget->SetAutoSelectNewNodes(true);
}
void QmitkMeasurementView::CreateConnections()
{
connect(d->m_SingleNodeSelectionWidget, &QmitkSingleNodeSelectionWidget::CurrentSelectionChanged,
this, &QmitkMeasurementView::OnCurrentSelectionChanged);
connect(d->m_DrawLine, SIGNAL(triggered(bool)), this, SLOT(OnDrawLineTriggered(bool)));
connect(d->m_DrawPath, SIGNAL(triggered(bool)), this, SLOT(OnDrawPathTriggered(bool)));
connect(d->m_DrawAngle, SIGNAL(triggered(bool)), this, SLOT(OnDrawAngleTriggered(bool)));
connect(d->m_DrawFourPointAngle, SIGNAL(triggered(bool)), this, SLOT(OnDrawFourPointAngleTriggered(bool)));
connect(d->m_DrawCircle, SIGNAL(triggered(bool)), this, SLOT(OnDrawCircleTriggered(bool)));
connect(d->m_DrawEllipse, SIGNAL(triggered(bool)), this, SLOT(OnDrawEllipseTriggered(bool)));
connect(d->m_DrawDoubleEllipse, SIGNAL(triggered(bool)), this, SLOT(OnDrawDoubleEllipseTriggered(bool)));
connect(d->m_DrawRectangle, SIGNAL(triggered(bool)), this, SLOT(OnDrawRectangleTriggered(bool)));
connect(d->m_DrawPolygon, SIGNAL(triggered(bool)), this, SLOT(OnDrawPolygonTriggered(bool)));
connect(d->m_DrawBezierCurve, SIGNAL(triggered(bool)), this, SLOT(OnDrawBezierCurveTriggered(bool)));
connect(d->m_DrawSubdivisionPolygon, SIGNAL(triggered(bool)), this, SLOT(OnDrawSubdivisionPolygonTriggered(bool)));
connect(d->m_CopyToClipboard, SIGNAL(clicked(bool)), this, SLOT(OnCopyToClipboard(bool)));
connect(d->m_Radius, QOverload<double>::of(&ctkDoubleSpinBox::valueChanged), d->m_Thickness, &ctkDoubleSpinBox::setMaximum);
}
void QmitkMeasurementView::OnCurrentSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
{
if (nodes.empty() || nodes.front().IsNull())
{
d->m_SelectedImageNode = nullptr;
d->m_DrawActionsToolBar->setEnabled(false);
d->m_FixedParameterBox->setEnabled(false);
}
else
{
d->m_SelectedImageNode = nodes.front();
d->m_DrawActionsToolBar->setEnabled(true);
d->m_FixedParameterBox->setEnabled(true);
}
}
void QmitkMeasurementView::NodeAdded(const mitk::DataNode* node)
{
// add observer for selection in renderwindow
mitk::PlanarFigure::Pointer planarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
auto isPositionMarker = false;
node->GetBoolProperty("isContourMarker", isPositionMarker);
if (planarFigure.IsNotNull() && !isPositionMarker)
{
auto nonConstNode = const_cast<mitk::DataNode*>(node);
mitk::PlanarFigureInteractor::Pointer interactor = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer());
if (interactor.IsNull())
{
interactor = mitk::PlanarFigureInteractor::New();
auto planarFigureModule = us::ModuleRegistry::GetModule("MitkPlanarFigure");
interactor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule);
interactor->SetEventConfig("PlanarFigureConfig.xml", planarFigureModule);
}
interactor->SetDataNode(nonConstNode);
QmitkPlanarFigureData data;
data.m_Figure = planarFigure;
typedef itk::SimpleMemberCommand<QmitkMeasurementView> SimpleCommandType;
typedef itk::MemberCommand<QmitkMeasurementView> MemberCommandType;
// add observer for event when figure has been placed
auto initializationCommand = SimpleCommandType::New();
initializationCommand->SetCallbackFunction(this, &QmitkMeasurementView::PlanarFigureInitialized);
data.m_EndPlacementObserverTag = planarFigure->AddObserver(mitk::EndPlacementPlanarFigureEvent(), initializationCommand);
// add observer for event when figure is picked (selected)
auto selectCommand = MemberCommandType::New();
selectCommand->SetCallbackFunction(this, &QmitkMeasurementView::PlanarFigureSelected);
data.m_SelectObserverTag = planarFigure->AddObserver(mitk::SelectPlanarFigureEvent(), selectCommand);
// add observer for event when interaction with figure starts
auto startInteractionCommand = SimpleCommandType::New();
startInteractionCommand->SetCallbackFunction(this, &QmitkMeasurementView::DisableCrosshairNavigation);
data.m_StartInteractionObserverTag = planarFigure->AddObserver(mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand);
- // add observer for event when interaction with figure starts
+ // add observer for event when interaction with figure ends
auto endInteractionCommand = SimpleCommandType::New();
endInteractionCommand->SetCallbackFunction(this, &QmitkMeasurementView::EnableCrosshairNavigation);
data.m_EndInteractionObserverTag = planarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand);
+ // add observer for event during interaction when a point is moved
+ auto duringInteractionCommand = SimpleCommandType::New();
+ duringInteractionCommand->SetCallbackFunction(this, &QmitkMeasurementView::UpdateMeasurementText);
+ data.m_DuringInteractionObserverTag = planarFigure->AddObserver(mitk::PointMovedPlanarFigureEvent(), duringInteractionCommand);
+
// adding to the map of tracked planarfigures
d->m_DataNodeToPlanarFigureData[nonConstNode] = data;
}
}
void QmitkMeasurementView::NodeChanged(const mitk::DataNode* node)
{
auto it = std::find(d->m_CurrentSelection.begin(), d->m_CurrentSelection.end(), node);
if (it != d->m_CurrentSelection.end())
{
this->UpdateMeasurementText();
}
}
void QmitkMeasurementView::NodeRemoved(const mitk::DataNode* node)
{
auto nonConstNode = const_cast<mitk::DataNode*>(node);
auto it = d->m_DataNodeToPlanarFigureData.find(nonConstNode);
auto isFigureFinished = false;
auto isPlaced = false;
if (it != d->m_DataNodeToPlanarFigureData.end())
{
QmitkPlanarFigureData& data = it->second;
data.m_Figure->RemoveObserver(data.m_EndPlacementObserverTag);
data.m_Figure->RemoveObserver(data.m_SelectObserverTag);
data.m_Figure->RemoveObserver(data.m_StartInteractionObserverTag);
data.m_Figure->RemoveObserver(data.m_EndInteractionObserverTag);
+ data.m_Figure->RemoveObserver(data.m_DuringInteractionObserverTag);
isFigureFinished = data.m_Figure->GetPropertyList()->GetBoolProperty("initiallyplaced", isPlaced);
if (!isFigureFinished) // if the property does not yet exist or is false, drop the datanode
this->PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
d->m_DataNodeToPlanarFigureData.erase( it );
}
if (nonConstNode != nullptr)
nonConstNode->SetDataInteractor(nullptr);
auto isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
auto nodes = this->GetDataStorage()->GetDerivations(node, isPlanarFigure);
for (unsigned int x = 0; x < nodes->size(); ++x)
{
mitk::PlanarFigure::Pointer planarFigure = dynamic_cast<mitk::PlanarFigure*>(nodes->at(x)->GetData());
if (planarFigure.IsNotNull())
{
isFigureFinished = planarFigure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
if (!isFigureFinished) // if the property does not yet exist or is false, drop the datanode
{
this->GetDataStorage()->Remove(nodes->at(x));
if (!d->m_DataNodeToPlanarFigureData.empty())
{
it = d->m_DataNodeToPlanarFigureData.find(nodes->at(x));
if (it != d->m_DataNodeToPlanarFigureData.end())
{
d->m_DataNodeToPlanarFigureData.erase(it);
this->PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
this->EnableCrosshairNavigation();
}
}
}
}
}
}
void QmitkMeasurementView::PlanarFigureSelected(itk::Object* object, const itk::EventObject&)
{
d->m_CurrentSelection.clear();
auto lambda = [&object](const std::pair<mitk::DataNode::Pointer, QmitkPlanarFigureData>& element)
{
return element.second.m_Figure == object;
};
auto it = std::find_if(d->m_DataNodeToPlanarFigureData.begin(), d->m_DataNodeToPlanarFigureData.end(), lambda);
if (it != d->m_DataNodeToPlanarFigureData.end())
{
d->m_CurrentSelection.push_back(it->first);
}
this->UpdateMeasurementText();
this->RequestRenderWindowUpdate();
}
void QmitkMeasurementView::PlanarFigureInitialized()
{
d->m_UnintializedPlanarFigure = false;
d->m_DrawActionsToolBar->setEnabled(true);
d->m_DrawLine->setChecked(false);
d->m_DrawPath->setChecked(false);
d->m_DrawAngle->setChecked(false);
d->m_DrawFourPointAngle->setChecked(false);
d->m_DrawCircle->setChecked(false);
d->m_DrawEllipse->setChecked(false);
d->m_DrawDoubleEllipse->setChecked(false);
d->m_DrawRectangle->setChecked(false);
d->m_DrawPolygon->setChecked(false);
d->m_DrawBezierCurve->setChecked(false);
d->m_DrawSubdivisionPolygon->setChecked(false);
}
void QmitkMeasurementView::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
{
d->m_CurrentSelection = nodes;
this->UpdateMeasurementText();
// bug 16600: deselecting all planarfigures by clicking on datamanager when no node is selected
if (d->m_CurrentSelection.size() == 0)
{
auto isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
auto planarFigures = this->GetDataStorage()->GetSubset(isPlanarFigure);
// setting all planar figures which are not helper objects not selected
for (mitk::DataStorage::SetOfObjects::ConstIterator it = planarFigures->Begin(); it != planarFigures->End(); ++it)
{
auto node = it.Value();
auto isHelperObject = false;
node->GetBoolProperty("helper object", isHelperObject);
if (!isHelperObject)
node->SetSelected(false);
}
}
for (int i = d->m_CurrentSelection.size() - 1; i >= 0; --i)
{
auto node = d->m_CurrentSelection[i];
mitk::PlanarFigure::Pointer planarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
// the last selected planar figure
if (planarFigure.IsNotNull() && planarFigure->GetPlaneGeometry())
{
auto planarFigureInitializedWindow = false;
auto linkedRenderWindow = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
QmitkRenderWindow* selectedRenderWindow;
if (!linkedRenderWindow)
return;
auto axialRenderWindow = linkedRenderWindow->GetQmitkRenderWindow("axial");
auto sagittalRenderWindow = linkedRenderWindow->GetQmitkRenderWindow("sagittal");
auto coronalRenderWindow = linkedRenderWindow->GetQmitkRenderWindow("coronal");
auto threeDimRenderWindow = linkedRenderWindow->GetQmitkRenderWindow("3d");
if (node->GetBoolProperty("planarFigureInitializedWindow", planarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
{
selectedRenderWindow = axialRenderWindow;
}
else if (node->GetBoolProperty("planarFigureInitializedWindow", planarFigureInitializedWindow, sagittalRenderWindow->GetRenderer()))
{
selectedRenderWindow = sagittalRenderWindow;
}
else if (node->GetBoolProperty("planarFigureInitializedWindow", planarFigureInitializedWindow, coronalRenderWindow->GetRenderer()))
{
selectedRenderWindow = coronalRenderWindow;
}
else if (node->GetBoolProperty("planarFigureInitializedWindow", planarFigureInitializedWindow, threeDimRenderWindow->GetRenderer()))
{
selectedRenderWindow = threeDimRenderWindow;
}
else
{
selectedRenderWindow = nullptr;
}
auto planeGeometry = dynamic_cast<const mitk::PlaneGeometry*>(planarFigure->GetPlaneGeometry());
auto normal = planeGeometry->GetNormalVnl();
mitk::PlaneGeometry::ConstPointer axialPlane = axialRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry();
auto axialNormal = axialPlane->GetNormalVnl();
mitk::PlaneGeometry::ConstPointer sagittalPlane = sagittalRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry();
auto sagittalNormal = sagittalPlane->GetNormalVnl();
mitk::PlaneGeometry::ConstPointer coronalPlane = coronalRenderWindow->GetRenderer()->GetCurrentWorldPlaneGeometry();
auto coronalNormal = coronalPlane->GetNormalVnl();
normal[0] = fabs(normal[0]);
normal[1] = fabs(normal[1]);
normal[2] = fabs(normal[2]);
axialNormal[0] = fabs(axialNormal[0]);
axialNormal[1] = fabs(axialNormal[1]);
axialNormal[2] = fabs(axialNormal[2]);
sagittalNormal[0] = fabs(sagittalNormal[0]);
sagittalNormal[1] = fabs(sagittalNormal[1]);
sagittalNormal[2] = fabs(sagittalNormal[2]);
coronalNormal[0] = fabs(coronalNormal[0]);
coronalNormal[1] = fabs(coronalNormal[1]);
coronalNormal[2] = fabs(coronalNormal[2]);
auto ang1 = angle(normal, axialNormal);
auto ang2 = angle(normal, sagittalNormal);
auto ang3 = angle(normal, coronalNormal);
if (ang1 < ang2 && ang1 < ang3)
{
selectedRenderWindow = axialRenderWindow;
}
else
{
if (ang2 < ang3)
{
selectedRenderWindow = sagittalRenderWindow;
}
else
{
selectedRenderWindow = coronalRenderWindow;
}
}
// re-orient view
if (selectedRenderWindow)
selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(planeGeometry->GetOrigin(), planeGeometry->GetNormal());
}
break;
}
this->RequestRenderWindowUpdate();
}
void QmitkMeasurementView::OnDrawLineTriggered(bool)
{
this->AddFigureToDataStorage(
mitk::PlanarLine::New(),
QString("Line%1").arg(++d->m_LineCounter));
}
void QmitkMeasurementView::OnDrawPathTriggered(bool)
{
mitk::CoreServicePointer<mitk::IPropertyFilters> propertyFilters(mitk::CoreServices::GetPropertyFilters());
mitk::PropertyFilter filter;
filter.AddEntry("ClosedPlanarPolygon", mitk::PropertyFilter::Blacklist);
propertyFilters->AddFilter(filter, "PlanarPolygon");
mitk::PlanarPolygon::Pointer planarFigure = mitk::PlanarPolygon::New();
planarFigure->ClosedOff();
auto node = this->AddFigureToDataStorage(
planarFigure,
QString("Path%1").arg(++d->m_PathCounter));
node->SetProperty("ClosedPlanarPolygon", mitk::BoolProperty::New(false));
node->SetProperty("planarfigure.isextendable", mitk::BoolProperty::New(true));
}
void QmitkMeasurementView::OnDrawAngleTriggered(bool)
{
this->AddFigureToDataStorage(
mitk::PlanarAngle::New(),
QString("Angle%1").arg(++d->m_AngleCounter));
}
void QmitkMeasurementView::OnDrawFourPointAngleTriggered(bool)
{
this->AddFigureToDataStorage(
mitk::PlanarFourPointAngle::New(),
QString("Four Point Angle%1").arg(++d->m_FourPointAngleCounter));
}
void QmitkMeasurementView::OnDrawCircleTriggered(bool)
{
auto circle = (d->m_FixedParameterBox->isChecked()) ? mitk::PlanarCircle::New(d->m_Radius->value()) : mitk::PlanarCircle::New();
this->AddFigureToDataStorage(circle, QString("Circle%1").arg(++d->m_CircleCounter));
}
void QmitkMeasurementView::OnDrawEllipseTriggered(bool)
{
this->AddFigureToDataStorage(
mitk::PlanarEllipse::New(),
QString("Ellipse%1").arg(++d->m_EllipseCounter));
}
void QmitkMeasurementView::OnDrawDoubleEllipseTriggered(bool)
{
auto ellipse = (d->m_FixedParameterBox->isChecked()) ? mitk::PlanarDoubleEllipse::New(d->m_Radius->value(),d->m_Thickness->value()) : mitk::PlanarDoubleEllipse::New();
this->AddFigureToDataStorage(ellipse, QString("DoubleEllipse%1").arg(++d->m_DoubleEllipseCounter));
}
void QmitkMeasurementView::OnDrawBezierCurveTriggered(bool)
{
this->AddFigureToDataStorage(
mitk::PlanarBezierCurve::New(),
QString("BezierCurve%1").arg(++d->m_BezierCurveCounter));
}
void QmitkMeasurementView::OnDrawSubdivisionPolygonTriggered(bool)
{
this->AddFigureToDataStorage(
mitk::PlanarSubdivisionPolygon::New(),
QString("SubdivisionPolygon%1").arg(++d->m_SubdivisionPolygonCounter));
}
void QmitkMeasurementView::OnDrawRectangleTriggered(bool)
{
this->AddFigureToDataStorage(
mitk::PlanarRectangle::New(),
QString("Rectangle%1").arg(++d->m_RectangleCounter));
}
void QmitkMeasurementView::OnDrawPolygonTriggered(bool)
{
auto planarFigure = mitk::PlanarPolygon::New();
planarFigure->ClosedOn();
auto node = this->AddFigureToDataStorage(
planarFigure,
QString("Polygon%1").arg(++d->m_PolygonCounter));
node->SetProperty("planarfigure.isextendable", mitk::BoolProperty::New(true));
}
void QmitkMeasurementView::OnCopyToClipboard(bool)
{
QApplication::clipboard()->setText(d->m_SelectedPlanarFiguresText->toPlainText(), QClipboard::Clipboard);
}
mitk::DataNode::Pointer QmitkMeasurementView::AddFigureToDataStorage(mitk::PlanarFigure* figure, const QString& name)
{
auto newNode = mitk::DataNode::New();
newNode->SetName(name.toStdString());
newNode->SetData(figure);
newNode->SetSelected(true);
if (d->m_SelectedImageNode.IsNotNull())
{
this->GetDataStorage()->Add(newNode, d->m_SelectedImageNode);
}
else
{
this->GetDataStorage()->Add(newNode);
}
for (auto &node : d->m_CurrentSelection)
node->SetSelected(false);
d->m_CurrentSelection.clear();
d->m_CurrentSelection.push_back(newNode);
this->UpdateMeasurementText();
this->DisableCrosshairNavigation();
d->m_DrawActionsToolBar->setEnabled(false);
d->m_UnintializedPlanarFigure = true;
return newNode;
}
void QmitkMeasurementView::UpdateMeasurementText()
{
d->m_SelectedPlanarFiguresText->clear();
QString infoText;
QString plainInfoText;
int j = 1;
mitk::PlanarFigure::Pointer planarFigure;
mitk::PlanarAngle::Pointer planarAngle;
mitk::PlanarFourPointAngle::Pointer planarFourPointAngle;
mitk::DataNode::Pointer node;
for (int i = 0; i < d->m_CurrentSelection.size(); ++i, ++j)
{
plainInfoText.clear();
node = d->m_CurrentSelection[i];
planarFigure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
if (planarFigure.IsNull())
continue;
if (j > 1)
infoText.append("<br />");
infoText.append(QString("<b>%1</b><hr />").arg(QString::fromStdString(node->GetName())));
plainInfoText.append(QString("%1").arg(QString::fromStdString(node->GetName())));
planarAngle = dynamic_cast<mitk::PlanarAngle*> (planarFigure.GetPointer());
if (planarAngle.IsNull())
planarFourPointAngle = dynamic_cast<mitk::PlanarFourPointAngle*> (planarFigure.GetPointer());
double featureQuantity = 0.0;
for (unsigned int k = 0; k < planarFigure->GetNumberOfFeatures(); ++k)
{
if (!planarFigure->IsFeatureActive(k))
continue;
featureQuantity = planarFigure->GetQuantity(k);
if ((planarAngle.IsNotNull() && k == planarAngle->FEATURE_ID_ANGLE) || (planarFourPointAngle.IsNotNull() && k == planarFourPointAngle->FEATURE_ID_ANGLE))
featureQuantity = featureQuantity * 180 / vnl_math::pi;
infoText.append(QString("<i>%1</i>: %2 %3")
.arg(QString(planarFigure->GetFeatureName(k)))
.arg(featureQuantity, 0, 'f', 2)
.arg(QString(planarFigure->GetFeatureUnit(k))));
plainInfoText.append(QString("\n%1: %2 %3")
.arg(QString(planarFigure->GetFeatureName(k)))
.arg(featureQuantity, 0, 'f', 2)
.arg(QString(planarFigure->GetFeatureUnit(k))));
if (k + 1 != planarFigure->GetNumberOfFeatures())
infoText.append("<br />");
}
if (j != d->m_CurrentSelection.size())
infoText.append("<br />");
}
d->m_SelectedPlanarFiguresText->setHtml(infoText);
}
void QmitkMeasurementView::AddAllInteractors()
{
auto planarFigures = this->GetAllPlanarFigures();
for (auto it = planarFigures->Begin(); it != planarFigures->End(); ++it)
this->NodeAdded(it.Value());
}
void QmitkMeasurementView::EnableCrosshairNavigation()
{
// enable the crosshair navigation
// Re-enabling InteractionEventObservers that have been previously disabled for legacy handling of Tools
// in new interaction framework
for (const auto& displayInteractorConfig : m_DisplayInteractorConfigs)
{
if (displayInteractorConfig.first)
{
auto displayInteractor = static_cast<mitk::DisplayInteractor*>(us::GetModuleContext()->GetService<mitk::InteractionEventObserver>(displayInteractorConfig.first));
if (displayInteractor != nullptr)
{
// here the regular configuration is loaded again
displayInteractor->SetEventConfig(displayInteractorConfig.second);
}
}
}
m_DisplayInteractorConfigs.clear();
d->m_ScrollEnabled = true;
}
void QmitkMeasurementView::DisableCrosshairNavigation()
{
// dont deactivate twice, else we will clutter the config list ...
if (d->m_ScrollEnabled == false)
return;
// As a legacy solution the display interaction of the new interaction framework is disabled here to avoid conflicts with tools
// Note: this only affects InteractionEventObservers (formerly known as Listeners) all DataNode specific interaction will still be enabled
m_DisplayInteractorConfigs.clear();
auto eventObservers = us::GetModuleContext()->GetServiceReferences<mitk::InteractionEventObserver>();
for (const auto& eventObserver : eventObservers)
{
auto displayInteractor = dynamic_cast<mitk::DisplayInteractor*>(us::GetModuleContext()->GetService<mitk::InteractionEventObserver>(eventObserver));
if (displayInteractor != nullptr)
{
// remember the original configuration
m_DisplayInteractorConfigs.insert(std::make_pair(eventObserver, displayInteractor->GetEventConfig()));
// here the alternative configuration is loaded
displayInteractor->SetEventConfig("DisplayConfigMITKLimited.xml");
}
}
d->m_ScrollEnabled = false;
}
mitk::DataStorage::SetOfObjects::ConstPointer QmitkMeasurementView::GetAllPlanarFigures() const
{
auto isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
auto isNotHelperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(false));
auto isNotHelperButPlanarFigure = mitk::NodePredicateAnd::New( isPlanarFigure, isNotHelperObject );
return this->GetDataStorage()->GetSubset(isPlanarFigure);
}