doxygen/html/vtkBoxWidget_8h_source.html

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


  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 "vtk3DWidget.h"

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


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


  void SetEnabled(int) override;

  void PlaceWidget(double bounds[6]) override;

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

  void PlaceWidget(

    double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) override

  {

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

  }


  void GetPlanes(vtkPlanes* planes);


  vtkSetMacro(InsideOut, vtkTypeBool);

  vtkGetMacro(InsideOut, vtkTypeBool);

  vtkBooleanMacro(InsideOut, vtkTypeBool);


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

  vtkGetMacro(TranslationEnabled, vtkTypeBool);

  vtkBooleanMacro(TranslationEnabled, vtkTypeBool);

  vtkSetMacro(ScalingEnabled, vtkTypeBool);

  vtkGetMacro(ScalingEnabled, vtkTypeBool);

  vtkBooleanMacro(ScalingEnabled, vtkTypeBool);

  vtkSetMacro(RotationEnabled, vtkTypeBool);

  vtkGetMacro(RotationEnabled, vtkTypeBool);

  vtkBooleanMacro(RotationEnabled, vtkTypeBool);


protected:

  vtkBoxWidget();

  ~vtkBoxWidget() override;


  // Manage the state of the widget

  int State;

  enum WidgetState

  {

    Start = 0,

    Moving,

    Scaling,

    Outside

  };


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

  void SizeHandles() override;


  // wireframe outline

  vtkActor* HexOutline;

  vtkPolyDataMapper* OutlineMapper;

  vtkPolyData* OutlinePolyData;


  // Do the picking

  vtkCellPicker* HandlePicker;

  vtkCellPicker* HexPicker;

  vtkActor* CurrentHandle;

  int CurrentHexFace;


  // Register internal Pickers within PickingManager

  void RegisterPickers() override;


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

  vtkTypeBool InsideOut;

  int OutlineFaceWires;

  int OutlineCursorWires;

  void GenerateOutline();


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

  vtkTypeBool TranslationEnabled;

  vtkTypeBool ScalingEnabled;

  vtkTypeBool RotationEnabled;


private:

  vtkBoxWidget(const vtkBoxWidget&) = delete;

  void operator=(const vtkBoxWidget&) = delete;

};


#endif