v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


  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


class VTKINTERACTIONWIDGETS_EXPORT vtkImagePlaneWidget : public vtkPolyDataSourceWidget

{

public:

  static vtkImagePlaneWidget *New();


  vtkTypeMacro(vtkImagePlaneWidget,vtkPolyDataSourceWidget);

  void PrintSelf(ostream& os, vtkIndent indent);


  virtual void SetEnabled(int);

  virtual void PlaceWidget(double bounds[6]);

  void PlaceWidget()

    {this->Superclass::PlaceWidget();}

  void PlaceWidget(double xmin, double xmax, double ymin, double ymax,

                   double zmin, double zmax)

    {this->Superclass::PlaceWidget(xmin,xmax,ymin,ymax,zmin,zmax);}


  void SetInputConnection(vtkAlgorithmOutput* aout);


  void SetOrigin(double x, double y, double z);

  void SetOrigin(double xyz[3]);

  double* GetOrigin();

  void GetOrigin(double xyz[3]);


  void SetPoint1(double x, double y, double z);

  void SetPoint1(double xyz[3]);

  double* GetPoint1();

  void GetPoint1(double xyz[3]);


  void SetPoint2(double x, double y, double z);

  void SetPoint2(double xyz[3]);

  double* GetPoint2();

  void GetPoint2(double xyz[3]);


  double* GetCenter();

  void GetCenter(double xyz[3]);


  double* GetNormal();

  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,int);

  vtkGetMacro(RestrictPlaneToVolume,int);

  vtkBooleanMacro(RestrictPlaneToVolume,int);


  vtkSetMacro(UserControlledLookupTable,int);

  vtkGetMacro(UserControlledLookupTable,int);

  vtkBooleanMacro(UserControlledLookupTable,int);


  vtkSetMacro(TextureInterpolate,int);

  vtkGetMacro(TextureInterpolate,int);

  vtkBooleanMacro(TextureInterpolate,int);


  virtual void SetTextureVisibility(int);

  vtkGetMacro(TextureVisibility,int);

  vtkBooleanMacro(TextureVisibility,int);


  void GetPolyData(vtkPolyData *pd);


  vtkPolyDataAlgorithm* GetPolyDataAlgorithm();


  void UpdatePlacement(void);


  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,int);

  vtkGetMacro(DisplayText,int);

  vtkBooleanMacro(DisplayText,int);


  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,int);

  vtkGetMacro(UseContinuousCursor,int);

  vtkBooleanMacro(UseContinuousCursor,int);


  void SetInteraction(int interact);

  vtkGetMacro(Interaction,int);

  vtkBooleanMacro(Interaction,int);


  //BTX


  enum

  {

    VTK_CURSOR_ACTION       = 0,

    VTK_SLICE_MOTION_ACTION = 1,

    VTK_WINDOW_LEVEL_ACTION = 2

  };

  //ETX

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


  //BTX


  enum

  {

    VTK_NO_MODIFIER         = 0,

    VTK_SHIFT_MODIFIER      = 1,

    VTK_CONTROL_MODIFIER    = 2

  };

  //ETX

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


  int TextureVisibility;


  int LeftButtonAction;

  int MiddleButtonAction;

  int RightButtonAction;


  int LeftButtonAutoModifier;

  int MiddleButtonAutoModifier;

  int RightButtonAutoModifier;


  //BTX

  enum

  {

    VTK_NO_BUTTON     = 0,

    VTK_LEFT_BUTTON   = 1,

    VTK_MIDDLE_BUTTON = 2,

    VTK_RIGHT_BUTTON  = 3

  };

  //ETX

  int LastButtonPressed;


  //BTX - manage the state of the widget

  int State;

  enum WidgetState

  {

    Start=0,

    Cursoring,

    WindowLevelling,

    Pushing,

    Spinning,

    Rotating,

    Moving,

    Scaling,

    Outside

  };

  //ETX


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

  virtual void OnChar();


  virtual void StartCursor();

  virtual void StopCursor();

  virtual void StartSliceMotion();

  virtual void StopSliceMotion();

  virtual void StartWindowLevel();

  virtual void StopWindowLevel();


  // controlling ivars

  int    Interaction; // Is the widget responsive to mouse events

  int    PlaneOrientation;

  int    RestrictPlaneToVolume;

  double OriginalWindow;

  double OriginalLevel;

  double CurrentWindow;

  double CurrentLevel;

  double InitialWindow;

  double InitialLevel;

  int    StartWindowLevelPositionX;

  int    StartWindowLevelPositionY;

  int    ResliceInterpolate;

  int    TextureInterpolate;

  int    UserControlledLookupTable;

  int    DisplayText;


  // The geometric represenation 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

  virtual void RegisterPickers();


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

  int                UseContinuousCursor;


  // The text to display W/L, image data

  vtkTextActor *TextActor;

  char          TextBuff[128];

  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&);  //Not implemented

  void operator=(const vtkImagePlaneWidget&);  //Not implemented

};


#endif