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, 
 
    // Interactions with intersecting slice thick slab handles
    WidgetStateOnTranslateIntersectingThickSlabHandle, 
    WidgetStateTranslateIntersectingThickSlabHandle, 
 
    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,
 
    // Interactions with slice thickslab handles
    // WidgetStateOnTranslateIntersectingThickSlabHandle/WidgetStateTranslateIntersectingThickSlabHandle
    WidgetEventTranslateIntersectingThickSlabHandleStart,
    WidgetEventTranslateIntersectingThickSlabHandleEnd,
  };

  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 ProcessTranslateIntersectingThickSlabHandleStart(vtkMRMLInteractionEventData* eventData);
  bool ProcessTranslateIntersectingThickSlabHandle(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 StartThickSlabTranslationPoint[2];
  double StartThickSlabTranslationPoint_RAS[3];
  double CurrentThickSlabTranslationPoint_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 IsThickSlabInteractive();

  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;
};
class VTK_MRML_DISPLAYABLEMANAGER_EXPORT vtkMRMLSliceIntersectionWidget : public vtkMRMLAbstractWidget {…};
 
#endif