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