doxygen/html/vtkBoxRepresentation_8h_source.html

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


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

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


  void GetPlanes(vtkPlanes* planes);


  // Get the underlying planes used by this rep

  // this can be used as a cropping planes in vtkMapper

  vtkPlane* GetUnderlyingPlane(int i) { return this->Planes[i]; }


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


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


  void PlaceWidget(double bounds[6]) override;

  void BuildRepresentation() override;

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

  void StartWidgetInteraction(double e[2]) override;

  void WidgetInteraction(double e[2]) override;

  double* GetBounds() VTK_SIZEHINT(6) override;

  void StartComplexInteraction(vtkRenderWindowInteractor* iren, vtkAbstractWidget* widget,

    unsigned long event, void* calldata) override;

  void ComplexInteraction(vtkRenderWindowInteractor* iren, vtkAbstractWidget* widget,

    unsigned long event, void* calldata) override;

  int ComputeComplexInteractionState(vtkRenderWindowInteractor* iren, vtkAbstractWidget* widget,

    unsigned long event, void* calldata, int modify = 0) override;

  void EndComplexInteraction(vtkRenderWindowInteractor* iren, vtkAbstractWidget* widget,

    unsigned long event, void* calldata) override;


  void ReleaseGraphicsResources(vtkWindow*) override;

  int RenderOpaqueGeometry(vtkViewport*) override;

  int RenderTranslucentPolygonalGeometry(vtkViewport*) override;

  vtkTypeBool HasTranslucentPolygonalGeometry() override;


  // Used to manage the state of the widget

  enum

  {

    Outside = 0,

    MoveF0,

    MoveF1,

    MoveF2,

    MoveF3,

    MoveF4,

    MoveF5,

    Translating,

    Rotating,

    Scaling

  };


  void SetInteractionState(int state);


  vtkGetMacro(TwoPlaneMode, bool);

  void SetTwoPlaneMode(bool);


  vtkGetMacro(SnapToAxes, bool);

  vtkSetMacro(SnapToAxes, bool);


  void StepForward();

  void StepBackward();


  /*

   * Register internal Pickers within PickingManager

   */

  void RegisterPickers() override;


  vtkGetMacro(TranslationAxis, int);

  vtkSetClampMacro(TranslationAxis, int, -1, 2);


  void SetXTranslationAxisOn() { this->TranslationAxis = Axis::XAxis; }

  void SetYTranslationAxisOn() { this->TranslationAxis = Axis::YAxis; }

  void SetZTranslationAxisOn() { this->TranslationAxis = Axis::ZAxis; }

  void SetTranslationAxisOff() { this->TranslationAxis = Axis::NONE; }


  bool IsTranslationConstrained() { return this->TranslationAxis != Axis::NONE; }


protected:

  vtkBoxRepresentation();

  ~vtkBoxRepresentation() override;


  // Manage how the representation appears

  double LastEventPosition[3];

  double LastEventOrientation[4];

  double StartEventOrientation[4];

  double SnappedEventOrientations[3][4];

  bool SnappedOrientation[3];

  bool SnapToAxes;


  bool TwoPlaneMode;


  // Constraint axis translation

  int TranslationAxis;


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


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

  vtkTypeBool InsideOut;

  int OutlineFaceWires;

  int OutlineCursorWires;

  void GenerateOutline();


  // Helper methods

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

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

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

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

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

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

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

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

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

  void UpdatePose(const double* p1, const double* d1, const double* p2, const double* d2);


  // Internal ivars for performance

  vtkPoints* PlanePoints;

  vtkDoubleArray* PlaneNormals;

  vtkMatrix4x4* Matrix;


  // The actual planes which are being manipulated

  vtkPlane* Planes[6];


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

  // through the center

  void MoveFace(const double* p1, const double* p2, const 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&) = delete;

  void operator=(const vtkBoxRepresentation&) = delete;

};


#endif