vtkAffineRepresentation2D.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkAffineRepresentation2D.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 vtkAffineRepresentation2D_h
#define vtkAffineRepresentation2D_h
 
#include "vtkAffineRepresentation.h"
#include "vtkInteractionWidgetsModule.h" // For export macro
 
class vtkProperty2D;
class vtkActor2D;
class vtkPolyDataMapper2D;
class vtkPolyData;
class vtkPoints;
class vtkCellArray;
class vtkTextProperty;
class vtkLeaderActor2D;
class vtkTextMapper;
class vtkActor2D;
 
class VTKINTERACTIONWIDGETS_EXPORT vtkAffineRepresentation2D : public vtkAffineRepresentation
{
public:
  static vtkAffineRepresentation2D* New();
 
 
  vtkTypeMacro(vtkAffineRepresentation2D, vtkAffineRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetClampMacro(BoxWidth, int, 10, VTK_INT_MAX);
  vtkGetMacro(BoxWidth, int);
  vtkSetClampMacro(CircleWidth, int, 10, VTK_INT_MAX);
  vtkGetMacro(CircleWidth, int);
  vtkSetClampMacro(AxesWidth, int, 10, VTK_INT_MAX);
  vtkGetMacro(AxesWidth, int);
 
 
  void SetOrigin(const double o[3]) { this->SetOrigin(o[0], o[1], o[2]); }
  void SetOrigin(double ox, double oy, double oz);
  vtkGetVector3Macro(Origin, double);
 
  void GetTransform(vtkTransform* t) override;
 
 
  void SetProperty(vtkProperty2D*);
  void SetSelectedProperty(vtkProperty2D*);
  void SetTextProperty(vtkTextProperty*);
  vtkGetObjectMacro(Property, vtkProperty2D);
  vtkGetObjectMacro(SelectedProperty, vtkProperty2D);
  vtkGetObjectMacro(TextProperty, vtkTextProperty);
 
 
  vtkSetMacro(DisplayText, vtkTypeBool);
  vtkGetMacro(DisplayText, vtkTypeBool);
  vtkBooleanMacro(DisplayText, vtkTypeBool);
 
 
  void PlaceWidget(double bounds[6]) override;
  void StartWidgetInteraction(double eventPos[2]) override;
  void WidgetInteraction(double eventPos[2]) override;
  void EndWidgetInteraction(double eventPos[2]) override;
  int ComputeInteractionState(int X, int Y, int modify = 0) override;
  void BuildRepresentation() override;
 
 
  void ShallowCopy(vtkProp* prop) override;
  void GetActors2D(vtkPropCollection*) override;
  void ReleaseGraphicsResources(vtkWindow*) override;
  int RenderOverlay(vtkViewport* viewport) override;
 
protected:
  vtkAffineRepresentation2D();
  ~vtkAffineRepresentation2D() override;
 
  // Methods to manipulate the cursor
  void Translate(double eventPos[2]);
  void Scale(double eventPos[2]);
  void Rotate(double eventPos[2]);
  void Shear(double eventPos[2]);
  void Highlight(int highlight) override;
  void UpdateText(const char* text, double eventPos[2]);
 
  // The width of the widget in normalized viewport coordinates.
  int BoxWidth;
  int CircleWidth;
  int AxesWidth;
 
  // Display text
  vtkTypeBool DisplayText;
 
  // Internal variables for bookkeeping (in display coordinates unless noted)
  double CurrentWidth;
  double CurrentRadius;
  double CurrentAxesWidth;
 
  // The internal transformation matrix
  vtkTransform* CurrentTransform;
  vtkTransform* TotalTransform;
  double Origin[4];             // the current origin in world coordinates
  double DisplayOrigin[3];      // the current origin in display coordinates
  double CurrentTranslation[3]; // translation this movement
  double StartWorldPosition[4]; // Start event position converted to world
  double StartAngle;            // The starting angle (always positive)
  double CurrentAngle;
  double CurrentScale[2];
  double CurrentShear[2];
  void ApplyShear(); // helper method to apply shear to matrix
 
  // Properties used to control the appearance of selected objects and
  // the manipulator in general.
  vtkProperty2D* Property;
  vtkProperty2D* SelectedProperty;
  vtkTextProperty* TextProperty;
  void CreateDefaultProperties();
  double Opacity;
  double SelectedOpacity;
 
  // Support picking
  double LastEventPosition[2];
 
  // These are the classes that form the geometric representation -----------
  // The label
  vtkTextMapper* TextMapper;
  vtkActor2D* TextActor;
 
  // The outer box
  vtkPoints* BoxPoints;
  vtkCellArray* BoxCellArray;
  vtkPolyData* Box;
  vtkPolyDataMapper2D* BoxMapper;
  vtkActor2D* BoxActor;
 
  vtkPoints* HBoxPoints;
  vtkCellArray* HBoxCellArray;
  vtkPolyData* HBox;
  vtkPolyDataMapper2D* HBoxMapper;
  vtkActor2D* HBoxActor;
 
  // The circle
  vtkPoints* CirclePoints;
  vtkCellArray* CircleCellArray;
  vtkPolyData* Circle;
  vtkPolyDataMapper2D* CircleMapper;
  vtkActor2D* CircleActor;
 
  vtkPoints* HCirclePoints;
  vtkCellArray* HCircleCellArray;
  vtkPolyData* HCircle;
  vtkPolyDataMapper2D* HCircleMapper;
  vtkActor2D* HCircleActor;
 
  // The translation axes
  vtkLeaderActor2D* XAxis;
  vtkLeaderActor2D* YAxis;
  vtkLeaderActor2D* HXAxis;
  vtkLeaderActor2D* HYAxis;
 
private:
  vtkAffineRepresentation2D(const vtkAffineRepresentation2D&) = delete;
  void operator=(const vtkAffineRepresentation2D&) = delete;
};
 
#endif