doxygen/html/vtkImagePlaneWidget_8h_source.html

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


  Program:   Visualization Toolkit

  Module:    vtkImagePlaneWidget.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 vtkImagePlaneWidget_h

#define vtkImagePlaneWidget_h


#include "vtkInteractionWidgetsModule.h" // For export macro

#include "vtkPolyDataSourceWidget.h"


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

};


#endif