vtkPolarAxesActor.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkCubeAxesActor.h
  Language:  C++
 
Copyright (c) 1993-2001 Ken Martin, Will Schroeder, Bill Lorensen
All rights reserve
  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 vtkPolarAxesActor_h
#define vtkPolarAxesActor_h
 
#define VTK_MAXIMUM_NUMBER_OF_RADIAL_AXES 50
#define VTK_DEFAULT_NUMBER_OF_RADIAL_AXES 5
#define VTK_MAXIMUM_NUMBER_OF_POLAR_AXIS_TICKS 200
#define VTK_POLAR_ARC_RESOLUTION_PER_DEG 0.2
 
#include "vtkRenderingAnnotationModule.h" // For export macro
#include "vtkActor.h"
 
class vtkAxisActor;
class vtkCamera;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkTextProperty;
 
class VTKRENDERINGANNOTATION_EXPORT vtkPolarAxesActor : public vtkActor
{
public:
  vtkTypeMacro(vtkPolarAxesActor,vtkActor);
  void PrintSelf(ostream& os, vtkIndent indent);
 
  static vtkPolarAxesActor *New();
 
 
  virtual int RenderOpaqueGeometry(vtkViewport*);
  virtual int RenderTranslucentPolygonalGeometry(vtkViewport*) {return 0;};
 
 
  virtual void SetPole( double[3] );
  virtual void SetPole( double, double, double );
  vtkGetVector3Macro( Pole, double );
 
 
  virtual void SetNumberOfRadialAxes( vtkIdType );
  vtkGetMacro( NumberOfRadialAxes, vtkIdType );
 
 
  vtkSetClampMacro( NumberOfPolarAxisTicks, vtkIdType, 0, VTK_MAXIMUM_NUMBER_OF_POLAR_AXIS_TICKS );
  vtkGetMacro( NumberOfPolarAxisTicks, vtkIdType );
 
 
  vtkSetMacro( AutoSubdividePolarAxis, bool );
  vtkGetMacro( AutoSubdividePolarAxis, bool );
  vtkBooleanMacro( AutoSubdividePolarAxis, bool );
 
 
  virtual void SetMaximumRadius( double );
  vtkGetMacro( MaximumRadius, double );
 
 
  vtkSetMacro( AutoScaleRadius,bool );
  vtkGetMacro( AutoScaleRadius,bool );
 
 
  virtual void SetMinimumAngle( double );
  vtkGetMacro( MinimumAngle, double );
 
 
  virtual void SetMaximumAngle( double );
  vtkGetMacro( MaximumAngle, double );
 
 
  vtkSetClampMacro( SmallestVisiblePolarAngle, double, 0., 5. );
  vtkGetMacro( SmallestVisiblePolarAngle, double );
 
 
  vtkSetMacro( RadialUnits, bool );
  vtkGetMacro( RadialUnits, bool );
 
 
  void SetScreenSize( double screenSize );
  vtkGetMacro( ScreenSize, double );
 
 
  virtual void SetCamera(vtkCamera*);
  vtkGetObjectMacro( Camera,vtkCamera );
 
 
  vtkSetStringMacro( PolarAxisTitle );
  vtkGetStringMacro( PolarAxisTitle );
 
 
  vtkSetStringMacro( PolarLabelFormat );
  vtkGetStringMacro( PolarLabelFormat );
 
  void ReleaseGraphicsResources( vtkWindow* );
 
 
  vtkSetMacro( EnableDistanceLOD, int );
  vtkGetMacro( EnableDistanceLOD, int );
 
 
  vtkSetClampMacro( DistanceLODThreshold, double, 0.0, 1.0 );
  vtkGetMacro( DistanceLODThreshold, double);
 
 
  vtkSetMacro( EnableViewAngleLOD, int );
  vtkGetMacro( EnableViewAngleLOD, int );
 
 
  vtkSetClampMacro( ViewAngleLODThreshold, double, 0., 1. );
  vtkGetMacro( ViewAngleLODThreshold, double );
 
 
  vtkSetMacro( PolarAxisVisibility, int );
  vtkGetMacro( PolarAxisVisibility, int );
  vtkBooleanMacro( PolarAxisVisibility, int );
 
 
  vtkSetMacro( PolarTitleVisibility, int );
  vtkGetMacro( PolarTitleVisibility, int );
  vtkBooleanMacro( PolarTitleVisibility, int );
 
 
  vtkSetMacro( PolarLabelVisibility, int );
  vtkGetMacro( PolarLabelVisibility, int );
  vtkBooleanMacro( PolarLabelVisibility, int );
 
 
  vtkSetMacro( PolarTickVisibility, int );
  vtkGetMacro( PolarTickVisibility, int );
  vtkBooleanMacro( PolarTickVisibility, int );
 
 
  vtkSetMacro( RadialAxesVisibility, int );
  vtkGetMacro( RadialAxesVisibility, int );
  vtkBooleanMacro( RadialAxesVisibility, int );
 
 
  vtkSetMacro( RadialTitleVisibility, int );
  vtkGetMacro( RadialTitleVisibility, int );
  vtkBooleanMacro( RadialTitleVisibility, int );
 
 
  vtkSetMacro( PolarArcsVisibility, int );
  vtkGetMacro( PolarArcsVisibility, int );
  vtkBooleanMacro( PolarArcsVisibility, int );
 
 
  virtual void SetPolarAxisTitleTextProperty(vtkTextProperty *p);
  vtkGetObjectMacro(PolarAxisTitleTextProperty,vtkTextProperty);
 
 
  virtual void SetPolarAxisLabelTextProperty(vtkTextProperty *p);
  vtkGetObjectMacro(PolarAxisLabelTextProperty,vtkTextProperty);
 
 
  virtual void SetPolarAxisProperty(vtkProperty *);
  vtkProperty* GetPolarAxisProperty();
 
 
  virtual void SetRadialAxesProperty(vtkProperty *);
  vtkProperty* GetRadialAxesProperty();
 
 
  virtual void SetPolarArcsProperty(vtkProperty *);
  vtkProperty* GetPolarArcsProperty();
 
 
  vtkSetVector6Macro(Bounds,double);
  double *GetBounds();
  void GetBounds(double& xmin, double& xmax, double& ymin, double& ymax,
                 double& zmin, double& zmax);
  void GetBounds(double bounds[6]);
 
protected:
  vtkPolarAxesActor();
  ~vtkPolarAxesActor();
 
  void BuildAxes( vtkViewport * );
 
  void CalculateBounds();
 
  void SetCommonAxisAttributes( vtkAxisActor* );
 
  void CreateRadialAxes();
 
  void BuildRadialAxes();
 
  void BuildPolarAxisTicks( double );
 
  void BuildPolarAxisLabelsArcs();
 
 
  double FFix(double );
  double FSign(double, double );
 
  void AutoScale( vtkViewport* viewport );
 
  double Pole[3];
 
  int NumberOfRadialAxes;
 
  int NumberOfPolarAxisTicks;
 
  bool AutoSubdividePolarAxis;
 
  double MaximumRadius;
 
  bool AutoScaleRadius;
 
  double MinimumAngle;
 
  double MaximumAngle;
 
  double SmallestVisiblePolarAngle;
 
  double Bounds[6];
 
 
  vtkPolyData        *PolarArcs;
  vtkPolyDataMapper  *PolarArcsMapper;
  vtkActor           *PolarArcsActor;
 
  vtkCamera *Camera;
 
  vtkAxisActor* PolarAxis;
 
  vtkAxisActor** RadialAxes;
 
 
  char *PolarAxisTitle;
  char  *PolarLabelFormat;
 
  bool RadialUnits;
 
  int EnableDistanceLOD;
 
  double DistanceLODThreshold;
 
  int EnableViewAngleLOD;
 
  double ViewAngleLODThreshold;
 
 
  int PolarAxisVisibility;
  int PolarTitleVisibility;
  int PolarLabelVisibility;
  int PolarTickVisibility;
 
 
  int RadialAxesVisibility;
  int RadialTitleVisibility;
 
  int PolarArcsVisibility;
 
  int   RenderCount;
 
  int RenderSomething;
 
 
  vtkTextProperty   *PolarAxisTitleTextProperty;
  vtkTextProperty   *PolarAxisLabelTextProperty;
 
  vtkProperty* PolarAxisProperty;
 
  vtkProperty* RadialAxesProperty;
 
  vtkTimeStamp BuildTime;
 
  double TitleScale;
 
  double LabelScale;
 
  double LabelScreenOffset;
 
  double ScreenSize;
 
private:
  vtkPolarAxesActor( const vtkPolarAxesActor& ); // Not implemented
  void operator=( const vtkPolarAxesActor& ); // Not implemented
};
 
 
#endif