diff --git a/Modules/Core/include/mitkDisplayActionEventBroadcast.h b/Modules/Core/include/mitkDisplayActionEventBroadcast.h
index d2470f5854..30066977f8 100644
--- a/Modules/Core/include/mitkDisplayActionEventBroadcast.h
+++ b/Modules/Core/include/mitkDisplayActionEventBroadcast.h
@@ -1,224 +1,218 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#ifndef MITKDISPLAYACTIONEVENTBROADCAST_H
#define MITKDISPLAYACTIONEVENTBROADCAST_H
#include "mitkInteractionEventObserver.h"
#include <MitkCoreExports.h>
namespace mitk
{
/**
* @brief This class serves as an event state machine while simultaneously observing interaction events.
* It connects the actions from the event state machine .xml-file with concrete functions of this class.
*
* The observed interaction events are mouse events that trigger certain actions, according to an event configuration (e.g. PACS mode).
* These actions are defined and connected inside this broadcast class.
* They typically contain some preprocessing steps and use the results of the preprocessing to broadcast a specific display event.
*
* Any instance that wants to react on the invoked events can call 'AddObserver' on a specific broadcast instance,
* given an itkEventObject and an itkCommand.
*/
class MITKCORE_EXPORT DisplayActionEventBroadcast : public EventStateMachine, public InteractionEventObserver
{
public:
mitkClassMacro(DisplayActionEventBroadcast, EventStateMachine);
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
/**
* By this function this observer is notified about about every 'InteractionEvent'.
* The interaction event is passed to the state machine in order to use its infrastructure.
* For more information see @see InteractionEventObserver.
*
* @par interactionEvent The event that was observed and triggered this notification.
* @par isHandled Flag that indicates if a 'DataInteractor' has already handled the event.
*/
void Notify(InteractionEvent* interactionEvent, bool isHandled) override;
protected:
DisplayActionEventBroadcast();
~DisplayActionEventBroadcast() override;
/**
* @brief Connects the action names used in the state machine pattern with functions implemented within this InteractionEventObserver.
*/
void ConnectActionsAndFunctions() override;
/**
* @brief This function is executed when a config object is set / changed (via 'SetEventConfig' or 'AddEventConfig' in 'InteractionEventObserver').
* It is used to read out the parameters set in the configuration file and to set the member variables accordingly.
*/
void ConfigurationChanged() override;
/**
* @brief Filters the event resp. the sender of the event.
*
* @par interactionEvent The event whose sender has to be checked
* @par data node The data node is ignored in this specific implementation.
*
* @return True, if the sender of the event is a valid sender and the sending renderer is a 2D-renderer. False, if not.
*/
bool FilterEvents(InteractionEvent* interactionEvent, DataNode* dataNode) override;
//////////////////////////////////////////////////////////////////////////
// Functions to react to interaction events (actions)
//////////////////////////////////////////////////////////////////////////
/**
* @brief Check if the given interaction event is actually an 'InteractionPositionEvent'.
*
* @par interactionEvent The interaction event that is checked.
*
* @return True, if the given event can be dynamically cast to an 'InteractionPositionEvent'. False, if not.
*/
bool CheckPositionEvent(const InteractionEvent* interactionEvent);
bool CheckRotationPossible(const InteractionEvent* interactionEvent);
bool CheckSwivelPossible(const InteractionEvent* interactionEvent);
void Init(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void Move(StateMachineAction* stateMachineAction , InteractionEvent* interactionEvent);
void SetCrosshair(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void Zoom(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void Scroll(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void ScrollOneUp(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void ScrollOneDown(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void AdjustLevelWindow(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void StartRotation(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void EndRotation(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void Rotate(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void Swivel(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void IncreaseTimeStep(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
void DecreaseTimeStep(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
private:
- void UpdateStatusbar(StateMachineAction* stateMachineAction, InteractionEvent* interactionEvent);
-
bool GetBoolProperty(PropertyList::Pointer propertyList, const char* propertyName, bool defaultValue);
/**
* @brief Reference to the service registration of the observer.
* This is needed to unregister the observer on unload.
*/
us::ServiceRegistration<InteractionEventObserver> m_ServiceRegistration;
/**
* @brief Determines if this broadcast class reacts to events that already have been processed by a DataInteractor.
* The default value is false.
*/
bool m_AlwaysReact;
/**
* @brief Coordinate of the mouse pointer at beginning of an interaction (translated to mm unit).
*/
Point2D m_StartCoordinateInMM;
/**
* @brief Coordinate of the mouse pointer in the last step within an interaction.
*/
Point2D m_LastDisplayCoordinate;
/**
- * @brief Coordinate of the mouse pointer in the last step within an interaction (translated to mm unit).
- */
- Point2D m_LastCoordinateInMM;
- /**
* \brief Current coordinates of the pointer.
*/
Point2D m_CurrentDisplayCoordinate;
/**
* @brief Defines the behavior at the end of a data set.
* If set to true, it will restart at end of data set from the beginning.
*/
bool m_AutoRepeat;
/**
* @brief Defines how many slices are scrolled per pixel that the mouse pointer was moved.
* By default the modifier is 4. This means that when the user moves the cursor by 4 pixels in Y-direction,
* the scene is scrolled by one slice. If the user has moved the the cursor by 20 pixels, the scene is
* scrolled by 5 slices.
*
* If the cursor has moved less than m_IndexToSliceModifier pixels, the scene is scrolled by one slice.
*/
int m_IndexToSliceModifier;
/**
* @brief Defines the scroll behavior.
* Default is up/down movement of pointer performs scrolling
*/
std::string m_ScrollDirection;
/**
* @brief Defines how the axis of interaction influences scroll behavior.
*/
bool m_InvertScrollDirection;
/**
* @brief Defines the zoom behavior.
* Default is up/down movement of pointer performs zooming
*/
std::string m_ZoomDirection;
/**
* @brief Defines how the axis of interaction influences zoom behavior.
*/
bool m_InvertZoomDirection;
/**
* @brief Factor to adjust zooming speed.
*/
float m_ZoomFactor;
/**
* @brief Defines how the axis of interaction influences move behavior.
*/
bool m_InvertMoveDirection;
/**
* @brief Defines the level-window behavior.
* Default is left/right movement of pointer modifies the level.
*/
std::string m_LevelDirection;
/**
* @brief Defines how the axis of interaction influences level-window behavior.
*/
bool m_InvertLevelWindowDirection;
/**
* @brief Determines if the angle between crosshair remains fixed when rotating.
*/
bool m_LinkPlanes;
typedef std::vector<SliceNavigationController*> SNCVector;
SNCVector m_RotatableSNCs;
SNCVector m_SNCsToBeRotated;
Point3D m_LastCursorPosition;
Point3D m_CenterOfRotation;
Point2D m_ReferenceCursor;
Vector3D m_RotationPlaneNormal;
Vector3D m_RotationPlaneXVector;
Vector3D m_RotationPlaneYVector;
Vector3D m_PreviousRotationAxis;
ScalarType m_PreviousRotationAngle;
};
} // end namespace
#endif // MITKDISPLAYACTIONEVENTBROADCAST_H
diff --git a/Modules/Core/resource/Interactions/DisplayInteraction.xml b/Modules/Core/resource/Interactions/DisplayInteraction.xml
index 81e8d9e23f..82a24b1299 100644
--- a/Modules/Core/resource/Interactions/DisplayInteraction.xml
+++ b/Modules/Core/resource/Interactions/DisplayInteraction.xml
@@ -1,175 +1,165 @@
<!--
State machine pattern for display interactions:
-Zooming
-Panning
-Scrolling through planes
-Adjusting the LevelWindow
For some interactions several transitions exists, which one is used can be determined by the configuration file.
If an event_variant is not declared in the configuration file it is disabled.
For example scrolling can be triggered by Key-, Wheel- or MouseMove events, where the latter needs an extra state for scrolling.
So they are triggered by different event_variants, to choose which one is used, describe the desired event_variant in a config file
and omit the others. See DisplayConfig___ for examples and also for parameters for the interaction behaviour.
TODO Std move to abort interaction of scroll/pan/zoom
-->
<statemachine>
<state name="start" startstate="true" >
<transition event_class="InteractionPositionEvent" event_variant="StartMove" target="move">
<condition name="check_position_event"/>
<action name="init"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="StartZoom" target="zoom">
<condition name="check_position_event"/>
<action name="init"/>
</transition>
<!-- mitkDisplayInteractor.cpp implements this for all events -->
<transition event_class="InteractionEvent" event_variant="PlaneUP" target="start">
<action name="ScrollOneUp"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="InteractionEvent" event_variant="PlaneDown" target="start">
<action name="ScrollOneDown"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="MousePressEvent" event_variant="StartScroll" target="scroll">
<action name="init"/>
</transition>
<transition event_class="MousePressEvent" event_variant="StartAdjustLevelWindow" target="adjustlevelwindow">
<action name="init"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="SetCrosshair" target="crosshair">
<action name="setCrosshair"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="Move" target="rotationPossible">
<condition name="check_can_rotate"/>
<action name="startRotation"/>
</transition>
<!-- Case when we do crosshair instead of rotation) -->
<transition event_class="InteractionPositionEvent" event_variant="StartRotate" target="crosshair">
<condition name="check_can_rotate" inverted="true" />
<action name="setCrosshair"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="StartSwivel" target="swivel">
<condition name="check_can_swivel"/>
</transition>
<!-- Case when we do crosshair instead of swivel) -->
<transition event_class="InteractionPositionEvent" event_variant="StartSwivel" target="crosshair">
<condition name="check_can_swivel" inverted="true"/>
<action name="setCrosshair"/>
- <action name="updateStatusbar"/>
</transition>
<!-- Change TimeSteps by clicking left or right Arrow-->
<transition event_class="InteractionEvent" event_variant="IncreaseTimeStep" target="start">
<action name="IncreaseTimeStep"/>
</transition>
<transition event_class="InteractionEvent" event_variant="DecreaseTimeStep" target="start">
<action name="DecreaseTimeStep"/>
</transition>
</state>
<state name="crosshair">
<transition event_class="InteractionPositionEvent" event_variant="MoveCrosshair" target="crosshair">
<action name="setCrosshair"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndMoveCrosshair" target="start"/>
<!-- Case when we jumped in from rotation (wanted to rotate, but not possible, so alternative action is to set crosshair) -->
<transition event_class="InteractionPositionEvent" event_variant="Rotate" target="crosshair">
<action name="setCrosshair"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndRotate" target="start"/>
<!-- Case when we do crosshair instead of swivel) -->
<transition event_class="InteractionPositionEvent" event_variant="Swivel" target="crosshair">
<action name="setCrosshair"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndSwivel" target="start"/>
<transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
</state>
<state name="move">
<transition event_class="InteractionPositionEvent" event_variant="Moving" target="move">
<condition name="check_position_event"/>
<action name="move"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndMoving" target="start"/>
<transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
</state>
<state name="zoom">
<transition event_class="InteractionPositionEvent" event_variant="Zooming" target="zoom">
<condition name="check_position_event"/>
<action name="zoom"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndZooming" target="start"/>
<transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
</state>
<state name="scroll">
<transition event_class="InteractionPositionEvent" event_variant="Scrolling" target="scroll">
<condition name="check_position_event"/>
<action name="scroll"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndScrolling" target="start"/>
<transition event_class="InteractionPositionEvent" event_variant="EndScrollingVar" target="start"/>
<transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
</state>
<state name="adjustlevelwindow">
<transition event_class="InteractionPositionEvent" event_variant="adjustlevelwindow" target="adjustlevelwindow">
<condition name="check_position_event"/>
<action name="levelWindow"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndLevelWindow" target="start"/>
<transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
</state>
<state name="rotationPossible">
<transition event_class="InteractionPositionEvent" event_variant="StartRotate" target="rotation">
<action name="rotate"/>
</transition>
<transition event_class="InternalEvent" event_variant="LeaveRenderWindow" target="start">
<action name="endRotation"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="Move" target="start">
<condition name="check_can_rotate" inverted="true" />
<action name="endRotation"/>
</transition>
<transition event_class="InteractionEvent" event_variant="PlaneUP" target="rotationPossible">
<action name="ScrollOneUp"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="InteractionEvent" event_variant="PlaneDown" target="rotationPossible">
<action name="ScrollOneDown"/>
- <action name="updateStatusbar"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="StartMove" target="move">
<condition name="check_position_event"/>
<action name="init"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="StartZoom" target="zoom">
<condition name="check_position_event"/>
<action name="init"/>
</transition>
<transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
</state>
<state name="rotation">
<transition event_class="InteractionPositionEvent" event_variant="Rotate" target="rotation">
<action name="rotate"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndRotate" target="start">
<action name="endRotation"/>
</transition>
<transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
</state>
<state name="swivel">
<transition event_class="InteractionPositionEvent" event_variant="Swivel" target="swivel">
<action name="swivel"/>
</transition>
<transition event_class="InteractionPositionEvent" event_variant="EndSwivel" target="start"/>
<transition event_class="InteractionEvent" event_variant="ResetState" target="start"/>
</state>
</statemachine>
diff --git a/Modules/Core/src/Interactions/mitkDisplayActionEventBroadcast.cpp b/Modules/Core/src/Interactions/mitkDisplayActionEventBroadcast.cpp
index 673085af97..c42172fe75 100644
--- a/Modules/Core/src/Interactions/mitkDisplayActionEventBroadcast.cpp
+++ b/Modules/Core/src/Interactions/mitkDisplayActionEventBroadcast.cpp
@@ -1,917 +1,807 @@
/*============================================================================
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 "mitkDisplayActionEventBroadcast.h"
// us
#include "usGetModuleContext.h"
#include "usModuleContext.h"
// mitk core module
-#include <mitkCompositePixelValueToString.h>
#include <mitkDisplayActionEvents.h>
#include <mitkImage.h>
-#include <mitkImagePixelReadAccessor.h>
#include <mitkInteractionConst.h>
#include <mitkInteractionPositionEvent.h>
#include <mitkLine.h>
-#include <mitkNodePredicateDataType.h>
-#include <mitkPixelTypeMultiplex.h>
#include <mitkRotationOperation.h>
-#include <mitkStatusBar.h>
#include <rotate_cursor.xpm>
mitk::DisplayActionEventBroadcast::DisplayActionEventBroadcast()
: m_AlwaysReact(false)
, m_AutoRepeat(false)
, m_IndexToSliceModifier(4)
, m_InvertScrollDirection(false)
, m_InvertZoomDirection(false)
, m_ZoomFactor(2)
, m_InvertMoveDirection(false)
, m_InvertLevelWindowDirection(false)
, m_LinkPlanes(true)
{
m_StartCoordinateInMM.Fill(0);
m_LastDisplayCoordinate.Fill(0);
- m_LastCoordinateInMM.Fill(0);
m_CurrentDisplayCoordinate.Fill(0);
// register the broadcast class (itself) as an interaction event observer via micro services
us::ServiceProperties props;
props["name"] = std::string("DisplayActionEventBroadcast");
m_ServiceRegistration = us::GetModuleContext()->RegisterService<InteractionEventObserver>(this, props);
}
mitk::DisplayActionEventBroadcast::~DisplayActionEventBroadcast()
{
m_ServiceRegistration.Unregister();
}
void mitk::DisplayActionEventBroadcast::Notify(InteractionEvent* interactionEvent, bool isHandled)
{
// the event is passed to the state machine interface to be handled
if (!isHandled || m_AlwaysReact)
{
HandleEvent(interactionEvent, nullptr);
}
}
void mitk::DisplayActionEventBroadcast::ConnectActionsAndFunctions()
{
CONNECT_CONDITION("check_position_event", CheckPositionEvent);
CONNECT_CONDITION("check_can_rotate", CheckRotationPossible);
CONNECT_CONDITION("check_can_swivel", CheckSwivelPossible);
CONNECT_FUNCTION("init", Init);
CONNECT_FUNCTION("move", Move);
CONNECT_FUNCTION("zoom", Zoom);
CONNECT_FUNCTION("scroll", Scroll);
CONNECT_FUNCTION("ScrollOneUp", ScrollOneUp);
CONNECT_FUNCTION("ScrollOneDown", ScrollOneDown);
CONNECT_FUNCTION("levelWindow", AdjustLevelWindow);
CONNECT_FUNCTION("setCrosshair", SetCrosshair);
- CONNECT_FUNCTION("updateStatusbar", UpdateStatusbar)
-
CONNECT_FUNCTION("startRotation", StartRotation);
CONNECT_FUNCTION("endRotation", EndRotation);
CONNECT_FUNCTION("rotate", Rotate);
CONNECT_FUNCTION("swivel", Swivel);
CONNECT_FUNCTION("IncreaseTimeStep", IncreaseTimeStep);
CONNECT_FUNCTION("DecreaseTimeStep", DecreaseTimeStep);
}
void mitk::DisplayActionEventBroadcast::ConfigurationChanged()
{
PropertyList::Pointer properties = GetAttributes();
// alwaysReact
std::string strAlwaysReact = "";
m_AlwaysReact = false;
if (properties->GetStringProperty("alwaysReact", strAlwaysReact))
{
if (strAlwaysReact == "true")
{
m_AlwaysReact = true;
}
}
// auto repeat
std::string strAutoRepeat = "";
m_AutoRepeat = false;
if (properties->GetStringProperty("autoRepeat", strAutoRepeat))
{
if (strAutoRepeat == "true")
{
m_AutoRepeat = true;
}
}
// pixel movement for scrolling one slice
std::string strPixelPerSlice = "";
m_IndexToSliceModifier = 4;
if (properties->GetStringProperty("pixelPerSlice", strPixelPerSlice))
{
m_IndexToSliceModifier = atoi(strPixelPerSlice.c_str());
}
// scroll direction
if (!properties->GetStringProperty("scrollDirection", m_ScrollDirection))
{
m_ScrollDirection = "updown";
}
m_InvertScrollDirection = GetBoolProperty(properties, "invertScrollDirection", false);
// zoom direction
if (!properties->GetStringProperty("zoomDirection", m_ZoomDirection))
{
m_ZoomDirection = "updown";
}
m_InvertZoomDirection = GetBoolProperty(properties, "invertZoomDirection", false);
m_InvertMoveDirection = GetBoolProperty(properties, "invertMoveDirection", false);
if (!properties->GetStringProperty("levelWindowDirection", m_LevelDirection))
{
m_LevelDirection = "leftright";
}
m_InvertLevelWindowDirection = GetBoolProperty(properties, "invertLevelWindowDirection", false);
// coupled rotation
std::string strCoupled = "";
m_LinkPlanes = false;
if (properties->GetStringProperty("coupled", strCoupled))
{
if (strCoupled == "true")
{
m_LinkPlanes = true;
}
}
// zoom factor
std::string strZoomFactor = "";
properties->GetStringProperty("zoomFactor", strZoomFactor);
m_ZoomFactor = .05;
if (atoi(strZoomFactor.c_str()) > 0)
{
m_ZoomFactor = 1.0 + (atoi(strZoomFactor.c_str()) / 100.0);
}
}
bool mitk::DisplayActionEventBroadcast::FilterEvents(InteractionEvent* interactionEvent, DataNode * /*dataNode*/)
{
BaseRenderer* sendingRenderer = interactionEvent->GetSender();
if (nullptr == sendingRenderer)
{
return false;
}
if (BaseRenderer::Standard3D == sendingRenderer->GetMapperID())
{
return false;
}
return true;
}
bool mitk::DisplayActionEventBroadcast::CheckPositionEvent(const InteractionEvent *interactionEvent)
{
const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return false;
}
return true;
}
bool mitk::DisplayActionEventBroadcast::CheckRotationPossible(const InteractionEvent *interactionEvent)
{
// Decide between moving and rotation slices.
/*
Detailed logic:
1. Find the SliceNavigationController that has sent the event: this one defines our rendering plane and will NOT be
rotated. Needs not even be counted or checked.
2. Inspect every other SliceNavigationController
- calculate the line intersection of this SliceNavigationController's plane with our rendering plane
- if there is NO intersection, ignore and continue
- IF there is an intersection
- check the mouse cursor's distance from that line.
0. if the line is NOT near the cursor, remember the plane as "one of the other planes" (which can be rotated in
"locked" mode)
1. on first line near the cursor, just remember this intersection line as THE other plane that we want to rotate
2. on every consecutive line near the cursor, check if the line is geometrically identical to the line that we want to
rotate
- if yes, we just push this line to the "other" lines and rotate it along
- if no, then we have a situation where the mouse is near two other lines (e.g. crossing point) and don't want to
rotate
*/
const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return false;
}
BaseRenderer* renderer = positionEvent->GetSender();
if (nullptr == renderer)
{
return false;
}
const PlaneGeometry* rendererWorldPlaneGeometry = renderer->GetCurrentWorldPlaneGeometry();
if (nullptr == rendererWorldPlaneGeometry)
{
return false;
}
Point3D position = positionEvent->GetPositionInWorld();
const auto spacing = rendererWorldPlaneGeometry->GetSpacing();
const PlaneGeometry *geometryToBeRotated = nullptr; // this one is under the mouse cursor
const PlaneGeometry *anyOtherGeometry = nullptr; // this is also visible (for calculation of intersection ONLY)
Line3D intersectionLineWithGeometryToBeRotated;
bool hitMultipleLines(false);
m_SNCsToBeRotated.clear();
const ScalarType threshholdDistancePixels = 12.0;
auto allRenderWindows = RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
for (auto renderWindow : allRenderWindows)
{
SliceNavigationController* snc = BaseRenderer::GetInstance(renderWindow)->GetSliceNavigationController();
// If the mouse cursor is in 3D Renderwindow, do not check for intersecting planes.
if (BaseRenderer::Standard3D == BaseRenderer::GetInstance(renderWindow)->GetMapperID())
{
continue;
}
const PlaneGeometry* rendererPlaneGeometry = snc->GetCurrentPlaneGeometry();
if (nullptr == rendererPlaneGeometry)
{
continue; // ignore, we don't see a plane
}
// check if there is an intersection between rendered / clicked geometry and the one being analyzed
Line3D intersectionLine;
if (!rendererWorldPlaneGeometry->IntersectionLine(rendererPlaneGeometry, intersectionLine))
{
continue; // we ignore this plane, it's parallel to our plane
}
// check distance from intersection line
const double distanceFromIntersectionLine = intersectionLine.Distance(position) / spacing[snc->GetDefaultViewDirection()];
// far away line, only remember for linked rotation if necessary
if (distanceFromIntersectionLine > threshholdDistancePixels)
{
// we just take the last one, so overwrite each iteration (we just need some crossing point)
// TODO what about multiple crossings? NOW we have undefined behavior / random crossing point is used
anyOtherGeometry = rendererPlaneGeometry;
if (m_LinkPlanes)
{
// if planes are linked, apply rotation to all planes
m_SNCsToBeRotated.push_back(snc);
}
}
else // close to cursor
{
if (nullptr == geometryToBeRotated) // first one close to the cursor
{
geometryToBeRotated = rendererPlaneGeometry;
intersectionLineWithGeometryToBeRotated = intersectionLine;
m_SNCsToBeRotated.push_back(snc);
}
else
{
// compare to the line defined by geometryToBeRotated: if identical, just rotate this otherRenderersRenderPlane
// together with the primary one
// if different, DON'T rotate
if (intersectionLine.IsParallel(intersectionLineWithGeometryToBeRotated)
&& intersectionLine.Distance(intersectionLineWithGeometryToBeRotated.GetPoint1()) < eps)
{
m_SNCsToBeRotated.push_back(snc);
}
else
{
hitMultipleLines = true;
}
}
}
}
bool moveSlices(true);
if (geometryToBeRotated && anyOtherGeometry && rendererWorldPlaneGeometry && !hitMultipleLines)
{
// assure all three are valid, so calculation of center of rotation can be done
moveSlices = false;
}
// question in state machine is: "rotate?"
if (moveSlices) // i.e. NOT rotate
{
return false;
}
else
{
// we have enough information for rotation
// remember where the last cursor position ON THE LINE has been observed
m_LastCursorPosition = intersectionLineWithGeometryToBeRotated.Project(position);
// find center of rotation by intersection with any of the OTHER lines
if (anyOtherGeometry->IntersectionPoint(intersectionLineWithGeometryToBeRotated, m_CenterOfRotation))
{
return true;
}
else
{
return false;
}
}
return false;
}
bool mitk::DisplayActionEventBroadcast::CheckSwivelPossible(const InteractionEvent *interactionEvent)
{
// Decide between moving and rotation: if we're close to the crossing
// point of the planes, moving mode is entered, otherwise
// rotation/swivel mode
const auto* positionEvent = dynamic_cast<const InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return false;
}
BaseRenderer* renderer = positionEvent->GetSender();
if (nullptr == renderer)
{
return false;
}
const Point3D& position = positionEvent->GetPositionInWorld();
m_SNCsToBeRotated.clear();
const PlaneGeometry* clickedGeometry(nullptr);
const PlaneGeometry* otherGeometry1(nullptr);
const PlaneGeometry* otherGeometry2(nullptr);
const ScalarType threshholdDistancePixels = 6.0;
auto allRenderWindows = RenderingManager::GetInstance()->GetAllRegisteredRenderWindows();
for (auto renderWindow : allRenderWindows)
{
SliceNavigationController* snc = BaseRenderer::GetInstance(renderWindow)->GetSliceNavigationController();
// If the mouse cursor is in 3D Renderwindow, do not check for intersecting planes.
if (BaseRenderer::Standard3D == BaseRenderer::GetInstance(renderWindow)->GetMapperID())
{
continue;
}
const PlaneGeometry* rendererPlaneGeometry = snc->GetCurrentPlaneGeometry();
if (nullptr == rendererPlaneGeometry)
{
continue; // ignore, we don't see a plane
}
if (snc == renderer->GetSliceNavigationController())
{
clickedGeometry = rendererPlaneGeometry;
m_SNCsToBeRotated.push_back(snc);
}
else
{
if (nullptr == otherGeometry1)
{
otherGeometry1 = rendererPlaneGeometry;
}
else
{
otherGeometry2 = rendererPlaneGeometry;
}
if (m_LinkPlanes)
{
// if planes are linked, apply rotation to all planes
m_SNCsToBeRotated.push_back(snc);
}
}
}
Line3D line;
Point3D point;
if ((nullptr != clickedGeometry) && (nullptr != otherGeometry1) && (nullptr != otherGeometry2)
&& clickedGeometry->IntersectionLine(otherGeometry1, line) && otherGeometry2->IntersectionPoint(line, point))
{
m_CenterOfRotation = point;
if (m_CenterOfRotation.EuclideanDistanceTo(position) < threshholdDistancePixels)
{
return false;
}
else
{
m_ReferenceCursor = positionEvent->GetPointerPositionOnScreen();
// Get main axes of rotation plane and store it for rotation step
m_RotationPlaneNormal = clickedGeometry->GetNormal();
ScalarType xVector[] = { 1.0, 0.0, 0.0 };
ScalarType yVector[] = { 0.0, 1.0, 0.0 };
clickedGeometry->BaseGeometry::IndexToWorld(Vector3D(xVector), m_RotationPlaneXVector);
clickedGeometry->BaseGeometry::IndexToWorld(Vector3D(yVector), m_RotationPlaneYVector);
m_RotationPlaneNormal.Normalize();
m_RotationPlaneXVector.Normalize();
m_RotationPlaneYVector.Normalize();
m_PreviousRotationAxis.Fill(0.0);
m_PreviousRotationAxis[2] = 1.0;
m_PreviousRotationAngle = 0.0;
return true;
}
}
else
{
return false;
}
return false;
}
void mitk::DisplayActionEventBroadcast::Init(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
m_CurrentDisplayCoordinate = m_LastDisplayCoordinate;
positionEvent->GetSender()->DisplayToPlane(m_LastDisplayCoordinate, m_StartCoordinateInMM);
- m_LastCoordinateInMM = m_StartCoordinateInMM;
}
void mitk::DisplayActionEventBroadcast::Move(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
BaseRenderer* sender = interactionEvent->GetSender();
Vector2D moveVector = m_LastDisplayCoordinate - positionEvent->GetPointerPositionOnScreen();
if (m_InvertMoveDirection)
{
moveVector *= -1.0;
}
moveVector *= sender->GetScaleFactorMMPerDisplayUnit(); // #TODO: put here?
// store new display coordinate
m_LastDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
// propagate move event with computed geometry values
InvokeEvent(DisplayMoveEvent(interactionEvent, moveVector));
}
void mitk::DisplayActionEventBroadcast::SetCrosshair(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
Point3D position = positionEvent->GetPositionInWorld();
// propagate set crosshair event with computed geometry values
InvokeEvent(DisplaySetCrosshairEvent(interactionEvent, position));
}
void mitk::DisplayActionEventBroadcast::Zoom(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
float factor = 1.0;
float distance = 0;
if (m_ZoomDirection == "updown")
{
distance = m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1];
}
else
{
distance = m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0];
}
if (m_InvertZoomDirection)
{
distance *= -1.0;
}
// set zooming speed
if (distance < 0.0)
{
factor = 1.0 / m_ZoomFactor;
}
else if (distance > 0.0)
{
factor = 1.0 * m_ZoomFactor;
}
// store new display coordinates
m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
// propagate zoom event with computed geometry values
InvokeEvent(DisplayZoomEvent(interactionEvent, factor, m_StartCoordinateInMM));
}
void mitk::DisplayActionEventBroadcast::Scroll(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
int sliceDelta = 0;
// scroll direction
if (m_ScrollDirection == "updown")
{
sliceDelta = static_cast<int>(m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1]);
}
else
{
sliceDelta = static_cast<int>(m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0]);
}
if (m_InvertScrollDirection)
{
sliceDelta *= -1;
}
// set how many pixels the mouse has to be moved to scroll one slice
// if the mouse has been moved less than 'm_IndexToSliceModifier', pixels slice ONE slice only
if (sliceDelta > 0 && sliceDelta < m_IndexToSliceModifier)
{
sliceDelta = m_IndexToSliceModifier;
}
else if (sliceDelta < 0 && sliceDelta > -m_IndexToSliceModifier)
{
sliceDelta = -m_IndexToSliceModifier;
}
sliceDelta /= m_IndexToSliceModifier;
// store new display coordinates
m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
// propagate scroll event with computed geometry values
InvokeEvent(DisplayScrollEvent(interactionEvent, sliceDelta, m_AutoRepeat));
}
void mitk::DisplayActionEventBroadcast::ScrollOneUp(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
int sliceDelta = 1;
if (m_InvertScrollDirection)
{
sliceDelta = -1;
}
// propagate scroll event with a single slice delta (increase)
InvokeEvent(DisplayScrollEvent(interactionEvent, sliceDelta, m_AutoRepeat));
}
void mitk::DisplayActionEventBroadcast::ScrollOneDown(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
int sliceDelta = -1;
if (m_InvertScrollDirection)
{
sliceDelta = 1;
}
// propagate scroll event with a single slice delta (decrease)
InvokeEvent(DisplayScrollEvent(interactionEvent, sliceDelta, m_AutoRepeat));
}
void mitk::DisplayActionEventBroadcast::AdjustLevelWindow(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
ScalarType level;
ScalarType window;
if (m_LevelDirection == "leftright")
{
level = m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0];
window = m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1];
}
else
{
level = m_CurrentDisplayCoordinate[1] - m_LastDisplayCoordinate[1];
window = m_CurrentDisplayCoordinate[0] - m_LastDisplayCoordinate[0];
}
if (m_InvertLevelWindowDirection)
{
level *= -1;
window *= -1;
}
level *= static_cast<ScalarType>(2);
window *= static_cast<ScalarType>(2);
// store new display coordinates
m_LastDisplayCoordinate = m_CurrentDisplayCoordinate;
m_CurrentDisplayCoordinate = positionEvent->GetPointerPositionOnScreen();
// propagate set level window event with the level and window delta
InvokeEvent(DisplaySetLevelWindowEvent(interactionEvent, level, window));
}
void mitk::DisplayActionEventBroadcast::StartRotation(StateMachineAction* /*stateMachineAction*/, InteractionEvent* /*interactionEvent*/)
{
SetMouseCursor(rotate_cursor_xpm, 0, 0);
}
void mitk::DisplayActionEventBroadcast::EndRotation(StateMachineAction* /*stateMachineAction*/, InteractionEvent* /*interactionEvent*/)
{
ResetMouseCursor();
}
void mitk::DisplayActionEventBroadcast::Rotate(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
Point3D position = positionEvent->GetPositionInWorld();
Vector3D toProjected = m_LastCursorPosition - m_CenterOfRotation;
Vector3D toCursor = position - m_CenterOfRotation;
// cross product: | A x B | = |A| * |B| * sin(angle)
Vector3D axisOfRotation;
vnl_vector_fixed<ScalarType, 3> vnlDirection = vnl_cross_3d(toCursor.GetVnlVector(), toProjected.GetVnlVector());
axisOfRotation.SetVnlVector(vnlDirection.as_ref());
// scalar product: A * B = |A| * |B| * cos(angle)
// tan = sin / cos
ScalarType angle = -atan2((double)(axisOfRotation.GetNorm()), (double)(toCursor * toProjected));
angle *= 180.0 / vnl_math::pi;
m_LastCursorPosition = position;
// create RotationOperation and apply to all SNCs that should be rotated
RotationOperation rotationOperation(OpROTATE, m_CenterOfRotation, axisOfRotation, angle);
// iterate the OTHER slice navigation controllers
for (auto iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
{
TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
if (nullptr == timeGeometry)
{
continue;
}
timeGeometry->ExecuteOperation(&rotationOperation);
(*iter)->SendCreatedWorldGeometryUpdate();
}
RenderingManager::GetInstance()->RequestUpdateAll();
}
void mitk::DisplayActionEventBroadcast::Swivel(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
{
const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
if (nullptr == positionEvent)
{
return;
}
// Determine relative mouse movement projected onto world space
Point2D position = positionEvent->GetPointerPositionOnScreen();
Vector2D relativeCursor = position - m_ReferenceCursor;
Vector3D relativeCursorAxis = m_RotationPlaneXVector * relativeCursor[0] + m_RotationPlaneYVector * relativeCursor[1];
// Determine rotation axis (perpendicular to rotation plane and cursor movement)
Vector3D rotationAxis = itk::CrossProduct(m_RotationPlaneNormal, relativeCursorAxis);
ScalarType rotationAngle = relativeCursor.GetNorm() / 2.0;
// Restore the initial plane pose by undoing the previous rotation operation
RotationOperation op(OpROTATE, m_CenterOfRotation, m_PreviousRotationAxis, -m_PreviousRotationAngle);
SNCVector::iterator iter;
for (iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
{
if (!(*iter)->GetSliceRotationLocked())
{
TimeGeometry* timeGeometry = (*iter)->GetCreatedWorldGeometry();
if (nullptr == timeGeometry)
{
continue;
}
timeGeometry->ExecuteOperation(&op);
(*iter)->SendCreatedWorldGeometryUpdate();
}
}
// Apply new rotation operation to all relevant SNCs
RotationOperation op2(OpROTATE, m_CenterOfRotation, rotationAxis, rotationAngle);
for (iter = m_SNCsToBeRotated.begin(); iter != m_SNCsToBeRotated.end(); ++iter)
{
if (!(*iter)->GetSliceRotationLocked())
{
// Retrieve the TimeGeometry of this SliceNavigationController
TimeGeometry *timeGeometry = (*iter)->GetCreatedWorldGeometry();
if (nullptr == timeGeometry)
{
continue;
}
// Execute the new rotation
timeGeometry->ExecuteOperation(&op2);
// Notify listeners
(*iter)->SendCreatedWorldGeometryUpdate();
}
}
m_PreviousRotationAxis = rotationAxis;
m_PreviousRotationAngle = rotationAngle;
RenderingManager::GetInstance()->RequestUpdateAll();
return;
}
void mitk::DisplayActionEventBroadcast::IncreaseTimeStep(StateMachineAction*, InteractionEvent*)
{
auto sliceNaviController = RenderingManager::GetInstance()->GetTimeNavigationController();
auto stepper = sliceNaviController->GetTime();
stepper->SetAutoRepeat(true);
stepper->Next();
}
void mitk::DisplayActionEventBroadcast::DecreaseTimeStep(StateMachineAction*, InteractionEvent*)
{
auto sliceNaviController = RenderingManager::GetInstance()->GetTimeNavigationController();
auto stepper = sliceNaviController->GetTime();
stepper->SetAutoRepeat(true);
stepper->Previous();
}
-void mitk::DisplayActionEventBroadcast::UpdateStatusbar(StateMachineAction* /*stateMachineAction*/, InteractionEvent* interactionEvent)
-{
- const auto* positionEvent = dynamic_cast<InteractionPositionEvent*>(interactionEvent);
- if (nullptr == positionEvent)
- {
- return;
- }
-
- BaseRenderer::Pointer renderer = positionEvent->GetSender();
-
- TNodePredicateDataType<Image>::Pointer isImageData = TNodePredicateDataType<Image>::New();
- DataStorage::SetOfObjects::ConstPointer nodes = renderer->GetDataStorage()->GetSubset(isImageData).GetPointer();
- if (nodes.IsNull())
- {
- return;
- }
-
- // A rendering update is required before getting the pointer position.
- // This is required when scrolling through slices of an image using the mouse wheel.
- renderer->ForceImmediateUpdate();
- Point3D worldposition;
- renderer->DisplayToWorld(positionEvent->GetPointerPositionOnScreen(), worldposition);
- auto globalCurrentTimePoint = renderer->GetTime();
-
- Image::Pointer image3D;
- DataNode::Pointer node;
- DataNode::Pointer topSourceNode;
-
- int component = 0;
-
- node = FindTopmostVisibleNode(nodes, worldposition, globalCurrentTimePoint, renderer);
- if (node.IsNull())
- {
- return;
- }
-
- bool isBinary(false);
- node->GetBoolProperty("binary", isBinary);
- if (isBinary)
- {
- DataStorage::SetOfObjects::ConstPointer sourcenodes = renderer->GetDataStorage()->GetSources(node, nullptr, true);
- if (!sourcenodes->empty())
- {
- topSourceNode = FindTopmostVisibleNode(nodes, worldposition, globalCurrentTimePoint, renderer);
- }
- if (topSourceNode.IsNotNull())
- {
- image3D = dynamic_cast<Image*>(topSourceNode->GetData());
- topSourceNode->GetIntProperty("Image.Displayed Component", component);
- }
- else
- {
- image3D = dynamic_cast<Image*>(node->GetData());
- node->GetIntProperty("Image.Displayed Component", component);
- }
- }
- else
- {
- image3D = dynamic_cast<Image *>(node->GetData());
- node->GetIntProperty("Image.Displayed Component", component);
- }
-
- // get the position and pixel value from the image and build up status bar text
- auto statusBar = StatusBar::GetInstance();
- if (image3D.IsNotNull() && statusBar != nullptr)
- {
- itk::Index<3> p;
- image3D->GetGeometry()->WorldToIndex(worldposition, p);
-
- auto pixelType = image3D->GetChannelDescriptor().GetPixelType().GetPixelType();
- if (pixelType == itk::IOPixelEnum::RGB || pixelType == itk::IOPixelEnum::RGBA)
- {
- std::string pixelValue = "Pixel RGB(A) value: ";
- pixelValue.append(ConvertCompositePixelValueToString(image3D, p));
- statusBar->DisplayImageInfo(worldposition, p, renderer->GetTime(), pixelValue.c_str());
- }
- else if (pixelType == itk::IOPixelEnum::DIFFUSIONTENSOR3D || pixelType == itk::IOPixelEnum::SYMMETRICSECONDRANKTENSOR)
- {
- std::string pixelValue = "See ODF Details view. ";
- statusBar->DisplayImageInfo(worldposition, p, renderer->GetTime(), pixelValue.c_str());
- }
- else
- {
- ScalarType pixelValue;
- mitkPixelTypeMultiplex5(
- FastSinglePixelAccess,
- image3D->GetChannelDescriptor().GetPixelType(),
- image3D,
- image3D->GetVolumeData(renderer->GetTimeStep()),
- p,
- pixelValue,
- component);
- statusBar->DisplayImageInfo(worldposition, p, renderer->GetTime(), pixelValue);
- }
- }
- else
- {
- statusBar->DisplayImageInfoInvalid();
- }
-}
-
bool mitk::DisplayActionEventBroadcast::GetBoolProperty(PropertyList::Pointer propertyList, const char* propertyName, bool defaultValue)
{
std::string valueAsString;
if (!propertyList->GetStringProperty(propertyName, valueAsString))
{
return defaultValue;
}
else
{
if (valueAsString == "true")
{
return true;
}
else
{
return false;
}
}
}