vtkPointCloudRepresentation.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkPointCloudRepresentation.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 vtkPointCloudRepresentation_h
#define vtkPointCloudRepresentation_h
 
#include "vtkDeprecation.h"              // For VTK_DEPRECATED_IN_9_2_0
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkLegacy.h"                   // for VTK_LEGACY_REMOVE
#include "vtkWidgetRepresentation.h"
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor;
class vtkPolyDataMapper;
class vtkOutlineFilter;
class vtkActor2D;
class vtkCoordinate;
class vtkPolyDataMapper2D;
class vtkProperty2D;
class vtkPolyData;
class vtkPicker;
class vtkPointPicker;
class vtkPointSet;
class vtkGlyphSource2D;
struct vtkPointCloudPicker;
 
class VTKINTERACTIONWIDGETS_EXPORT vtkPointCloudRepresentation : public vtkWidgetRepresentation
{
  friend struct vtkPointCloudPicker;
 
public:
  static vtkPointCloudRepresentation* New();
 
 
  vtkTypeMacro(vtkPointCloudRepresentation, vtkWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void PlacePointCloud(vtkActor* a);
  void PlacePointCloud(vtkPointSet* ps);
 
 
  vtkGetObjectMacro(PointCloudActor, vtkActor);
  vtkGetObjectMacro(PointCloudMapper, vtkPolyDataMapper);
 
  vtkIdType GetPointId() { return this->PointId; }
 
 
  const double* GetPointCoordinates() { return this->PointCoordinates; }
  void GetPointCoordinates(double x[3])
  {
    x[0] = this->PointCoordinates[0];
    x[1] = this->PointCoordinates[1];
    x[2] = this->PointCoordinates[2];
  }
 
 
  vtkSetMacro(Highlighting, bool);
  vtkGetMacro(Highlighting, bool);
  vtkBooleanMacro(Highlighting, bool);
 
  // Enums define the state of the representation relative to the mouse pointer
  // position. Used by ComputeInteractionState() to communicate with the
  // widget.
  enum InteractionStateType
  {
    Outside = 0, // no points nor outline selected
    OverOutline, // mouse is over the bounding box of the point cloud
    Over,        // mouse is over a point
    Selecting    // user has selected the point
  };
#if !defined(VTK_LEGACY_REMOVE)
  VTK_DEPRECATED_IN_9_2_0("because leading underscore is reserved")
  typedef InteractionStateType _InteractionState;
#endif
 
 
  vtkSetClampMacro(InteractionState, int, Outside, Selecting);
 
 
  double* GetBounds() VTK_SIZEHINT(6) override;
  void BuildRepresentation() override {}
  int ComputeInteractionState(int X, int Y, int modify = 0) override;
 
 
  void GetActors(vtkPropCollection* pc) override;
  void GetActors2D(vtkPropCollection* pc) override;
  int RenderOpaqueGeometry(vtkViewport* viewport) override;
  int RenderTranslucentPolygonalGeometry(vtkViewport* viewport) override;
  vtkTypeBool HasTranslucentPolygonalGeometry() override;
  void ReleaseGraphicsResources(vtkWindow*) override;
  int RenderOverlay(vtkViewport*) override;
 
 
  enum PickingModeType
  {
    HARDWARE_PICKING = 0,
    SOFTWARE_PICKING
  };
#if !defined(VTK_LEGACY_REMOVE)
  VTK_DEPRECATED_IN_9_2_0("because leading underscore is reserved")
  typedef PickingModeType _Picking_Mode;
#endif
  vtkSetClampMacro(PickingMode, int, HARDWARE_PICKING, SOFTWARE_PICKING);
  vtkGetMacro(PickingMode, int);
  void SetPickingModeToHardware() { this->SetPickingMode(HARDWARE_PICKING); }
  void SetPickingModeToSoftware() { this->SetPickingMode(SOFTWARE_PICKING); }
 
 
  vtkSetMacro(HardwarePickingTolerance, unsigned int);
  vtkGetMacro(HardwarePickingTolerance, unsigned int);
 
 
  vtkSetClampMacro(SoftwarePickingTolerance, double, 0.0, 100.0);
  vtkGetMacro(SoftwarePickingTolerance, double);
 
  /*
   * Register internal Pickers within PickingManager
   */
  void RegisterPickers() override;
 
protected:
  vtkPointCloudRepresentation();
  ~vtkPointCloudRepresentation() override;
 
  // The point cloud that is being operated on
  vtkActor* PointCloudActor;
  vtkPolyDataMapper* PointCloudMapper;
  vtkPointSet* PointCloud;
 
  // The selected point id and coordinates
  vtkIdType PointId;
  double PointCoordinates[3];
 
  // Data members to manage state
  bool Highlighting;
  int PickingMode;
  unsigned int HardwarePickingTolerance;
  double SoftwarePickingTolerance;
  vtkPicker* OutlinePicker;
  vtkPointCloudPicker* PointCloudPicker;
 
  // Draw an outline around the point cloud
  vtkActor* OutlineActor;
  vtkPolyDataMapper* OutlineMapper;
  vtkOutlineFilter* OutlineFilter;
 
  // Highlight the selected point
  vtkActor2D* SelectionActor;
  vtkCoordinate* SelectionCoordinate;
  vtkPolyDataMapper2D* SelectionMapper;
  vtkGlyphSource2D* SelectionShape;
 
  vtkProperty2D* SelectionProperty;
  void CreateDefaultProperties();
 
private:
  vtkPointCloudRepresentation(const vtkPointCloudRepresentation&) = delete;
  void operator=(const vtkPointCloudRepresentation&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif