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

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


  Program:   Visualization Toolkit

  Module:    vtkImplicitPlaneWidget.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 vtkImplicitPlaneWidget_h

#define vtkImplicitPlaneWidget_h


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

#include "vtkPolyDataSourceWidget.h"


class vtkActor;

class vtkPolyDataMapper;

class vtkCellPicker;

class vtkConeSource;

class vtkLineSource;

class vtkSphereSource;

class vtkTubeFilter;

class vtkPlane;

class vtkCutter;

class vtkProperty;

class vtkImageData;

class vtkOutlineFilter;

class vtkFeatureEdges;

class vtkPolyData;

class vtkTransform;


class VTKINTERACTIONWIDGETS_EXPORT vtkImplicitPlaneWidget : public vtkPolyDataSourceWidget

{

public:

  static vtkImplicitPlaneWidget *New();


  vtkTypeMacro(vtkImplicitPlaneWidget,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);}


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

  virtual void SetOrigin(double x[3]);

  double* GetOrigin();

  void GetOrigin(double xyz[3]);


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

  void SetNormal(double x[3]);

  double* GetNormal();

  void GetNormal(double xyz[3]);


  void SetNormalToXAxis(int);

  vtkGetMacro(NormalToXAxis,int);

  vtkBooleanMacro(NormalToXAxis,int);

  void SetNormalToYAxis(int);

  vtkGetMacro(NormalToYAxis,int);

  vtkBooleanMacro(NormalToYAxis,int);

  void SetNormalToZAxis(int);

  vtkGetMacro(NormalToZAxis,int);

  vtkBooleanMacro(NormalToZAxis,int);


  vtkSetMacro(Tubing,int);

  vtkGetMacro(Tubing,int);

  vtkBooleanMacro(Tubing,int);


  void SetDrawPlane(int plane);

  vtkGetMacro(DrawPlane,int);

  vtkBooleanMacro(DrawPlane,int);


  vtkSetMacro(OutlineTranslation,int);

  vtkGetMacro(OutlineTranslation,int);

  vtkBooleanMacro(OutlineTranslation,int);


  vtkSetMacro(OutsideBounds,int);

  vtkGetMacro(OutsideBounds,int);

  vtkBooleanMacro(OutsideBounds,int);


  vtkSetMacro(ScaleEnabled,int);

  vtkGetMacro(ScaleEnabled,int);

  vtkBooleanMacro(ScaleEnabled,int);


  vtkSetMacro(OriginTranslation,int);

  vtkGetMacro(OriginTranslation,int);

  vtkBooleanMacro(OriginTranslation,int);


  vtkSetClampMacro(DiagonalRatio,double,0,2);

  vtkGetMacro(DiagonalRatio,double);


  void GetPolyData(vtkPolyData *pd);


  vtkPolyDataAlgorithm* GetPolyDataAlgorithm();


  void GetPlane(vtkPlane *plane);


  void UpdatePlacement();


  virtual void SizeHandles();


  vtkGetObjectMacro(NormalProperty,vtkProperty);

  vtkGetObjectMacro(SelectedNormalProperty,vtkProperty);


  vtkGetObjectMacro(PlaneProperty,vtkProperty);

  vtkGetObjectMacro(SelectedPlaneProperty,vtkProperty);


  vtkGetObjectMacro(OutlineProperty,vtkProperty);

  vtkGetObjectMacro(SelectedOutlineProperty,vtkProperty);


  vtkGetObjectMacro(EdgesProperty,vtkProperty);


protected:

  vtkImplicitPlaneWidget();

  ~vtkImplicitPlaneWidget();


//BTX - manage the state of the widget

  int State;

  enum WidgetState

  {

    Start=0,

    MovingPlane,

    MovingOutline,

    MovingOrigin,

    Scaling,

    Pushing,

    Rotating,

    Outside

  };

//ETX


  //handles the events

  static void ProcessEvents(vtkObject* object, unsigned long event,

                            void* clientdata, void* calldata);


  // ProcessEvents() dispatches to these methods.

  void OnLeftButtonDown();

  void OnLeftButtonUp();

  void OnMiddleButtonDown();

  void OnMiddleButtonUp();

  void OnRightButtonDown();

  void OnRightButtonUp();

  void OnMouseMove();


  // Controlling ivars

  int NormalToXAxis;

  int NormalToYAxis;

  int NormalToZAxis;

  void UpdateRepresentation();


  // The actual plane which is being manipulated

  vtkPlane *Plane;


  // The bounding box is represented by a single voxel image data

  vtkImageData      *Box;

  vtkOutlineFilter  *Outline;

  vtkPolyDataMapper *OutlineMapper;

  vtkActor          *OutlineActor;

  void HighlightOutline(int highlight);

  int OutlineTranslation; //whether the outline can be moved

  int ScaleEnabled; //whether the widget can be scaled

  int OutsideBounds; //whether the widget can be moved outside input's bounds


  // The cut plane is produced with a vtkCutter

  vtkCutter         *Cutter;

  vtkPolyDataMapper *CutMapper;

  vtkActor          *CutActor;

  int               DrawPlane;

  virtual void HighlightPlane(int highlight);


  // Optional tubes are represented by extracting boundary edges and tubing

  vtkFeatureEdges   *Edges;

  vtkTubeFilter     *EdgesTuber;

  vtkPolyDataMapper *EdgesMapper;

  vtkActor          *EdgesActor;

  int               Tubing; //control whether tubing is on


  // Control final length of the arrow:

  double DiagonalRatio;


  // The + normal cone

  vtkConeSource     *ConeSource;

  vtkPolyDataMapper *ConeMapper;

  vtkActor          *ConeActor;

  void HighlightNormal(int highlight);


  // The + normal line

  vtkLineSource     *LineSource;

  vtkPolyDataMapper *LineMapper;

  vtkActor          *LineActor;


  // The - normal cone

  vtkConeSource     *ConeSource2;

  vtkPolyDataMapper *ConeMapper2;

  vtkActor          *ConeActor2;


  // The - normal line

  vtkLineSource     *LineSource2;

  vtkPolyDataMapper *LineMapper2;

  vtkActor          *LineActor2;


  // The origin positioning handle

  vtkSphereSource   *Sphere;

  vtkPolyDataMapper *SphereMapper;

  vtkActor          *SphereActor;

  int OriginTranslation; //whether the origin (sphere) can be moved


  // Do the picking

  vtkCellPicker *Picker;


  // Register internal Pickers within PickingManager

  virtual void RegisterPickers();


  // Transform the normal (used for rotation)

  vtkTransform *Transform;


  // Methods to manipulate the plane

  void ConstrainOrigin(double x[3]);

  void Rotate(int X, int Y, double *p1, double *p2, double *vpn);

  void TranslatePlane(double *p1, double *p2);

  void TranslateOutline(double *p1, double *p2);

  void TranslateOrigin(double *p1, double *p2);

  void Push(double *p1, double *p2);

  void Scale(double *p1, double *p2, int X, int Y);


  // Properties used to control the appearance of selected objects and

  // the manipulator in general.

  vtkProperty *NormalProperty;

  vtkProperty *SelectedNormalProperty;

  vtkProperty *PlaneProperty;

  vtkProperty *SelectedPlaneProperty;

  vtkProperty *OutlineProperty;

  vtkProperty *SelectedOutlineProperty;

  vtkProperty *EdgesProperty;

  void CreateDefaultProperties();


  void GeneratePlane();


private:

  vtkImplicitPlaneWidget(const vtkImplicitPlaneWidget&);  //Not implemented

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

};


#endif