mitkPlanarFigureInteractor.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef MITKPLANARFIGUREINTERACTOR_H_HEADER_INCLUDED
#define MITKPLANARFIGUREINTERACTOR_H_HEADER_INCLUDED

#include <MitkPlanarFigureExports.h>

#include "mitkCommon.h"
#include "mitkDataInteractor.h"
#include "mitkNumericTypes.h"

#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop

namespace mitk
{
  class DataNode;
  class PlaneGeometry;
  class PlanarFigure;
  class PositionEvent;
  class BaseRenderer;
  class InteractionPositionEvent;
  class StateMachineAction;

#pragma GCC visibility push(default)

  // Define events for PlanarFigure interaction notifications
  itkEventMacro(PlanarFigureEvent, itk::AnyEvent);
  itkEventMacro(StartPlacementPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacro(EndPlacementPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacro(SelectPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacro(StartInteractionPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacro(EndInteractionPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacro(StartHoverPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacro(EndHoverPlanarFigureEvent, PlanarFigureEvent);
  itkEventMacro(ContextMenuPlanarFigureEvent, PlanarFigureEvent);

#pragma GCC visibility pop

  class MITKPLANARFIGURE_EXPORT PlanarFigureInteractor : public DataInteractor
  {
  public:
    mitkClassMacro(PlanarFigureInteractor, DataInteractor);
    itkFactorylessNewMacro(Self) itkCloneMacro(Self)

      
      void SetPrecision(ScalarType precision);

    void SetMinimumPointDistance(ScalarType minimumDistance);

  protected:
    PlanarFigureInteractor();
    virtual ~PlanarFigureInteractor();

    virtual 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);


    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);

    virtual void ConfigurationChanged() override;

  private:
    ScalarType m_Precision;

    ScalarType m_MinimumPointDistance;

    bool m_IsHovering;

    bool m_LastPointWasValid;

    // mitk::PlanarFigure::Pointer m_PlanarFigure;
  };
}

#endif // MITKPLANARFIGUREINTERACTOR_H_HEADER_INCLUDED