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

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


  Program:   Visualization Toolkit

  Module:    vtkImplicitPlaneRepresentation.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 vtkImplicitPlaneRepresentation_h

#define vtkImplicitPlaneRepresentation_h


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

#include "vtkWidgetRepresentation.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 vtkPolyDataAlgorithm;

class vtkTransform;

class vtkBox;

class vtkLookupTable;


class VTKINTERACTIONWIDGETS_EXPORT vtkImplicitPlaneRepresentation : public vtkWidgetRepresentation

{

public:

  static vtkImplicitPlaneRepresentation *New();


  vtkTypeMacro(vtkImplicitPlaneRepresentation,vtkWidgetRepresentation);

  void PrintSelf(ostream& os, vtkIndent indent);


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

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

  void SetNormalToCamera();

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


  virtual void SetLockNormalToCamera(int);

  vtkGetMacro(LockNormalToCamera,int);

  vtkBooleanMacro(LockNormalToCamera,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);


  void GetPolyData(vtkPolyData *pd);


  vtkPolyDataAlgorithm* GetPolyDataAlgorithm();


  void GetPlane(vtkPlane *plane);


  void UpdatePlacement(void);


  vtkGetObjectMacro(NormalProperty,vtkProperty);

  vtkGetObjectMacro(SelectedNormalProperty,vtkProperty);


  vtkGetObjectMacro(PlaneProperty,vtkProperty);

  vtkGetObjectMacro(SelectedPlaneProperty,vtkProperty);


  vtkGetObjectMacro(OutlineProperty,vtkProperty);

  vtkGetObjectMacro(SelectedOutlineProperty,vtkProperty);


  vtkGetObjectMacro(EdgesProperty,vtkProperty);


  void SetEdgeColor(vtkLookupTable*);

  void SetEdgeColor(double, double, double);

  void SetEdgeColor(double x[3]);


  vtkSetClampMacro(BumpDistance,double,0.000001,1);

  vtkGetMacro(BumpDistance,double);


  void BumpPlane(int dir, double factor);


  void PushPlane(double distance);


  virtual int ComputeInteractionState(int X, int Y, int modify=0);

  virtual void PlaceWidget(double bounds[6]);

  virtual void BuildRepresentation();

  virtual void StartWidgetInteraction(double eventPos[2]);

  virtual void WidgetInteraction(double newEventPos[2]);

  virtual void EndWidgetInteraction(double newEventPos[2]);


  virtual double *GetBounds();

  virtual void GetActors(vtkPropCollection *pc);

  virtual void ReleaseGraphicsResources(vtkWindow*);

  virtual int RenderOpaqueGeometry(vtkViewport*);

  virtual int RenderTranslucentPolygonalGeometry(vtkViewport*);

  virtual int HasTranslucentPolygonalGeometry();


//BTX - manage the state of the widget

  enum _InteractionState

  {

    Outside=0,

    Moving,

    MovingOutline,

    MovingOrigin,

    Rotating,

    Pushing,

    Scaling

  };

//ETX


  vtkSetClampMacro(InteractionState,int,Outside,Scaling);


  virtual void SetRepresentationState(int);

  vtkGetMacro(RepresentationState, int);


protected:

  vtkImplicitPlaneRepresentation();

  ~vtkImplicitPlaneRepresentation();


  int RepresentationState;


  // Keep track of event positions

  double LastEventPosition[3];


  // Controlling ivars

  int NormalToXAxis;

  int NormalToYAxis;

  int NormalToZAxis;


  // Locking normal to camera

  int LockNormalToCamera;


  // Controlling the push operation

  double BumpDistance;


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

  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


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


  // 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(double X, double 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, double X, double Y);

  void SizeHandles();


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


  // Support GetBounds() method

  vtkBox *BoundingBox;


private:

  vtkImplicitPlaneRepresentation(const vtkImplicitPlaneRepresentation&);  //Not implemented

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

};


#endif