You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
722 lines
23 KiB
C++
722 lines
23 KiB
C++
/*=========================================================================
|
|
|
|
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.
|
|
|
|
=========================================================================*/
|
|
/**
|
|
* @class vtkImagePlaneWidget
|
|
* @brief 3D widget for reslicing image data
|
|
*
|
|
* This 3D widget defines a plane that can be interactively placed in an
|
|
* image volume. A nice feature of the object is that the
|
|
* vtkImagePlaneWidget, like any 3D widget, will work with the current
|
|
* interactor style. That is, if vtkImagePlaneWidget does not handle an
|
|
* event, then all other registered observers (including the interactor
|
|
* style) have an opportunity to process the event. Otherwise, the
|
|
* vtkImagePlaneWidget will terminate the processing of the event that it
|
|
* handles.
|
|
*
|
|
* The core functionality of the widget is provided by a vtkImageReslice
|
|
* object which passes its output onto a texture mapping pipeline for fast
|
|
* slicing through volumetric data. See the key methods: GenerateTexturePlane()
|
|
* and UpdatePlane() for implementation details.
|
|
*
|
|
* To use this object, just invoke SetInteractor() with the argument of the
|
|
* method a vtkRenderWindowInteractor. You may also wish to invoke
|
|
* "PlaceWidget()" to initially position the widget. If the "i" key (for
|
|
* "interactor") is pressed, the vtkImagePlaneWidget will appear. (See
|
|
* superclass documentation for information about changing this behavior.)
|
|
*
|
|
* Selecting the widget with the middle mouse button with and without holding
|
|
* the shift or control keys enables complex reslicing capablilites.
|
|
* To facilitate use, a set of 'margins' (left, right, top, bottom) are shown as
|
|
* a set of plane-axes aligned lines, the properties of which can be changed
|
|
* as a group.
|
|
* Without keyboard modifiers: selecting in the middle of the margins
|
|
* enables translation of the plane along its normal. Selecting one of the
|
|
* corners within the margins enables spinning around the plane's normal at its
|
|
* center. Selecting within a margin allows rotating about the center of the
|
|
* plane around an axis aligned with the margin (i.e., selecting left margin
|
|
* enables rotating around the plane's local y-prime axis).
|
|
* With control key modifier: margin selection enables edge translation (i.e., a
|
|
* constrained form of scaling). Selecting within the margins enables
|
|
* translation of the entire plane.
|
|
* With shift key modifier: uniform plane scaling is enabled. Moving the mouse
|
|
* up enlarges the plane while downward movement shrinks it.
|
|
*
|
|
* Window-level is achieved by using the right mouse button. Window-level
|
|
* values can be reset by shift + 'r' or control + 'r' while regular reset
|
|
* camera is maintained with 'r' or 'R'.
|
|
* The left mouse button can be used to query the underlying image data
|
|
* with a snap-to cross-hair cursor. Currently, the nearest point in the input
|
|
* image data to the mouse cursor generates the cross-hairs. With oblique
|
|
* slicing, this behaviour may appear unsatisfactory. Text display of
|
|
* window-level and image coordinates/data values are provided by a text
|
|
* actor/mapper pair.
|
|
*
|
|
* Events that occur outside of the widget (i.e., no part of the widget is
|
|
* picked) are propagated to any other registered obsevers (such as the
|
|
* interaction style). Turn off the widget by pressing the "i" key again
|
|
* (or invoke the Off() method). To support interactive manipulation of
|
|
* objects, this class invokes the events StartInteractionEvent,
|
|
* InteractionEvent, and EndInteractionEvent as well as StartWindowLevelEvent,
|
|
* WindowLevelEvent, EndWindowLevelEvent and ResetWindowLevelEvent.
|
|
*
|
|
* The vtkImagePlaneWidget has several methods that can be used in
|
|
* conjunction with other VTK objects. The GetPolyData() method can be used
|
|
* to get the polygonal representation of the plane and can be used as input
|
|
* for other VTK objects. Typical usage of the widget is to make use of the
|
|
* StartInteractionEvent, InteractionEvent, and EndInteractionEvent
|
|
* events. The InteractionEvent is called on mouse motion; the other two
|
|
* events are called on button down and button up (either left or right
|
|
* button).
|
|
*
|
|
* Some additional features of this class include the ability to control the
|
|
* properties of the widget. You can set the properties of: the selected and
|
|
* unselected representations of the plane's outline; the text actor via its
|
|
* vtkTextProperty; the cross-hair cursor. In addition there are methods to
|
|
* constrain the plane so that it is aligned along the x-y-z axes. Finally,
|
|
* one can specify the degree of interpolation (vtkImageReslice): nearest
|
|
* neighbour, linear, and cubic.
|
|
*
|
|
* @par Thanks:
|
|
* Thanks to Dean Inglis for developing and contributing this class.
|
|
* Based on the Python SlicePlaneFactory from Atamai, Inc.
|
|
*
|
|
* @sa
|
|
* vtk3DWidget vtkBoxWidget vtkLineWidget vtkPlaneWidget vtkPointWidget
|
|
* vtkPolyDataSourceWidget vtkSphereWidget vtkImplicitPlaneWidget
|
|
*/
|
|
|
|
#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:
|
|
/**
|
|
* Instantiate the object.
|
|
*/
|
|
static vtkImagePlaneWidget* New();
|
|
|
|
vtkTypeMacro(vtkImagePlaneWidget, vtkPolyDataSourceWidget);
|
|
void PrintSelf(ostream& os, vtkIndent indent) override;
|
|
|
|
//@{
|
|
/**
|
|
* Methods that satisfy the superclass' API.
|
|
*/
|
|
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);
|
|
}
|
|
//@}
|
|
|
|
/**
|
|
* Set the vtkImageData* input for the vtkImageReslice.
|
|
*/
|
|
void SetInputConnection(vtkAlgorithmOutput* aout) override;
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the origin of the plane.
|
|
*/
|
|
void SetOrigin(double x, double y, double z);
|
|
void SetOrigin(double xyz[3]);
|
|
double* GetOrigin() VTK_SIZEHINT(3);
|
|
void GetOrigin(double xyz[3]);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the position of the point defining the first axis of the plane.
|
|
*/
|
|
void SetPoint1(double x, double y, double z);
|
|
void SetPoint1(double xyz[3]);
|
|
double* GetPoint1() VTK_SIZEHINT(3);
|
|
void GetPoint1(double xyz[3]);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the position of the point defining the second axis of the plane.
|
|
*/
|
|
void SetPoint2(double x, double y, double z);
|
|
void SetPoint2(double xyz[3]);
|
|
double* GetPoint2() VTK_SIZEHINT(3);
|
|
void GetPoint2(double xyz[3]);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Get the center of the plane.
|
|
*/
|
|
double* GetCenter() VTK_SIZEHINT(3);
|
|
void GetCenter(double xyz[3]);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Get the normal to the plane.
|
|
*/
|
|
double* GetNormal() VTK_SIZEHINT(3);
|
|
void GetNormal(double xyz[3]);
|
|
//@}
|
|
|
|
/**
|
|
* Get the vector from the plane origin to point1.
|
|
*/
|
|
void GetVector1(double v1[3]);
|
|
|
|
/**
|
|
* Get the vector from the plane origin to point2.
|
|
*/
|
|
void GetVector2(double v2[3]);
|
|
|
|
/**
|
|
* Get the slice position in terms of the data extent.
|
|
*/
|
|
int GetSliceIndex();
|
|
|
|
/**
|
|
* Set the slice position in terms of the data extent.
|
|
*/
|
|
void SetSliceIndex(int index);
|
|
|
|
/**
|
|
* Get the position of the slice along its normal.
|
|
*/
|
|
double GetSlicePosition();
|
|
|
|
/**
|
|
* Set the position of the slice along its normal.
|
|
*/
|
|
void SetSlicePosition(double position);
|
|
|
|
//@{
|
|
/**
|
|
* Set the interpolation to use when texturing the plane.
|
|
*/
|
|
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); }
|
|
//@}
|
|
|
|
/**
|
|
* Convenience method to get the vtkImageReslice output.
|
|
*/
|
|
vtkImageData* GetResliceOutput();
|
|
|
|
//@{
|
|
/**
|
|
* Make sure that the plane remains within the volume.
|
|
* Default is On.
|
|
*/
|
|
vtkSetMacro(RestrictPlaneToVolume, vtkTypeBool);
|
|
vtkGetMacro(RestrictPlaneToVolume, vtkTypeBool);
|
|
vtkBooleanMacro(RestrictPlaneToVolume, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Let the user control the lookup table. NOTE: apply this method BEFORE
|
|
* applying the SetLookupTable method.
|
|
* Default is Off.
|
|
*/
|
|
vtkSetMacro(UserControlledLookupTable, vtkTypeBool);
|
|
vtkGetMacro(UserControlledLookupTable, vtkTypeBool);
|
|
vtkBooleanMacro(UserControlledLookupTable, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Specify whether to interpolate the texture or not. When off, the
|
|
* reslice interpolation is nearest neighbour regardless of how the
|
|
* interpolation is set through the API. Set before setting the
|
|
* vtkImageData input. Default is On.
|
|
*/
|
|
vtkSetMacro(TextureInterpolate, vtkTypeBool);
|
|
vtkGetMacro(TextureInterpolate, vtkTypeBool);
|
|
vtkBooleanMacro(TextureInterpolate, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Control the visibility of the actual texture mapped reformatted plane.
|
|
* in some cases you may only want the plane outline for example.
|
|
*/
|
|
virtual void SetTextureVisibility(vtkTypeBool);
|
|
vtkGetMacro(TextureVisibility, vtkTypeBool);
|
|
vtkBooleanMacro(TextureVisibility, vtkTypeBool);
|
|
//@}
|
|
|
|
/**
|
|
* Grab the polydata (including points) that defines the plane. The
|
|
* polydata consists of (res+1)*(res+1) points, and res*res quadrilateral
|
|
* polygons, where res is the resolution of the plane. These point values
|
|
* are guaranteed to be up-to-date when either the InteractionEvent or
|
|
* EndInteraction events are invoked. The user provides the vtkPolyData and
|
|
* the points and polygons are added to it.
|
|
*/
|
|
void GetPolyData(vtkPolyData* pd);
|
|
|
|
/**
|
|
* Satisfies superclass API. This returns a pointer to the underlying
|
|
* vtkPolyData. Make changes to this before calling the initial PlaceWidget()
|
|
* to have the initial placement follow suit. Or, make changes after the
|
|
* widget has been initialised and call UpdatePlacement() to realise.
|
|
*/
|
|
vtkPolyDataAlgorithm* GetPolyDataAlgorithm() override;
|
|
|
|
/**
|
|
* Satisfies superclass API. This will change the state of the widget to
|
|
* match changes that have been made to the underlying vtkPolyDataSource
|
|
*/
|
|
void UpdatePlacement(void) override;
|
|
|
|
/**
|
|
* Convenience method to get the texture used by this widget. This can be
|
|
* used in external slice viewers.
|
|
*/
|
|
vtkTexture* GetTexture();
|
|
|
|
//@{
|
|
/**
|
|
* Convenience method to get the vtkImageMapToColors filter used by this
|
|
* widget. The user can properly render other transparent actors in a
|
|
* scene by calling the filter's SetOutputFormatToRGB and
|
|
* PassAlphaToOutputOff.
|
|
*/
|
|
vtkGetObjectMacro(ColorMap, vtkImageMapToColors);
|
|
virtual void SetColorMap(vtkImageMapToColors*);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the plane's outline properties. The properties of the plane's
|
|
* outline when selected and unselected can be manipulated.
|
|
*/
|
|
virtual void SetPlaneProperty(vtkProperty*);
|
|
vtkGetObjectMacro(PlaneProperty, vtkProperty);
|
|
virtual void SetSelectedPlaneProperty(vtkProperty*);
|
|
vtkGetObjectMacro(SelectedPlaneProperty, vtkProperty);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Convenience method sets the plane orientation normal to the
|
|
* x, y, or z axes. Default is XAxes (0).
|
|
*/
|
|
void SetPlaneOrientation(int);
|
|
vtkGetMacro(PlaneOrientation, int);
|
|
void SetPlaneOrientationToXAxes() { this->SetPlaneOrientation(0); }
|
|
void SetPlaneOrientationToYAxes() { this->SetPlaneOrientation(1); }
|
|
void SetPlaneOrientationToZAxes() { this->SetPlaneOrientation(2); }
|
|
//@}
|
|
|
|
/**
|
|
* Set the internal picker to one defined by the user. In this way,
|
|
* a set of three orthogonal planes can share the same picker so that
|
|
* picking is performed correctly. The default internal picker can be
|
|
* re-set/allocated by setting to 0 (nullptr).
|
|
*/
|
|
void SetPicker(vtkAbstractPropPicker*);
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the internal lookuptable (lut) to one defined by the user, or,
|
|
* alternatively, to the lut of another vtkImgePlaneWidget. In this way,
|
|
* a set of three orthogonal planes can share the same lut so that
|
|
* window-levelling is performed uniformly among planes. The default
|
|
* internal lut can be re- set/allocated by setting to 0 (nullptr).
|
|
*/
|
|
virtual void SetLookupTable(vtkLookupTable*);
|
|
vtkGetObjectMacro(LookupTable, vtkLookupTable);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Enable/disable text display of window-level, image coordinates and
|
|
* scalar values in a render window.
|
|
*/
|
|
vtkSetMacro(DisplayText, vtkTypeBool);
|
|
vtkGetMacro(DisplayText, vtkTypeBool);
|
|
vtkBooleanMacro(DisplayText, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set the properties of the cross-hair cursor.
|
|
*/
|
|
virtual void SetCursorProperty(vtkProperty*);
|
|
vtkGetObjectMacro(CursorProperty, vtkProperty);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set the properties of the margins.
|
|
*/
|
|
virtual void SetMarginProperty(vtkProperty*);
|
|
vtkGetObjectMacro(MarginProperty, vtkProperty);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set the size of the margins based on a percentage of the
|
|
* plane's width and height, limited between 0 and 50%.
|
|
*/
|
|
vtkSetClampMacro(MarginSizeX, double, 0.0, 0.5);
|
|
vtkGetMacro(MarginSizeX, double);
|
|
vtkSetClampMacro(MarginSizeY, double, 0.0, 0.5);
|
|
vtkGetMacro(MarginSizeY, double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the text property for the image data and window-level annotation.
|
|
*/
|
|
void SetTextProperty(vtkTextProperty* tprop);
|
|
vtkTextProperty* GetTextProperty();
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the property for the resliced image.
|
|
*/
|
|
virtual void SetTexturePlaneProperty(vtkProperty*);
|
|
vtkGetObjectMacro(TexturePlaneProperty, vtkProperty);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the current window and level values. SetWindowLevel should
|
|
* only be called after SetInput. If a shared lookup table is being used,
|
|
* a callback is required to update the window level values without having
|
|
* to update the lookup table again.
|
|
*/
|
|
void SetWindowLevel(double window, double level, int copy = 0);
|
|
void GetWindowLevel(double wl[2]);
|
|
double GetWindow() { return this->CurrentWindow; }
|
|
double GetLevel() { return this->CurrentLevel; }
|
|
//@}
|
|
|
|
/**
|
|
* Get the image coordinate position and voxel value. Currently only
|
|
* supports single component image data.
|
|
*/
|
|
int GetCursorData(double xyzv[4]);
|
|
|
|
/**
|
|
* Get the status of the cursor data. If this returns 1 the
|
|
* CurrentCursorPosition and CurrentImageValue will have current
|
|
* data. If it returns 0, these values are invalid.
|
|
*/
|
|
int GetCursorDataStatus();
|
|
|
|
//@{
|
|
/**
|
|
* Get the current cursor position. To be used in conjunction with
|
|
* GetCursorDataStatus.
|
|
*/
|
|
vtkGetVectorMacro(CurrentCursorPosition, double, 3);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Get the current image value at the current cursor position. To
|
|
* be used in conjunction with GetCursorDataStatus. The value is
|
|
* VTK_DOUBLE_MAX when the data is invalid.
|
|
*/
|
|
vtkGetMacro(CurrentImageValue, double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Get the current reslice class and reslice axes
|
|
*/
|
|
vtkGetObjectMacro(ResliceAxes, vtkMatrix4x4);
|
|
vtkGetObjectMacro(Reslice, vtkImageReslice);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Choose between voxel centered or continuous cursor probing. With voxel
|
|
* centered probing, the cursor snaps to the nearest voxel and the reported
|
|
* cursor coordinates are extent based. With continuous probing, voxel data
|
|
* is interpolated using vtkDataSetAttributes' InterpolatePoint method and
|
|
* the reported coordinates are 3D spatial continuous.
|
|
*/
|
|
vtkSetMacro(UseContinuousCursor, vtkTypeBool);
|
|
vtkGetMacro(UseContinuousCursor, vtkTypeBool);
|
|
vtkBooleanMacro(UseContinuousCursor, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Enable/disable mouse interaction so the widget remains on display.
|
|
*/
|
|
void SetInteraction(vtkTypeBool interact);
|
|
vtkGetMacro(Interaction, vtkTypeBool);
|
|
vtkBooleanMacro(Interaction, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set action associated to buttons.
|
|
*/
|
|
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);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set the auto-modifiers associated to buttons.
|
|
* This allows users to bind some buttons to actions that are usually
|
|
* triggered by a key modifier. For example, if you do not need cursoring,
|
|
* you can bind the left button action to VTK_SLICE_MOTION_ACTION (see above)
|
|
* and the left button auto modifier to VTK_CONTROL_MODIFIER: you end up with
|
|
* the left button controlling panning without pressing a key.
|
|
*/
|
|
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
|