mitkPlanarFigureInteractor.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkPlanarFigureInteractor_h
#define mitkPlanarFigureInteractor_h
 
#include <MitkPlanarFigureExports.h>
 
#include <mitkCommon.h>
#include <mitkDataInteractor.h>
#include <mitkNumericTypes.h>
 
#ifdef __GNUC__
#pragma GCC visibility push(default)
#endif
#include <itkEventObject.h>
#ifdef __GNUC__
#pragma GCC visibility pop
#endif
 
namespace mitk
{
  class DataNode;
  class PlaneGeometry;
  class PlanarFigure;
  class PositionEvent;
  class BaseRenderer;
  class InteractionPositionEvent;
  class StateMachineAction;
 
#ifdef __GNUC__
#pragma GCC visibility push(default)
#endif
 
  // Define events for PlanarFigure interaction notifications
  itkEventMacroDeclaration(PlanarFigureEvent, itk::AnyEvent);
  itkEventMacroDeclaration(StartPlacementPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacroDeclaration(EndPlacementPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacroDeclaration(SelectPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacroDeclaration(StartInteractionPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacroDeclaration(EndInteractionPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacroDeclaration(StartHoverPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacroDeclaration(EndHoverPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacroDeclaration(ContextMenuPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacroDeclaration(PointMovedPlanarFigureEvent, PlanarFigureEvent);
 
#ifdef __GNUC__
#pragma GCC visibility pop
#endif
 
  class MITKPLANARFIGURE_EXPORT PlanarFigureInteractor : public DataInteractor
  {
  public:
    mitkClassMacro(PlanarFigureInteractor, DataInteractor);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
    void SetPrecision(ScalarType precision);
 
    void SetMinimumPointDistance(ScalarType minimumDistance);
 
    void EnableContinuousPointsMode();
 
  protected:
    PlanarFigureInteractor();
    ~PlanarFigureInteractor() override;
 
    void ConnectActionsAndFunctions() override;
 
    bool CheckFigurePlaced(const InteractionEvent *interactionEvent);
 
    bool CheckFigureHovering(const InteractionEvent *interactionEvent);
 
    bool CheckControlPointHovering(const InteractionEvent *interactionEvent);
 
    bool CheckSelection(const InteractionEvent *interactionEvent);
 
    bool CheckPointValidity(const InteractionEvent *interactionEvent);
 
    bool CheckFigureFinished(const InteractionEvent *interactionEvent);
 
    bool CheckResetOnPointSelect(const InteractionEvent *interactionEvent);
 
    bool CheckFigureOnRenderingGeometry(const InteractionEvent *interactionEvent);
 
    bool CheckMinimalFigureFinished(const InteractionEvent *interactionEvent);
 
    bool CheckFigureIsExtendable(const InteractionEvent *interactionEvent);
 
    bool CheckFigureIsDeletable(const InteractionEvent *interactionEvent);
 
    bool CheckFigureIsEditable(const InteractionEvent *interactionEvent);
 
    bool CheckContinuousPointsMode(const InteractionEvent* interactionEvent);
 
 
    void FinalizeFigure(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void MoveCurrentPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void DeselectPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void AddPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void AddInitialPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void StartHovering(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void EndHovering(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void DeleteFigure(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void PerformPointResetOnSelect(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void SetPreviewPointPosition(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void HidePreviewPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void HideControlPoints(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void RemoveSelectedPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void RequestContextMenu(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void SelectFigure(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void SelectPoint(StateMachineAction *, InteractionEvent *interactionEvent);
 
    void EndInteraction(StateMachineAction *, InteractionEvent *interactionEvent);
 
    bool FilterEvents(InteractionEvent *interactionEvent, DataNode *) override;
 
    bool IsMousePositionAcceptableAsNewControlPoint(const mitk::InteractionPositionEvent *positionEvent,
                                                    const PlanarFigure *);
 
    bool TransformPositionEventToPoint2D(const InteractionPositionEvent *positionEvent,
                                         const PlaneGeometry *planarFigureGeometry,
                                         Point2D &point2D);
 
    bool TransformObjectToDisplay(const mitk::Point2D &point2D,
                                  mitk::Point2D &displayPoint,
                                  const mitk::PlaneGeometry *objectGeometry,
                                  const mitk::PlaneGeometry *rendererGeometry,
                                  const mitk::BaseRenderer *renderer) const;
 
    bool IsPointNearLine(const mitk::Point2D &point,
                         const mitk::Point2D &startPoint,
                         const mitk::Point2D &endPoint,
                         mitk::Point2D &projectedPoint) const;
 
    int IsPositionOverFigure(const InteractionPositionEvent *positionEvent,
                             PlanarFigure *planarFigure,
                             const PlaneGeometry *planarFigureGeometry,
                             const PlaneGeometry *rendererGeometry,
                             Point2D &pointProjectedOntoLine) const;
 
    int IsPositionInsideMarker(const InteractionPositionEvent *positionEvent,
                               const PlanarFigure *planarFigure,
                               const PlaneGeometry *planarFigureGeometry,
                               const PlaneGeometry *rendererGeometry,
                               const BaseRenderer *renderer) const;
 
    void LogPrintPlanarFigureQuantities(const PlanarFigure *planarFigure);
 
    void ConfigurationChanged() override;
 
  private:
    ScalarType m_Precision;
 
    ScalarType m_MinimumPointDistance;
 
    bool m_IsHovering;
 
    bool m_ContinuousPointsMode = false;
  };
}
 
#endif