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

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


  Program:   Visualization Toolkit

  Module:    vtkBoxWidget.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 vtkBoxWidget_h

#define vtkBoxWidget_h


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

#include "vtk3DWidget.h"


class vtkActor;

class vtkCellPicker;

class vtkPlanes;

class vtkPoints;

class vtkPolyData;

class vtkPolyDataMapper;

class vtkProp;

class vtkProperty;

class vtkSphereSource;

class vtkTransform;


class VTKINTERACTIONWIDGETS_EXPORT vtkBoxWidget : public vtk3DWidget

{

public:

  static vtkBoxWidget *New();


  vtkTypeMacro(vtkBoxWidget,vtk3DWidget);

  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 GetPlanes(vtkPlanes *planes);


  vtkSetMacro(InsideOut,int);

  vtkGetMacro(InsideOut,int);

  vtkBooleanMacro(InsideOut,int);


  virtual void GetTransform(vtkTransform *t);


  virtual void SetTransform(vtkTransform* t);


  void GetPolyData(vtkPolyData *pd);


  vtkGetObjectMacro(HandleProperty,vtkProperty);

  vtkGetObjectMacro(SelectedHandleProperty,vtkProperty);


  void HandlesOn();

  void HandlesOff();


  vtkGetObjectMacro(FaceProperty,vtkProperty);

  vtkGetObjectMacro(SelectedFaceProperty,vtkProperty);


  vtkGetObjectMacro(OutlineProperty,vtkProperty);

  vtkGetObjectMacro(SelectedOutlineProperty,vtkProperty);


  void SetOutlineFaceWires(int);

  vtkGetMacro(OutlineFaceWires,int);

  void OutlineFaceWiresOn() {this->SetOutlineFaceWires(1);}

  void OutlineFaceWiresOff() {this->SetOutlineFaceWires(0);}


  void SetOutlineCursorWires(int);

  vtkGetMacro(OutlineCursorWires,int);

  void OutlineCursorWiresOn() {this->SetOutlineCursorWires(1);}

  void OutlineCursorWiresOff() {this->SetOutlineCursorWires(0);}


  vtkSetMacro(TranslationEnabled,int);

  vtkGetMacro(TranslationEnabled,int);

  vtkBooleanMacro(TranslationEnabled,int);

  vtkSetMacro(ScalingEnabled,int);

  vtkGetMacro(ScalingEnabled,int);

  vtkBooleanMacro(ScalingEnabled,int);

  vtkSetMacro(RotationEnabled,int);

  vtkGetMacro(RotationEnabled,int);

  vtkBooleanMacro(RotationEnabled,int);


protected:

  vtkBoxWidget();

  ~vtkBoxWidget();


//BTX - manage the state of the widget

  int State;

  enum WidgetState

  {

    Start=0,

    Moving,

    Scaling,

    Outside

  };

//ETX


  // Handles the events

  static void ProcessEvents(vtkObject* object,

                            unsigned long event,

                            void* clientdata,

                            void* calldata);


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


  // the hexahedron (6 faces)

  vtkActor          *HexActor;

  vtkPolyDataMapper *HexMapper;

  vtkPolyData       *HexPolyData;

  vtkPoints         *Points;  //used by others as well

  double             N[6][3]; //the normals of the faces


  // A face of the hexahedron

  vtkActor          *HexFace;

  vtkPolyDataMapper *HexFaceMapper;

  vtkPolyData       *HexFacePolyData;


  // glyphs representing hot spots (e.g., handles)

  vtkActor          **Handle;

  vtkPolyDataMapper **HandleMapper;

  vtkSphereSource   **HandleGeometry;

  virtual void PositionHandles();

  int HighlightHandle(vtkProp *prop); //returns cell id

  void HighlightFace(int cellId);

  void HighlightOutline(int highlight);

  void ComputeNormals();

  virtual void SizeHandles();


  // wireframe outline

  vtkActor          *HexOutline;

  vtkPolyDataMapper *OutlineMapper;

  vtkPolyData       *OutlinePolyData;


  // Do the picking

  vtkCellPicker *HandlePicker;

  vtkCellPicker *HexPicker;

  vtkActor *CurrentHandle;

  int      CurrentHexFace;


  // Register internal Pickers within PickingManager

  virtual void RegisterPickers();


  // Methods to manipulate the hexahedron.

  virtual void Translate(double *p1, double *p2);

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

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

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

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

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

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

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

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


  //"dir" is the direction in which the face can be moved i.e. the axis passing

  //through the center

  void MoveFace(double *p1, double *p2, double *dir,

                double *x1, double *x2, double *x3, double *x4,

                double *x5);

  //Helper method to obtain the direction in which the face is to be moved.

  //Handles special cases where some of the scale factors are 0.

  void GetDirection(const double Nx[3],const double Ny[3],

                    const double Nz[3], double dir[3]);


  // Transform the hexahedral points (used for rotations)

  vtkTransform *Transform;


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

  // the manipulator in general.

  vtkProperty *HandleProperty;

  vtkProperty *SelectedHandleProperty;

  vtkProperty *FaceProperty;

  vtkProperty *SelectedFaceProperty;

  vtkProperty *OutlineProperty;

  vtkProperty *SelectedOutlineProperty;

  void CreateDefaultProperties();


  // Control the orientation of the normals

  int InsideOut;

  int OutlineFaceWires;

  int OutlineCursorWires;

  void GenerateOutline();


  // Control whether scaling, rotation, and translation are supported

  int TranslationEnabled;

  int ScalingEnabled;

  int RotationEnabled;


private:

  vtkBoxWidget(const vtkBoxWidget&);  //Not implemented

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

};


#endif