doxygen/html/vtkImplicitCylinderRepresentation_8h_source.html

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


  Program:   Visualization Toolkit

  Module:    vtkImplicitCylinderRepresentation.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 vtkImplicitCylinderRepresentation_h

#define vtkImplicitCylinderRepresentation_h


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

#include "vtkWidgetRepresentation.h"


class vtkActor;

class vtkPolyDataMapper;

class vtkCellPicker;

class vtkConeSource;

class vtkLineSource;

class vtkSphereSource;

class vtkTubeFilter;

class vtkCylinder;

class vtkProperty;

class vtkImageData;

class vtkOutlineFilter;

class vtkFeatureEdges;

class vtkPolyData;

class vtkPolyDataAlgorithm;

class vtkTransform;

class vtkBox;

class vtkLookupTable;


#define VTK_MAX_CYL_RESOLUTION 2048


class VTKINTERACTIONWIDGETS_EXPORT vtkImplicitCylinderRepresentation

  : public vtkWidgetRepresentation

{

public:

  static vtkImplicitCylinderRepresentation* New();


  vtkTypeMacro(vtkImplicitCylinderRepresentation, vtkWidgetRepresentation);

  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetCenter(double x, double y, double z);

  void SetCenter(double x[3]);

  double* GetCenter() VTK_SIZEHINT(3);

  void GetCenter(double xyz[3]);


  void SetAxis(double x, double y, double z);

  void SetAxis(double a[3]);

  double* GetAxis() VTK_SIZEHINT(3);

  void GetAxis(double a[3]);


  void SetRadius(double r);

  double GetRadius();


  vtkSetClampMacro(MinRadius, double, 0.001, 0.25);

  vtkGetMacro(MinRadius, double);

  vtkSetClampMacro(MaxRadius, double, 0.25, VTK_FLOAT_MAX);

  vtkGetMacro(MaxRadius, double);


  void SetAlongXAxis(vtkTypeBool);

  vtkGetMacro(AlongXAxis, vtkTypeBool);

  vtkBooleanMacro(AlongXAxis, vtkTypeBool);

  void SetAlongYAxis(vtkTypeBool);

  vtkGetMacro(AlongYAxis, vtkTypeBool);

  vtkBooleanMacro(AlongYAxis, vtkTypeBool);

  void SetAlongZAxis(vtkTypeBool);

  vtkGetMacro(AlongZAxis, vtkTypeBool);

  vtkBooleanMacro(AlongZAxis, vtkTypeBool);


  void SetDrawCylinder(vtkTypeBool drawCyl);

  vtkGetMacro(DrawCylinder, vtkTypeBool);

  vtkBooleanMacro(DrawCylinder, vtkTypeBool);


  vtkSetClampMacro(Resolution, int, 8, VTK_MAX_CYL_RESOLUTION);

  vtkGetMacro(Resolution, int);


  vtkSetMacro(Tubing, vtkTypeBool);

  vtkGetMacro(Tubing, vtkTypeBool);

  vtkBooleanMacro(Tubing, vtkTypeBool);


  vtkSetMacro(OutlineTranslation, vtkTypeBool);

  vtkGetMacro(OutlineTranslation, vtkTypeBool);

  vtkBooleanMacro(OutlineTranslation, vtkTypeBool);


  vtkSetMacro(OutsideBounds, vtkTypeBool);

  vtkGetMacro(OutsideBounds, vtkTypeBool);

  vtkBooleanMacro(OutsideBounds, vtkTypeBool);


  vtkSetVector6Macro(WidgetBounds, double);

  vtkGetVector6Macro(WidgetBounds, double);


  vtkSetMacro(ConstrainToWidgetBounds, vtkTypeBool);

  vtkGetMacro(ConstrainToWidgetBounds, vtkTypeBool);

  vtkBooleanMacro(ConstrainToWidgetBounds, vtkTypeBool);


  vtkSetMacro(ScaleEnabled, vtkTypeBool);

  vtkGetMacro(ScaleEnabled, vtkTypeBool);

  vtkBooleanMacro(ScaleEnabled, vtkTypeBool);


  void GetCylinder(vtkCylinder* cyl);


  void GetPolyData(vtkPolyData* pd);


  void UpdatePlacement(void);


  vtkGetObjectMacro(AxisProperty, vtkProperty);

  vtkGetObjectMacro(SelectedAxisProperty, vtkProperty);


  vtkGetObjectMacro(CylinderProperty, vtkProperty);

  vtkGetObjectMacro(SelectedCylinderProperty, vtkProperty);


  vtkGetObjectMacro(OutlineProperty, vtkProperty);

  vtkGetObjectMacro(SelectedOutlineProperty, vtkProperty);


  vtkGetObjectMacro(EdgesProperty, vtkProperty);


  void SetEdgeColor(vtkLookupTable*);

  void SetEdgeColor(double, double, double);

  void SetEdgeColor(double x[3]);


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

  void PlaceWidget(double bounds[6]) override;

  void BuildRepresentation() override;

  void StartWidgetInteraction(double eventPos[2]) override;

  void WidgetInteraction(double newEventPos[2]) override;

  void EndWidgetInteraction(double newEventPos[2]) override;


  double* GetBounds() override;

  void GetActors(vtkPropCollection* pc) override;

  void ReleaseGraphicsResources(vtkWindow*) override;

  int RenderOpaqueGeometry(vtkViewport*) override;

  int RenderTranslucentPolygonalGeometry(vtkViewport*) override;

  vtkTypeBool HasTranslucentPolygonalGeometry() override;


  vtkSetClampMacro(BumpDistance, double, 0.000001, 1);

  vtkGetMacro(BumpDistance, double);


  void BumpCylinder(int dir, double factor);


  void PushCylinder(double distance);


  // Manage the state of the widget

  enum _InteractionState

  {

    Outside = 0,

    Moving,

    MovingOutline,

    MovingCenter,

    RotatingAxis,

    AdjustingRadius,

    Scaling,

    TranslatingCenter

  };


  vtkSetClampMacro(InteractionState, int, Outside, TranslatingCenter);


  virtual void SetRepresentationState(int);

  vtkGetMacro(RepresentationState, int);


  /*

   * 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:

  vtkImplicitCylinderRepresentation();

  ~vtkImplicitCylinderRepresentation() override;


  int RepresentationState;


  int TranslationAxis;


  // Keep track of event positions

  double LastEventPosition[3];


  // Control the radius

  double MinRadius;

  double MaxRadius;


  // Controlling the push operation

  double BumpDistance;


  // Controlling ivars

  vtkTypeBool AlongXAxis;

  vtkTypeBool AlongYAxis;

  vtkTypeBool AlongZAxis;


  // The actual cylinder which is being manipulated

  vtkCylinder* Cylinder;


  // The facet resolution for rendering purposes.

  int Resolution;


  // The bounding box is represented by a single voxel image data

  vtkImageData* Box;

  vtkOutlineFilter* Outline;

  vtkPolyDataMapper* OutlineMapper;

  vtkActor* OutlineActor;

  void HighlightOutline(int highlight);

  vtkTypeBool OutlineTranslation; // whether the outline can be moved

  vtkTypeBool ScaleEnabled;       // whether the widget can be scaled

  vtkTypeBool OutsideBounds;      // whether the widget can be moved outside input's bounds

  double WidgetBounds[6];

  int ConstrainToWidgetBounds;


  // The cut cylinder is produced with a vtkCutter

  vtkPolyData* Cyl;

  vtkPolyDataMapper* CylMapper;

  vtkActor* CylActor;

  vtkTypeBool DrawCylinder;

  void HighlightCylinder(int highlight);


  // Optional tubes are represented by extracting boundary edges and tubing

  vtkFeatureEdges* Edges;

  vtkTubeFilter* EdgesTuber;

  vtkPolyDataMapper* EdgesMapper;

  vtkActor* EdgesActor;

  vtkTypeBool Tubing; // control whether tubing is on


  // The + normal cone (i.e., in positive direction along normal)

  vtkConeSource* ConeSource;

  vtkPolyDataMapper* ConeMapper;

  vtkActor* ConeActor;

  void HighlightNormal(int highlight);


  // The + normal line

  vtkLineSource* LineSource;

  vtkPolyDataMapper* LineMapper;

  vtkActor* LineActor;


  // The - normal cone

  vtkConeSource* ConeSource2;

  vtkPolyDataMapper* ConeMapper2;

  vtkActor* ConeActor2;


  // The - normal line

  vtkLineSource* LineSource2;

  vtkPolyDataMapper* LineMapper2;

  vtkActor* LineActor2;


  // The center positioning handle

  vtkSphereSource* Sphere;

  vtkPolyDataMapper* SphereMapper;

  vtkActor* SphereActor;


  // Do the picking

  vtkCellPicker* Picker;

  vtkCellPicker* CylPicker;


  // Transform the normal (used for rotation)

  vtkTransform* Transform;


  // Methods to manipulate the cylinder

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

  void TranslateCylinder(double* p1, double* p2);

  void TranslateOutline(double* p1, double* p2);

  void TranslateCenter(double* p1, double* p2);

  void TranslateCenterOnAxis(double* p1, double* p2);

  void ScaleRadius(double* p1, double* p2);

  void AdjustRadius(double X, double Y, double* p1, double* p2);

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

  void SizeHandles();


  // Properties used to control the appearance of selected objects and

  // the manipulator in general.

  vtkProperty* AxisProperty;

  vtkProperty* SelectedAxisProperty;

  vtkProperty* CylinderProperty;

  vtkProperty* SelectedCylinderProperty;

  vtkProperty* OutlineProperty;

  vtkProperty* SelectedOutlineProperty;

  vtkProperty* EdgesProperty;

  void CreateDefaultProperties();


  // Intersect oriented infinite cylinder against bounding box

  void BuildCylinder();


  // Support GetBounds() method

  vtkBox* BoundingBox;


private:

  vtkImplicitCylinderRepresentation(const vtkImplicitCylinderRepresentation&) = delete;

  void operator=(const vtkImplicitCylinderRepresentation&) = delete;

};


#endif