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 http://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 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();

  void SetMRMLApplicationLogic(vtkMRMLApplicationLogic* applicationLogic) override;

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

  bool ProcessInteractionEvent(vtkMRMLInteractionEventData* eventData) override;

  void Leave(vtkMRMLInteractionEventData* eventData) override;

  enum
    {
    WidgetStateFollowCursor = WidgetStateUser,
    WidgetStateBlend,
    WidgetStateTranslateSlice,
    WidgetStateZoomSlice,
    WidgetStateTouchGesture,
    };

  enum
    {
    WidgetEventTouchGestureStart = WidgetEventUser,
    WidgetEventTouchGestureEnd,
    WidgetEventTouchRotateSliceIntersection,
    WidgetEventTouchZoomSlice,
    WidgetEventTouchTranslateSlice,
    WidgetEventBlendStart,
    WidgetEventBlendEnd,
    WidgetEventToggleLabelOpacity,
    WidgetEventToggleForegroundOpacity,
    WidgetEventIncrementSlice,
    WidgetEventDecrementSlice,
    WidgetEventZoomInSlice,
    WidgetEventZoomOutSlice,
    WidgetEventToggleSliceVisibility,
    WidgetEventToggleAllSlicesVisibility, // currently does not work, only toggles current slice
    WidgetEventResetFieldOfView,
    WidgetEventShowNextBackgroundVolume,
    WidgetEventShowPreviousBackgroundVolume,
    WidgetEventShowNextForegroundVolume,
    WidgetEventShowPreviousForegroundVolume,
    WidgetEventTranslateSliceStart,
    WidgetEventTranslateSliceEnd,
    WidgetEventZoomSliceStart,
    WidgetEventZoomSliceEnd,
    WidgetEventSetCrosshairPosition,
    };

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

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

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

  bool ProcessRotateStart(vtkMRMLInteractionEventData* eventData);
  bool ProcessRotate(vtkMRMLInteractionEventData* eventData);
  bool ProcessSetCrosshair(vtkMRMLInteractionEventData* eventData);
  double GetSliceRotationAngleRad(double eventPos[2]);

  // 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 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 SliceLogicsModifiedCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);

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

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

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

  int ActionsEnabled;

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

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

#endif