vtkImagePlaneWidget.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkImagePlaneWidget_h
#define vtkImagePlaneWidget_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkPolyDataSourceWidget.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor;
class vtkAbstractPropPicker;
class vtkDataSetMapper;
class vtkImageData;
class vtkImageMapToColors;
class vtkImageReslice;
class vtkLookupTable;
class vtkMatrix4x4;
class vtkPlaneSource;
class vtkPoints;
class vtkPolyData;
class vtkProperty;
class vtkTextActor;
class vtkTextProperty;
class vtkTexture;
class vtkTransform;
 
#define VTK_NEAREST_RESLICE 0
#define VTK_LINEAR_RESLICE 1
#define VTK_CUBIC_RESLICE 2
 
// Private.
#define VTK_IMAGE_PLANE_WIDGET_MAX_TEXTBUFF 128
 
class VTKINTERACTIONWIDGETS_EXPORT vtkImagePlaneWidget : public vtkPolyDataSourceWidget
{
public:
  static vtkImagePlaneWidget* New();
 
  vtkTypeMacro(vtkImagePlaneWidget, vtkPolyDataSourceWidget);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void SetEnabled(int) override;
  void PlaceWidget(double bounds[6]) override;
  void PlaceWidget() override { this->Superclass::PlaceWidget(); }
  void PlaceWidget(
    double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) override
  {
    this->Superclass::PlaceWidget(xmin, xmax, ymin, ymax, zmin, zmax);
  }
 
  void SetInputConnection(vtkAlgorithmOutput* aout) override;
 
 
  void SetOrigin(double x, double y, double z);
  void SetOrigin(double xyz[3]);
  double* GetOrigin() VTK_SIZEHINT(3);
  void GetOrigin(double xyz[3]);
 
 
  void SetPoint1(double x, double y, double z);
  void SetPoint1(double xyz[3]);
  double* GetPoint1() VTK_SIZEHINT(3);
  void GetPoint1(double xyz[3]);
 
 
  void SetPoint2(double x, double y, double z);
  void SetPoint2(double xyz[3]);
  double* GetPoint2() VTK_SIZEHINT(3);
  void GetPoint2(double xyz[3]);
 
 
  double* GetCenter() VTK_SIZEHINT(3);
  void GetCenter(double xyz[3]);
 
 
  double* GetNormal() VTK_SIZEHINT(3);
  void GetNormal(double xyz[3]);
 
  void GetVector1(double v1[3]);
 
  void GetVector2(double v2[3]);
 
  int GetSliceIndex();
 
  void SetSliceIndex(int index);
 
  double GetSlicePosition();
 
  void SetSlicePosition(double position);
 
 
  void SetResliceInterpolate(int);
  vtkGetMacro(ResliceInterpolate, int);
  void SetResliceInterpolateToNearestNeighbour()
  {
    this->SetResliceInterpolate(VTK_NEAREST_RESLICE);
  }
  void SetResliceInterpolateToLinear() { this->SetResliceInterpolate(VTK_LINEAR_RESLICE); }
  void SetResliceInterpolateToCubic() { this->SetResliceInterpolate(VTK_CUBIC_RESLICE); }
 
  vtkImageData* GetResliceOutput();
 
 
  vtkSetMacro(RestrictPlaneToVolume, vtkTypeBool);
  vtkGetMacro(RestrictPlaneToVolume, vtkTypeBool);
  vtkBooleanMacro(RestrictPlaneToVolume, vtkTypeBool);
 
 
  vtkSetMacro(UserControlledLookupTable, vtkTypeBool);
  vtkGetMacro(UserControlledLookupTable, vtkTypeBool);
  vtkBooleanMacro(UserControlledLookupTable, vtkTypeBool);
 
 
  vtkSetMacro(TextureInterpolate, vtkTypeBool);
  vtkGetMacro(TextureInterpolate, vtkTypeBool);
  vtkBooleanMacro(TextureInterpolate, vtkTypeBool);
 
 
  virtual void SetTextureVisibility(vtkTypeBool);
  vtkGetMacro(TextureVisibility, vtkTypeBool);
  vtkBooleanMacro(TextureVisibility, vtkTypeBool);
 
  void GetPolyData(vtkPolyData* pd);
 
  vtkPolyDataAlgorithm* GetPolyDataAlgorithm() override;
 
  void UpdatePlacement() override;
 
  vtkTexture* GetTexture();
 
 
  vtkGetObjectMacro(ColorMap, vtkImageMapToColors);
  virtual void SetColorMap(vtkImageMapToColors*);
 
 
  virtual void SetPlaneProperty(vtkProperty*);
  vtkGetObjectMacro(PlaneProperty, vtkProperty);
  virtual void SetSelectedPlaneProperty(vtkProperty*);
  vtkGetObjectMacro(SelectedPlaneProperty, vtkProperty);
 
 
  void SetPlaneOrientation(int);
  vtkGetMacro(PlaneOrientation, int);
  void SetPlaneOrientationToXAxes() { this->SetPlaneOrientation(0); }
  void SetPlaneOrientationToYAxes() { this->SetPlaneOrientation(1); }
  void SetPlaneOrientationToZAxes() { this->SetPlaneOrientation(2); }
 
  void SetPicker(vtkAbstractPropPicker*);
 
 
  virtual void SetLookupTable(vtkLookupTable*);
  vtkGetObjectMacro(LookupTable, vtkLookupTable);
 
 
  vtkSetMacro(DisplayText, vtkTypeBool);
  vtkGetMacro(DisplayText, vtkTypeBool);
  vtkBooleanMacro(DisplayText, vtkTypeBool);
 
 
  virtual void SetCursorProperty(vtkProperty*);
  vtkGetObjectMacro(CursorProperty, vtkProperty);
 
 
  virtual void SetMarginProperty(vtkProperty*);
  vtkGetObjectMacro(MarginProperty, vtkProperty);
 
 
  vtkSetClampMacro(MarginSizeX, double, 0.0, 0.5);
  vtkGetMacro(MarginSizeX, double);
  vtkSetClampMacro(MarginSizeY, double, 0.0, 0.5);
  vtkGetMacro(MarginSizeY, double);
 
 
  void SetTextProperty(vtkTextProperty* tprop);
  vtkTextProperty* GetTextProperty();
 
 
  virtual void SetTexturePlaneProperty(vtkProperty*);
  vtkGetObjectMacro(TexturePlaneProperty, vtkProperty);
 
 
  void SetWindowLevel(double window, double level, int copy = 0);
  void GetWindowLevel(double wl[2]);
  double GetWindow() { return this->CurrentWindow; }
  double GetLevel() { return this->CurrentLevel; }
 
  int GetCursorData(double xyzv[4]);
 
  int GetCursorDataStatus();
 
 
  vtkGetVectorMacro(CurrentCursorPosition, double, 3);
 
 
  vtkGetMacro(CurrentImageValue, double);
 
 
  vtkGetObjectMacro(ResliceAxes, vtkMatrix4x4);
  vtkGetObjectMacro(Reslice, vtkImageReslice);
 
 
  vtkSetMacro(UseContinuousCursor, vtkTypeBool);
  vtkGetMacro(UseContinuousCursor, vtkTypeBool);
  vtkBooleanMacro(UseContinuousCursor, vtkTypeBool);
 
 
  void SetInteraction(vtkTypeBool interact);
  vtkGetMacro(Interaction, vtkTypeBool);
  vtkBooleanMacro(Interaction, vtkTypeBool);
 
 
  enum
  {
    VTK_CURSOR_ACTION = 0,
    VTK_SLICE_MOTION_ACTION = 1,
    VTK_WINDOW_LEVEL_ACTION = 2
  };
  vtkSetClampMacro(LeftButtonAction, int, VTK_CURSOR_ACTION, VTK_WINDOW_LEVEL_ACTION);
  vtkGetMacro(LeftButtonAction, int);
  vtkSetClampMacro(MiddleButtonAction, int, VTK_CURSOR_ACTION, VTK_WINDOW_LEVEL_ACTION);
  vtkGetMacro(MiddleButtonAction, int);
  vtkSetClampMacro(RightButtonAction, int, VTK_CURSOR_ACTION, VTK_WINDOW_LEVEL_ACTION);
  vtkGetMacro(RightButtonAction, int);
 
 
  enum
  {
    VTK_NO_MODIFIER = 0,
    VTK_SHIFT_MODIFIER = 1,
    VTK_CONTROL_MODIFIER = 2
  };
  vtkSetClampMacro(LeftButtonAutoModifier, int, VTK_NO_MODIFIER, VTK_CONTROL_MODIFIER);
  vtkGetMacro(LeftButtonAutoModifier, int);
  vtkSetClampMacro(MiddleButtonAutoModifier, int, VTK_NO_MODIFIER, VTK_CONTROL_MODIFIER);
  vtkGetMacro(MiddleButtonAutoModifier, int);
  vtkSetClampMacro(RightButtonAutoModifier, int, VTK_NO_MODIFIER, VTK_CONTROL_MODIFIER);
  vtkGetMacro(RightButtonAutoModifier, int);
 
protected:
  vtkImagePlaneWidget();
  ~vtkImagePlaneWidget() override;
 
  vtkTypeBool TextureVisibility;
 
  int LeftButtonAction;
  int MiddleButtonAction;
  int RightButtonAction;
 
  int LeftButtonAutoModifier;
  int MiddleButtonAutoModifier;
  int RightButtonAutoModifier;
 
  enum
  {
    VTK_NO_BUTTON = 0,
    VTK_LEFT_BUTTON = 1,
    VTK_MIDDLE_BUTTON = 2,
    VTK_RIGHT_BUTTON = 3
  };
  int LastButtonPressed;
 
  // Manage the state of the widget
  int State;
  enum WidgetState
  {
    Start = 0,
    Cursoring,
    WindowLevelling,
    Pushing,
    Spinning,
    Rotating,
    Moving,
    Scaling,
    Outside
  };
 
  // Handles the events
  static void ProcessEvents(
    vtkObject* object, unsigned long event, void* clientdata, void* calldata);
 
  // internal utility method that adds observers to the RenderWindowInteractor
  // so that our ProcessEvents is eventually called.  this method is called
  // by SetEnabled as well as SetInteraction
  void AddObservers();
 
  // ProcessEvents() dispatches to these methods.
  virtual void OnMouseMove();
  virtual void OnLeftButtonDown();
  virtual void OnLeftButtonUp();
  virtual void OnMiddleButtonDown();
  virtual void OnMiddleButtonUp();
  virtual void OnRightButtonDown();
  virtual void OnRightButtonUp();
  void OnChar() override;
 
  virtual void StartCursor();
  virtual void StopCursor();
  virtual void StartSliceMotion();
  virtual void StopSliceMotion();
  virtual void StartWindowLevel();
  virtual void StopWindowLevel();
 
  // controlling ivars
  vtkTypeBool Interaction; // Is the widget responsive to mouse events
  int PlaneOrientation;
  vtkTypeBool RestrictPlaneToVolume;
  double OriginalWindow;
  double OriginalLevel;
  double CurrentWindow;
  double CurrentLevel;
  double InitialWindow;
  double InitialLevel;
  int StartWindowLevelPositionX;
  int StartWindowLevelPositionY;
  int ResliceInterpolate;
  vtkTypeBool TextureInterpolate;
  vtkTypeBool UserControlledLookupTable;
  vtkTypeBool DisplayText;
 
  // The geometric representation of the plane and it's outline
  vtkPlaneSource* PlaneSource;
  vtkPolyData* PlaneOutlinePolyData;
  vtkActor* PlaneOutlineActor;
  void HighlightPlane(int highlight);
  void GeneratePlaneOutline();
 
  // Re-builds the plane outline based on the plane source
  void BuildRepresentation();
 
  // Do the picking
  vtkAbstractPropPicker* PlanePicker;
 
  // Register internal Pickers within PickingManager
  void RegisterPickers() override;
 
  // for negative window values.
  void InvertTable();
 
  // Methods to manipulate the plane
  void WindowLevel(int X, int Y);
  void Push(double* p1, double* p2);
  void Spin(double* p1, double* p2);
  void Rotate(double* p1, double* p2, double* vpn);
  void Scale(double* p1, double* p2, int X, int Y);
  void Translate(double* p1, double* p2);
 
  vtkImageData* ImageData;
  vtkImageReslice* Reslice;
  vtkMatrix4x4* ResliceAxes;
  vtkTransform* Transform;
  vtkActor* TexturePlaneActor;
  vtkImageMapToColors* ColorMap;
  vtkTexture* Texture;
  vtkLookupTable* LookupTable;
  vtkLookupTable* CreateDefaultLookupTable();
 
  // Properties used to control the appearance of selected objects and
  // the manipulator in general.  The plane property is actually that for
  // the outline.  The TexturePlaneProperty can be used to control the
  // lighting etc. of the resliced image data.
  vtkProperty* PlaneProperty;
  vtkProperty* SelectedPlaneProperty;
  vtkProperty* CursorProperty;
  vtkProperty* MarginProperty;
  vtkProperty* TexturePlaneProperty;
  void CreateDefaultProperties();
 
  // Reslice and texture management
  void UpdatePlane();
  void GenerateTexturePlane();
 
  // The cross-hair cursor
  vtkPolyData* CursorPolyData;
  vtkActor* CursorActor;
  double CurrentCursorPosition[3];
  double CurrentImageValue; // Set to VTK_DOUBLE_MAX when invalid
  void GenerateCursor();
  void UpdateCursor(int, int);
  void ActivateCursor(int);
  int UpdateContinuousCursor(double* q);
  int UpdateDiscreteCursor(double* q);
  vtkTypeBool UseContinuousCursor;
 
  // The text to display W/L, image data
  vtkTextActor* TextActor;
  char TextBuff[VTK_IMAGE_PLANE_WIDGET_MAX_TEXTBUFF];
  void GenerateText();
  void ManageTextDisplay();
  void ActivateText(int);
 
  // Oblique reslice control
  double RotateAxis[3];
  double RadiusVector[3];
  void AdjustState();
 
  // Visible margins to assist user interaction
  vtkPolyData* MarginPolyData;
  vtkActor* MarginActor;
  int MarginSelectMode;
  void GenerateMargins();
  void UpdateMargins();
  void ActivateMargins(int);
  double MarginSizeX;
  double MarginSizeY;
 
private:
  vtkImagePlaneWidget(const vtkImagePlaneWidget&) = delete;
  void operator=(const vtkImagePlaneWidget&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif