vtkMRMLSliceIntersectionWidget.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkMRMLSliceIntersectionWidget.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or https://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkMRMLSliceIntersectionWidget_h
#define vtkMRMLSliceIntersectionWidget_h

#include "vtkMRMLDisplayableManagerExport.h" // For export macro
#include "vtkMRMLAbstractWidget.h"
#include "vtkMRMLSliceLogic.h"
#include "vtkMRMLSliceNode.h"

#include <vtkCallbackCommand.h>
#include <vtkCollection.h>
#include <vtkSmartPointer.h>
#include <vtkWeakPointer.h>

class vtkSliceIntersectionRepresentation2D;
class vtkMRMLApplicationLogic;
class vtkMRMLSegmentationDisplayNode;
class vtkMRMLSliceDisplayNode;

class VTK_MRML_DISPLAYABLEMANAGER_EXPORT vtkMRMLSliceIntersectionWidget : public vtkMRMLAbstractWidget
{
public:
  static vtkMRMLSliceIntersectionWidget *New();


  vtkTypeMacro(vtkMRMLSliceIntersectionWidget, vtkMRMLAbstractWidget);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void CreateDefaultRepresentation();

  void SetSliceNode(vtkMRMLSliceNode* sliceNode);
  vtkMRMLSliceNode* GetSliceNode();

  vtkMRMLSliceDisplayNode* GetSliceDisplayNode();

  void SetMRMLApplicationLogic(vtkMRMLApplicationLogic* applicationLogic) override;

  bool CanProcessInteractionEvent(vtkMRMLInteractionEventData* eventData, double &distance2) override;

  bool ProcessInteractionEvent(vtkMRMLInteractionEventData* eventData) override;

  void Leave(vtkMRMLInteractionEventData* eventData) override;

  enum
    {
    // Interactions without handles
    WidgetStateMoveCrosshair = WidgetStateUser, 
    WidgetStateBlend, 
    WidgetStateTranslateSlice, 
    WidgetStateRotateIntersectingSlices, 
    WidgetStateZoomSlice, 
    WidgetStateTouchGesture, 

    // Interactions with slice intersection handles
    WidgetStateOnTranslateIntersectingSlicesHandle, 
    WidgetStateTranslateIntersectingSlicesHandle, 
    WidgetStateOnRotateIntersectingSlicesHandle, 
    WidgetStateRotateIntersectingSlicesHandle, 
    WidgetStateOnTranslateSingleIntersectingSliceHandle, 
    WidgetStateTranslateSingleIntersectingSliceHandle, 

    WidgetState_Last
    };

  enum
    {
    // Interactions without handles
    WidgetEventTouchGestureStart = WidgetEventUser,
    WidgetEventTouchGestureEnd,
    WidgetEventTouchRotateSliceIntersection,
    WidgetEventTouchZoomSlice,
    WidgetEventTouchTranslateSlice,
    WidgetEventMoveCrosshairStart,
    WidgetEventMoveCrosshairEnd,
    WidgetEventBlendStart,
    WidgetEventBlendEnd,
    WidgetEventToggleLabelOpacity,
    WidgetEventToggleForegroundOpacity,
    WidgetEventIncrementSlice,
    WidgetEventDecrementSlice,
    WidgetEventZoomInSlice,
    WidgetEventZoomOutSlice,
    WidgetEventToggleSliceVisibility,
    WidgetEventToggleAllSlicesVisibility, // currently does not work, only toggles current slice
    WidgetEventResetFieldOfView,
    WidgetEventShowNextBackgroundVolume,
    WidgetEventShowPreviousBackgroundVolume,
    WidgetEventShowNextForegroundVolume,
    WidgetEventShowPreviousForegroundVolume,
    WidgetEventRotateIntersectingSlicesStart, // rotate all intersecting slices (ctrl-alt-left-click-and-drag)
    WidgetEventRotateIntersectingSlicesEnd,
    WidgetEventTranslateSliceStart,
    WidgetEventTranslateSliceEnd,
    WidgetEventZoomSliceStart,
    WidgetEventZoomSliceEnd,
    WidgetEventSetCrosshairPosition,
    WidgetEventSetCrosshairPositionBackground, //< set crosshair position without consuming the event (so that other widgets can process the event)
    WidgetEventMaximizeView,

    // Interactions with slice intersection handles
    // WidgetStateOnTranslateIntersectingSlicesHandle/WidgetStateTranslateIntersectingSlicesHandle
    WidgetEventTranslateIntersectingSlicesHandleStart,
    WidgetEventTranslateIntersectingSlicesHandleEnd,
    // WidgetStateOnRotateIntersectingSlicesHandle/WidgetStateRotateIntersectingSlicesHandle
    WidgetEventRotateIntersectingSlicesHandleStart,
    WidgetEventRotateIntersectingSlicesHandleEnd,
    // WidgetStateOnTranslateSingleIntersectingSliceHandle/WidgetStateOnTranslateSingleIntersectingSliceHandle
    WidgetEventTranslateSingleIntersectingSliceHandleStart,
    WidgetEventTranslateSingleIntersectingSliceHandleEnd,
    };

  enum
    {
    ActionNone = 0,
    ActionTranslate = 1,
    ActionZoom = 2,
    ActionRotate = 4, /* not used */
    ActionBlend = 8, /* fg to bg, labelmap to bg */
    ActionBrowseSlice = 64,
    ActionShowSlice = 128,
    ActionAdjustLightbox = 256,
    ActionSelectVolume = 512,
    ActionSetCursorPosition = 1024, /* adjust cursor position in crosshair node as mouse is moved */
    ActionSetCrosshairPosition = 2048, /* adjust cursor position in crosshair node as mouse is moved */
    ActionTranslateSliceIntersection = 4096,
    ActionRotateSliceIntersection = 8192,
    ActionAll = ActionTranslate | ActionZoom | ActionRotate | ActionBlend
    | ActionBrowseSlice | ActionShowSlice | ActionAdjustLightbox | ActionSelectVolume
    | ActionSetCursorPosition | ActionSetCrosshairPosition
    | ActionTranslateSliceIntersection | ActionRotateSliceIntersection
    };

  void SetActionsEnabled(int actions);

  int GetActionsEnabled();

  void SetActionEnabled(int actionsMask, bool enable = true);
  bool GetActionEnabled(int actionsMask);

  void UpdateInteractionEventMapping();

  // Allows the widget to request a cursor shape
  int GetMouseCursor() override;

protected:
  vtkMRMLSliceIntersectionWidget();
  ~vtkMRMLSliceIntersectionWidget() override;

  bool ProcessStartMouseDrag(vtkMRMLInteractionEventData* eventData);
  bool ProcessMouseMove(vtkMRMLInteractionEventData* eventData);
  bool ProcessEndMouseDrag(vtkMRMLInteractionEventData* eventData);
  bool ProcessBlend(vtkMRMLInteractionEventData* eventData);

  bool ProcessRotateIntersectingSlicesStart(vtkMRMLInteractionEventData* eventData);
  bool ProcessRotateIntersectingSlices(vtkMRMLInteractionEventData* eventData);
  bool ProcessSetCrosshair(vtkMRMLInteractionEventData* eventData);
  bool ProcessSetCrosshairBackground(vtkMRMLInteractionEventData* eventData);
  double GetSliceRotationAngleRad(double eventPos[2]);

  // Pan (move slice in-plane) by click-and-drag
  bool ProcessTranslateSlice(vtkMRMLInteractionEventData* eventData);

  bool ProcessZoomSlice(vtkMRMLInteractionEventData* eventData);

  bool ProcessTouchGestureStart(vtkMRMLInteractionEventData* eventData);
  bool ProcessTouchGestureEnd(vtkMRMLInteractionEventData* eventData);
  bool ProcessTouchRotate(vtkMRMLInteractionEventData* eventData);
  bool ProcessTouchZoom(vtkMRMLInteractionEventData* eventData);
  bool ProcessTouchTranslate(vtkMRMLInteractionEventData* eventData);

  bool ProcessTranslateIntersectingSlicesHandleStart(vtkMRMLInteractionEventData* eventData);
  bool ProcessTranslateIntersectingSlicesHandle(vtkMRMLInteractionEventData* eventData);
  bool ProcessTranslateSingleIntersectingSliceHandleStart(vtkMRMLInteractionEventData* eventData);
  bool ProcessTranslateSingleIntersectingSliceHandle(vtkMRMLInteractionEventData* eventData);
  bool ProcessRotateIntersectingSlicesHandleStart(vtkMRMLInteractionEventData* eventData);
  bool ProcessRotateIntersectingSlicesHandle(vtkMRMLInteractionEventData* eventData);

  bool ProcessWidgetMenu(vtkMRMLInteractionEventData* eventData);

  bool ProcessMaximizeView(vtkMRMLInteractionEventData* eventData);

  bool Rotate(double sliceRotationAngleRad);

  void ScaleZoom(double zoomScaleFactor, vtkMRMLInteractionEventData* eventData);

  void SetLabelOpacity(double opacity);
  double GetLabelOpacity();

  bool IsEventInsideVolume(bool background, vtkMRMLInteractionEventData* eventData);

  vtkMRMLSegmentationDisplayNode* GetVisibleSegmentationDisplayNode();

  static void SliceModifiedCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);
  static void SliceLogicsModifiedCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);

  vtkWeakPointer<vtkCollection> SliceLogics;
  vtkWeakPointer<vtkMRMLSliceNode> SliceNode;
  vtkWeakPointer<vtkMRMLSliceLogic> SliceLogic;
  vtkNew<vtkCallbackCommand> SliceLogicsModifiedCommand;
  vtkNew<vtkCallbackCommand> SliceModifiedCommand;

  double StartEventPosition[2];
  double PreviousRotationAngleRad;
  int PreviousEventPosition[2];
  double StartRotationCenter[2];
  double StartRotationCenter_RAS[4];

  double StartTranslationPoint[2];
  double StartTranslationPoint_RAS[3];
  double CurrentTranslationPoint_RAS[3];

  double StartActionFOV[3];
  double VolumeScalarRange[2];

  enum
    {
    LayerBackground,
    LayerForeground,
    LayerLabelmap
    };

  // Blend
  double LastForegroundOpacity;
  double LastLabelOpacity;
  vtkMRMLSegmentationDisplayNode* StartActionSegmentationDisplayNode;

  // Browse slice
  double GetSliceSpacing();
  void IncrementSlice();
  void DecrementSlice();
  void MoveSlice(double delta);

  void CycleVolumeLayer(int layer, int direction);

  bool IsSliceIntersectionInteractive();

  bool ModifierKeyPressedSinceLastClickAndDrag;

  int ActionsEnabled;

  double TouchRotationThreshold;
  double TouchTranslationThreshold;
  double TouchZoomThreshold;
  double TotalTouchRotation;
  bool TouchRotateEnabled;
  double TotalTouchTranslation;
  bool TouchTranslationEnabled;
  double TotalTouchZoom;
  bool TouchZoomEnabled;

  // Last intersecting slice node where interaction occurred
  std::string LastIntersectingSliceNodeID;

private:
  vtkMRMLSliceIntersectionWidget(const vtkMRMLSliceIntersectionWidget&) = delete;
  void operator=(const vtkMRMLSliceIntersectionWidget&) = delete;
};

#endif