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

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


  Program:   Visualization Toolkit

  Module:    vtkBoxRepresentation.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 vtkBoxRepresentation_h

#define vtkBoxRepresentation_h


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

#include "vtkWidgetRepresentation.h"


class vtkActor;

class vtkPolyDataMapper;

class vtkLineSource;

class vtkSphereSource;

class vtkCellPicker;

class vtkProperty;

class vtkPolyData;

class vtkPoints;

class vtkPolyDataAlgorithm;

class vtkPointHandleRepresentation3D;

class vtkTransform;

class vtkPlanes;

class vtkBox;

class vtkDoubleArray;

class vtkMatrix4x4;


class VTKINTERACTIONWIDGETS_EXPORT vtkBoxRepresentation : public vtkWidgetRepresentation

{

public:

  static vtkBoxRepresentation *New();


  vtkTypeMacro(vtkBoxRepresentation,vtkWidgetRepresentation);

  void PrintSelf(ostream& os, vtkIndent indent);


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


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


  virtual void HandlesOn();

  virtual void HandlesOff();


  virtual void PlaceWidget(double bounds[6]);

  virtual void BuildRepresentation();

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

  virtual void StartWidgetInteraction(double e[2]);

  virtual void WidgetInteraction(double e[2]);

  virtual double *GetBounds();


  virtual void ReleaseGraphicsResources(vtkWindow*);

  virtual int  RenderOpaqueGeometry(vtkViewport*);

  virtual int  RenderTranslucentPolygonalGeometry(vtkViewport*);

  virtual int  HasTranslucentPolygonalGeometry();


//BTX - used to manage the state of the widget

  enum {Outside=0,MoveF0,MoveF1,MoveF2,MoveF3,MoveF4,MoveF5,Translating,Rotating,Scaling};

//ETX


  void SetInteractionState(int state);


protected:

  vtkBoxRepresentation();

  ~vtkBoxRepresentation();


  // Manage how the representation appears

  double LastEventPosition[3];


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

  virtual void ComputeNormals();

  virtual void SizeHandles();


  // wireframe outline

  vtkActor          *HexOutline;

  vtkPolyDataMapper *OutlineMapper;

  vtkPolyData       *OutlinePolyData;


  // Do the picking

  vtkCellPicker *HandlePicker;

  vtkCellPicker *HexPicker;

  vtkActor *CurrentHandle;

  int      CurrentHexFace;

  vtkCellPicker *LastPicker;


  // Register internal Pickers within PickingManager

  virtual void RegisterPickers();


  // Transform the hexahedral points (used for rotations)

  vtkTransform *Transform;


  // Support GetBounds() method

  vtkBox *BoundingBox;


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

  virtual void CreateDefaultProperties();


  // Control the orientation of the normals

  int InsideOut;

  int OutlineFaceWires;

  int OutlineCursorWires;

  void GenerateOutline();


  // Helper methods

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


  // Internal ivars for performance

  vtkPoints      *PlanePoints;

  vtkDoubleArray *PlaneNormals;

  vtkMatrix4x4   *Matrix;


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


private:

  vtkBoxRepresentation(const vtkBoxRepresentation&);  //Not implemented

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

};


#endif