diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
index e7ea6bd729..13a577d227 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurement.dox
@@ -1,126 +1,90 @@
/**
\page org_mitk_views_measurement The Measurement View
\imageMacro{measurement.svg,"Icon of the Measurement View",2.00}
-\section QmitkMeasurementUserManualOverview Overview
+<h1>Overview</h1>
-The Measurement view enables the user to interact with 2D images or single slices of 3D image stacks and planar figure data types. It allows to measure distances, angels, pathes and several geometric figures on a dataset.
+The Measurement view allows you to measure distances, angels, paths and several geometric figures on 2D images or image slices of 3D and 4D images. The measurement view is repeatedly useable with the same or different measurement figures, which are correlated to the chosen image and can be saved together with it for future use.
-\tableofcontents
-The workflow to use this view is:
+\imageMacro{QmitkMeasurementToolbox_BasicScreen_Edited.jpg,"Image with measurements",16.00}
-\imageMacro{QmitkMeasurementToolbox_Workflow.png,"",16.00}
-The workflow is repeatedly useable with the same or different measurement figures, which are correlated to the choosen image and can be saved together with it for future use. On pressing the Measurement icon (see picture below the page title) in the view button line the basic appearance of the view is as follws.
+<h1>Usage</h1>
-\imageMacro{QmitkMeasurementToolbox_BasicScreenEdited.jpg,"",16.00}
+The first step to perform measurements is to select a reference image on top of the view. All resulting measurements will be assigned as child nodes of the image in the data manager. The standard working plane is 'Axial' but the other standard view planes ('Saggital' and 'Coronal') are also valid for measurements.
-The standard working plane is "Axial" but the other standard viewplanes ("Saggital" and "Coronal") are also valid for measurements. To swap between the view planes refer to the application user manual.
-\section QmitkMeasurementUserManualFeatures Features
+\imageMacro{QmitkMeasurementToolbox_MeasurementView.jpg,"Measurement View",7.60}
-The view as it is depicted below offers the following features in the order of apperance on the image from top to bottom:
+After selecting an image, you can click on any of the geometrical symbols. The respective measurement will appear as soon as you click on the image location you want to measure.
-\imageMacro{QmitkMeasurementToolbox_MeasurementView.jpg,"",7.60}
+The view offers a variety of measurement options that are introduced in the following:
-The first information is the selected image's name (here: DICOM-MRI-Image) followed by the measurement figures button line with the seven measurement figures. From left to right the buttons are connected with the following functions:
+<ul>
+<li> <b>Line:</b>
-\subsection SubOne Draw Line
Draws a line between two set points and returns the distance between these points.
-\subsection SubTwo Draw Path
-Draws a path between several set points (two and more) and calculates the circumference, that is all line's length summed up. Add the final point by double left click.
+<li> <b>Path:</b>
-\subsection SubThree Draw Angle
-Draws two lines from three set points connected in the second set point and returns the inner angle at the second point.
+Draws a line between several set points (two and more) and calculates the overall length, which is all line's length summed up. Add the final point by double left-click.
-\subsection SubFour Draw Four Point Angle
-Draws two lines that may but must not intersect from four set points. The returned angle is the one depicted in the icon.
+<li> <b>Angle:</b>
-\subsection SubFive Draw Circle
-Draws a circle by setting two points, whereas the first set point is the center and the second the radius of the circle. The measured values are the radius and the included area.
+Draws two lines from three set points connected in the second set point and return the inner angle at the second point.
-\subsection SubSix Draw Rectangle
-Draws a rectangle by setting two points at the opposing edges of the rectangle starting with the upper left edge. The measured values are the circumference and the included area.
+<li> <b>Four Point / Double Angle:</b>
-\subsection SubSeven Draw Polygon
-Draws a polygon by setting three or more points. The measured values are the circumference and the included area. Add the final point by double left click.
+Draws two lines that may but must not intersect from four set points. The returned angle is the one depicted in the icon.
-Below the buttonline the statistics window is situated, it displays the results of the actual measurements from the selected measurement figures. The content of the statistics window can be copied to the clipboard with the correspondig button for further use in a table calculation programm (e.g. Open Office Calc etc.).
+<li> <b>Circle:</b>
-\imageMacro{QmitkMeasurementToolbox_ImageProcessed.jpg,"",7.56}
+Draws a circle by setting two points, whereas the first set point is the center and the second the radius of the circle. The measured values are the radius and the included area.
-The last row contains again a button line to swap from the measurement perspective (activated in the image) to other supported MITK perspectives.
+<li> <b>Ellipse:</b>
-\section QmitkMeasurementUserManualUsage Usage
+Draws an ellipse that can be modified by three points. The middle point can be used to move the whole measurement. The lower point modifies the ellipse axes. The right point can be used to modify the radius of the ellipse. The measured values are the major and minor axes and the area.
-This Section is subdivided into four subsections:
-<ol>
- <li><b>Add an image</b>
- <li><b>Work with measurement figures</b>
- <li><b>Save the image with measurement information</b>
- <li><b>Remove measurement figures or image</b>
-</ol>
+<li> <b>Double Ellipse:</b>
-Let's start with subsection 1
-\subsection One Add an image
+Draws two ellipses by adjusting four points. The middle point can be used to move the whole measurement. The left point is used to adjust the distance between the two ellipses. The lower point modifies the ellipse axes. The right point can be used to modify the radius of the ellipse. Can be used for measuring e.g. the wall thickness of a vessel. The measured values are the major and minor axes and the thickness.
-There are two possible ways to add an image to the programm. One is to grap the image with left mouse click from your prefered file browser and simply drag&drop it to the View Plane field. The other way is to use the
-\imageMacro{QmitkMeasurementToolbox_OpenButton.png,"",2.01}
-button in the upper left corner of the application. A dialog window appears showing the file tree of the computer. Navigate to the wanted file and select it with the left mouse click. Afterwards just use the dialog's open button.
+<li> <b>Rectangle:</b>
-The wanted image appears in the View Plane and in the Data Manager the images name appears as a new tree node. Now the image is loaded it can be adjusted in the usual way ( zoom in/out: right mouse button + moving the mouse up and down, moving the image: press mouse wheel and move the mouse to the wished direction, scroll through the slices( only on 3D images): scroll mouse wheel up and down).
+Draws a rectangle by setting two points at the opposing edges of the rectangle starting with the upper left edge. The measured values are the circumference and the included area.
-\imageMacro{QmitkMeasurementToolbox_ImageLoadedScreen.jpg,"",16.00}
+<li> <b>Polygon:</b>
-After the image is loaded the image's name appears in the Data Manager. By left-clicking on the image name the buttonline becomes activated.
+Draws a closed polygon that can have an arbitrary number of points. New points are added by left mouse-click. To finish the drawing the user can double click on the last control point. The measured values are circumference and area.
-\subsection Two Work with measurement figures
-The measurement view comes with seven measurement figures(see picture below), that can be applied to the images.
+<li> <b>Bezier curve:</b>
-\imageMacro{QmitkMeasurementToolbox_MeasurementFigureButtonLine.jpg,"",7.22}
+Draws a bezier curve by adding some control points with left mouse-click. To finish the drawing the user can double-click on the last control point. The measured value is the length of the bezier curve.
-The results of the measurement with each of these figures is shown in the statistics window and in the lower right corner of the view plane.
+<li> <b>Subdivision Polygon:</b>
-\imageMacro{QmitkMeasurementToolbox_ImageProcessedScreen.jpg,"",6.96}
+Draws a closed subdivision polygon by adding some control points with left mouse-click. To finish the drawing the user can double-click on the last control point. The measured value is the circumference of the polygon.
+</ul>
-When applying more then one measurement figure to the image the actual measurement figure is depicted in red and the displayed values belong to this measurement figure. All measurement figures become part of the Data Manager as a node of the image tree.
+<h2>Fixed sizes of measurement figures</h2>
+The measurement view offers a fixed size for circle and double ellipses to preset a radius and a thickness. This is useful e.g. for disagnostic studies where you want to derive gray value statistics from a well defined region.
-\subsection Three Save the image with measurement information
-After applying the wanted measurement figures the entire scene consisting of the image and the measurement figures can be saved for future use. Therefore just click the right mouse button when over the image item in the Data Manager and choose the item "Save" in the opening item list. Following to that a save dialog appears where the path to the save folder can be set. Afterwards just accept your choice with the save button.
+<h2>Modify measurements</h2>
-\subsection Four Remove measurement figures or image
-If the single measurement figures or the image is not needed any longer, it can be removed solely or as an entire group. The image can't be removed without simultaneously removing all the dependent measurement figures that belong to the image tree in the Data Manager. To remove just select the wanted items in the data manager list by left-click on it or if several items wanted to be removed left click on all wanted by simultaneously holding the ctrl-button pressed.
+All measurements can be modified later on by moving the respective control points. Note that they can only be modified if the view is open.
-For more detailed usage of the save/remove functionality refer to the Data Manager User Manual.
+<h2>Multiple measurement figures</h2>
-<!-- <ul>
- <li> The Measurement Module is able to measure:
- <ul>
- <li> Distances between two points
- <li> Angles between two lines (defined by three points)
- <li> Distances along a path
- </ul>
-</ul>
+When applying more than one measurement figure to the image the actual measurement figure is depicted in red and the displayed values belong to this measurement figure. All other measurement figures appear white. They can be selected by a left-mouse click on the respective node.
-\section QmitkMeasurementUserManualUsage Usage
-To use the Measurement Module, at first a data set must be loaded. That can be done by drag & drop.
-Choose the measurement method you need by pressing the according button.
-<ul>
- <li>Points can be set by "shift-clicking" on the place in the data set.
- <li>Remove points by pressing the del-button on your keyboard.
- <li>You can mark a point by clickon it with the cursor and move it while the mouse button is still pressed.
-</ul>
-What the different modes mean and how to use them:
-<ul>
- <li> a) Distances: To measure the distance between two points, you have to set two points. The distance will be displayed on the line between the points.
- <li> b) Angles: Angles can be measured between two lines. For that you have to set three points. The angle will be displayed between the two lines.
- <li> c) Path: Distances and angles along a path can be measured by setting at least two (for distance) or three (for angles) or more (for longer pathes) points. The distance and the angles for each part will be displayed next to the path.
-</ul>
-\imageMacro{QmitkMeasurementToolbox_MeasurementGUI.png,"Graphical User Interface of Measurement -->",16.00}
+<h2>Save the measurement information</h2>
+The entire scene containing the image and the measurement figures can be saved for future use. Scenes are saved with a '.mitk' extension by pressing 'Save Project' and contain all nodes and relevant information. Alternatively, you can just save the measurement solely (with file extension '.pf') by right-click on the node in the data manager.
-*/
+The content of the measurement widget can be copied to the clipboard with the corresponding button for further use in a table calculation program (e.g. Open Office Calc etc.).
+<h2>Remove measurement figures or image</h2>
+If the single measurement figures or the image is not needed any longer, it can be removed solely or as an entire group. The image can't be removed without simultaneously removing all the dependent measurement figures that belong to the image tree in the data manager. To remove just select the wanted items in the data manager list by left-clicking on the respective node or, if several items wanted to be removed, left-click on all wanted by simultaneously holding the ctrl-button pressed.
+*/
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
index 811c479e3e..c3f1ed2e58 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox.dox
@@ -1,12 +1,12 @@
/**
\page org_mitk_gui_qt_measurementtoolbox The Measurement Toolbox
-\section QmitkmeasurementToolbox Manual
+<h1>QmitkmeasurementToolbox Manual</h1>
This plugin contains all views that provide measurement and statistics functionality.
<ul>
<li> \subpage org_mitk_views_measurement
<li> \subpage org_mitk_views_imagestatistics
</ul>
*/
\ No newline at end of file
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_BasicScreenEdited.jpg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_BasicScreenEdited.jpg
deleted file mode 100644
index 13446ab25f..0000000000
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_BasicScreenEdited.jpg and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_BasicScreen_Edited.jpg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_BasicScreen_Edited.jpg
new file mode 100644
index 0000000000..708aa039d1
Binary files /dev/null and b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_BasicScreen_Edited.jpg differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageLoadedScreen.jpg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageLoadedScreen.jpg
deleted file mode 100644
index 71abc0236e..0000000000
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageLoadedScreen.jpg and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageProcessed.jpg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageProcessed.jpg
deleted file mode 100644
index 88514a9d30..0000000000
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageProcessed.jpg and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageProcessedScreen.jpg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageProcessedScreen.jpg
deleted file mode 100644
index 01c5de3526..0000000000
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_ImageProcessedScreen.jpg and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementFigureButtonLine.jpg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementFigureButtonLine.jpg
deleted file mode 100644
index 02dc8951f8..0000000000
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementFigureButtonLine.jpg and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementGUI.png b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementGUI.png
deleted file mode 100644
index d80789bf41..0000000000
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementGUI.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementView.jpg b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementView.jpg
index 12b94152bd..db04c46943 100644
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementView.jpg and b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_MeasurementView.jpg differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_OpenButton.png b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_OpenButton.png
deleted file mode 100644
index 1ec53342b1..0000000000
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_OpenButton.png and /dev/null differ
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_Workflow.png b/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_Workflow.png
deleted file mode 100644
index 32fbfc5cf2..0000000000
Binary files a/Plugins/org.mitk.gui.qt.measurementtoolbox/documentation/UserManual/QmitkMeasurementToolbox_Workflow.png and /dev/null differ
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 f471a8a318..2954c3715c 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,871 +1,872 @@
/*============================================================================
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)
{
}
mitk::PlanarFigure::Pointer m_Figure;
unsigned int m_EndPlacementObserverTag;
unsigned int m_SelectObserverTag;
unsigned int m_StartInteractionObserverTag;
unsigned int m_EndInteractionObserverTag;
};
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;
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->SetAutoSelectNewNodes(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->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_Layout = new QGridLayout;
d->m_Layout->addWidget(d->m_SingleNodeSelectionWidget, 0, 0, 1, 2);
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();
}
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);
}
else
{
d->m_SelectedImageNode = nodes.front();
d->m_DrawActionsToolBar->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
auto endInteractionCommand = SimpleCommandType::New();
endInteractionCommand->SetCallbackFunction(this, &QmitkMeasurementView::EnableCrosshairNavigation);
data.m_EndInteractionObserverTag = planarFigure->AddObserver(mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand);
// 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);
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);
}