vtkConstrainedPointHandleRepresentation.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkConstrainedPointHandleRepresentation.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 vtkConstrainedPointHandleRepresentation_h
#define vtkConstrainedPointHandleRepresentation_h
 
#include "vtkHandleRepresentation.h"
#include "vtkInteractionWidgetsModule.h" // For export macro
 
class vtkProperty;
class vtkActor;
class vtkPolyDataMapper;
class vtkPolyData;
class vtkGlyph3D;
class vtkPoints;
class vtkPolyData;
class vtkPlane;
class vtkPlaneCollection;
class vtkPlanes;
class vtkRenderer;
 
class VTKINTERACTIONWIDGETS_EXPORT vtkConstrainedPointHandleRepresentation
  : public vtkHandleRepresentation
{
public:
  static vtkConstrainedPointHandleRepresentation* New();
 
 
  vtkTypeMacro(vtkConstrainedPointHandleRepresentation, vtkHandleRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  using vtkHandleRepresentation::Translate;
 
 
  void SetCursorShape(vtkPolyData* cursorShape);
  vtkPolyData* GetCursorShape();
 
 
  void SetActiveCursorShape(vtkPolyData* activeShape);
  vtkPolyData* GetActiveCursorShape();
 
 
  vtkSetClampMacro(ProjectionNormal, int, vtkConstrainedPointHandleRepresentation::XAxis,
    vtkConstrainedPointHandleRepresentation::Oblique);
  vtkGetMacro(ProjectionNormal, int);
 
  void SetProjectionNormalToXAxis()
  {
    this->SetProjectionNormal(vtkConstrainedPointHandleRepresentation::XAxis);
  }
  void SetProjectionNormalToYAxis()
  {
    this->SetProjectionNormal(vtkConstrainedPointHandleRepresentation::YAxis);
  }
  void SetProjectionNormalToZAxis()
  {
    this->SetProjectionNormal(vtkConstrainedPointHandleRepresentation::ZAxis);
  }
  void SetProjectionNormalToOblique()
  {
    this->SetProjectionNormal(vtkConstrainedPointHandleRepresentation::Oblique);
  }
 
 
  void SetObliquePlane(vtkPlane*);
  vtkGetObjectMacro(ObliquePlane, vtkPlane);
 
 
  void SetProjectionPosition(double position);
  vtkGetMacro(ProjectionPosition, double);
 
 
  void AddBoundingPlane(vtkPlane* plane);
  void RemoveBoundingPlane(vtkPlane* plane);
  void RemoveAllBoundingPlanes();
  virtual void SetBoundingPlanes(vtkPlaneCollection*);
  vtkGetObjectMacro(BoundingPlanes, vtkPlaneCollection);
  void SetBoundingPlanes(vtkPlanes* planes);
 
  int CheckConstraint(vtkRenderer* renderer, double pos[2]) override;
 
 
  void SetPosition(double x, double y, double z);
  void SetPosition(double xyz[3]);
  double* GetPosition();
  void GetPosition(double xyz[3]);
 
 
  vtkGetObjectMacro(Property, vtkProperty);
 
 
  vtkGetObjectMacro(SelectedProperty, vtkProperty);
 
 
  vtkGetObjectMacro(ActiveProperty, vtkProperty);
 
 
  void SetRenderer(vtkRenderer* ren) override;
  void BuildRepresentation() override;
  void StartWidgetInteraction(double eventPos[2]) override;
  void WidgetInteraction(double eventPos[2]) override;
  int ComputeInteractionState(int X, int Y, int modify) override;
 
  void SetDisplayPosition(double pos[3]) override;
 
 
  void GetActors(vtkPropCollection*) override;
  void ReleaseGraphicsResources(vtkWindow*) override;
  int RenderOverlay(vtkViewport* viewport) override;
  int RenderOpaqueGeometry(vtkViewport* viewport) override;
  int RenderTranslucentPolygonalGeometry(vtkViewport* viewport) override;
  vtkTypeBool HasTranslucentPolygonalGeometry() override;
  void ShallowCopy(vtkProp* prop) override;
 
  enum
  {
    XAxis = 0,
    YAxis,
    ZAxis,
    Oblique
  };
 
  void Highlight(int highlight) override;
 
protected:
  vtkConstrainedPointHandleRepresentation();
  ~vtkConstrainedPointHandleRepresentation() override;
 
  // Render the cursor
  vtkActor* Actor;
  vtkPolyDataMapper* Mapper;
  vtkGlyph3D* Glypher;
  vtkPolyData* CursorShape;
  vtkPolyData* ActiveCursorShape;
  vtkPolyData* FocalData;
  vtkPoints* FocalPoint;
 
  // Support picking
  double LastPickPosition[3];
  double LastEventPosition[2];
 
  // Methods to manipulate the cursor
  void Translate(const double* eventPos) override;
  void Scale(const double* eventPos);
 
  // Properties used to control the appearance of selected objects and
  // the manipulator in general.
  vtkProperty* Property;
  vtkProperty* SelectedProperty;
  vtkProperty* ActiveProperty;
  void CreateDefaultProperties();
 
  // Controlling vars
  int ProjectionNormal;
  double ProjectionPosition;
  int ProjectToPlane;
  vtkPlane* ObliquePlane;
 
  vtkPlaneCollection* BoundingPlanes;
 
  // Internal method for computing 3D location from 2D screen position
  int GetIntersectionPosition(const double eventPos[2], double worldPos[3], double tolerance = 0.0,
    vtkRenderer* renderer = nullptr);
 
  // Internal method for getting the project normal as a vector
  void GetProjectionNormal(double normal[3]);
 
  // Internal method for getting the origin of the
  // constraining plane as a 3-tuple
  void GetProjectionOrigin(double origin[3]);
 
  // Distance between where the mouse event happens and where the
  // widget is focused - maintain this distance during interaction.
  double InteractionOffset[2];
 
private:
  vtkConstrainedPointHandleRepresentation(const vtkConstrainedPointHandleRepresentation&) = delete;
  void operator=(const vtkConstrainedPointHandleRepresentation&) = delete;
};
 
#endif