dox/Rendering/Annotation/vtkScalarBarActor.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    vtkScalarBarActor.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 __vtkScalarBarActor_h
#define __vtkScalarBarActor_h

#include "vtkRenderingAnnotationModule.h" // For export macro
#include "vtkActor2D.h"

class vtkColor3ub;
class vtkPolyData;
class vtkPolyDataMapper2D;
class vtkProperty2D;
class vtkScalarsToColors;
class vtkScalarBarActorInternal;
class vtkTextActor;
class vtkTextMapper;
class vtkTextProperty;
class vtkTexture;

#define VTK_ORIENT_HORIZONTAL 0
#define VTK_ORIENT_VERTICAL 1

class VTKRENDERINGANNOTATION_EXPORT vtkScalarBarActor : public vtkActor2D
{
public:
  vtkTypeMacro(vtkScalarBarActor,vtkActor2D);
  void PrintSelf(ostream& os, vtkIndent indent);

  static vtkScalarBarActor* New();


  int RenderOpaqueGeometry(vtkViewport* viewport);
  virtual int RenderTranslucentPolygonalGeometry(vtkViewport*) { return 0; };
  int RenderOverlay(vtkViewport* viewport);

  virtual int HasTranslucentPolygonalGeometry();

  virtual void ReleaseGraphicsResources(vtkWindow*);

  virtual void GetScalarBarRect(int rect[4], vtkViewport* viewport);


  virtual void SetLookupTable(vtkScalarsToColors*);
  vtkGetObjectMacro(LookupTable,vtkScalarsToColors);


  vtkSetMacro( UseOpacity, int );
  vtkGetMacro( UseOpacity, int );
  vtkBooleanMacro( UseOpacity, int );


  vtkSetClampMacro(MaximumNumberOfColors, int, 2, VTK_INT_MAX);
  vtkGetMacro(MaximumNumberOfColors, int);


  vtkSetClampMacro(NumberOfLabels, int, 0, 64);
  vtkGetMacro(NumberOfLabels, int);


  vtkSetClampMacro(Orientation,int,VTK_ORIENT_HORIZONTAL, VTK_ORIENT_VERTICAL);
  vtkGetMacro(Orientation, int);
  void SetOrientationToHorizontal()
       {this->SetOrientation(VTK_ORIENT_HORIZONTAL);}
  void SetOrientationToVertical() {this->SetOrientation(VTK_ORIENT_VERTICAL);}


  virtual void SetTitleTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(TitleTextProperty,vtkTextProperty);


  virtual void SetLabelTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(LabelTextProperty,vtkTextProperty);


  vtkSetStringMacro(LabelFormat);
  vtkGetStringMacro(LabelFormat);


  vtkSetStringMacro(Title);
  vtkGetStringMacro(Title);


  vtkSetStringMacro(ComponentTitle);
  vtkGetStringMacro(ComponentTitle);

  void ShallowCopy(vtkProp* prop);


  vtkSetMacro( TextureGridWidth, double );
  vtkGetMacro( TextureGridWidth, double );


  vtkGetObjectMacro( TextureActor, vtkActor2D );

//BTX
  enum { PrecedeScalarBar = 0, SucceedScalarBar };
//ETX


  vtkSetClampMacro( TextPosition, int, PrecedeScalarBar, SucceedScalarBar);
  vtkGetMacro( TextPosition, int );
  virtual void SetTextPositionToPrecedeScalarBar()
    { this->SetTextPosition( vtkScalarBarActor::PrecedeScalarBar ); }
  virtual void SetTextPositionToSucceedScalarBar()
    { this->SetTextPosition( vtkScalarBarActor::SucceedScalarBar ); }


  vtkSetMacro( MaximumWidthInPixels, int );
  vtkGetMacro( MaximumWidthInPixels, int );
  vtkSetMacro( MaximumHeightInPixels, int );
  vtkGetMacro( MaximumHeightInPixels, int );


  vtkSetMacro(AnnotationLeaderPadding, double);
  vtkGetMacro(AnnotationLeaderPadding, double);


  vtkSetMacro(DrawAnnotations, int);
  vtkGetMacro(DrawAnnotations, int);
  vtkBooleanMacro(DrawAnnotations, int);


  vtkSetMacro(DrawNanAnnotation, int);
  vtkGetMacro(DrawNanAnnotation, int);
  vtkBooleanMacro(DrawNanAnnotation, int);


  vtkSetMacro(FixedAnnotationLeaderLineColor, int);
  vtkGetMacro(FixedAnnotationLeaderLineColor, int);
  vtkBooleanMacro(FixedAnnotationLeaderLineColor, int);


  vtkSetStringMacro(NanAnnotation);
  vtkGetStringMacro(NanAnnotation);


  vtkSetMacro(AnnotationTextScaling,int);
  vtkGetMacro(AnnotationTextScaling,int);


  vtkSetMacro(DrawBackground, int);
  vtkGetMacro(DrawBackground, int);
  vtkBooleanMacro(DrawBackground, int);


  vtkSetMacro(DrawFrame, int);
  vtkGetMacro(DrawFrame, int);
  vtkBooleanMacro(DrawFrame, int);


  vtkSetMacro(DrawColorBar, int);
  vtkGetMacro(DrawColorBar, int);
  vtkBooleanMacro(DrawColorBar, int);


  vtkSetMacro(DrawTickLabels, int);
  vtkGetMacro(DrawTickLabels, int);
  vtkBooleanMacro(DrawTickLabels, int);


  virtual void SetBackgroundProperty(vtkProperty2D* p);
  vtkGetObjectMacro(BackgroundProperty,vtkProperty2D);


  virtual void SetFrameProperty(vtkProperty2D* p);
  vtkGetObjectMacro(FrameProperty,vtkProperty2D);


  vtkGetMacro(TextPad,int);
  vtkSetMacro(TextPad,int);


  vtkGetMacro(VerticalTitleSeparation,int);
  vtkSetMacro(VerticalTitleSeparation,int);


  vtkGetMacro(BarRatio,double);
  vtkSetClampMacro(BarRatio,double,0.,1.);


  vtkGetMacro(TitleRatio,double);
  vtkSetClampMacro(TitleRatio,double,0.,1.);

protected:
  vtkScalarBarActor();
  ~vtkScalarBarActor();

  virtual void RebuildLayout(vtkViewport* viewport);

  virtual void FreeLayoutStorage();

  virtual void ComputeFrame();

  virtual void ComputeScalarBarThickness();

  virtual void LayoutNanSwatch();

  virtual void PrepareTitleText();

  virtual void LayoutTitle();

  virtual void ComputeScalarBarLength();

  virtual void LayoutTicks();

  virtual void LayoutAnnotations();

  virtual void ConfigureAnnotations();

  virtual void ConfigureFrame();

  virtual void DrawBoxes();

  virtual void ConfigureScalarBar();

  virtual void ConfigureTitle();

  virtual void ConfigureTicks();

  virtual void ConfigureNanSwatch();

  virtual void EditAnnotations() { }

  virtual void SizeTitle(double* titleSize, int* size, vtkViewport* viewport);


  int MapAnnotationLabels(
    vtkScalarsToColors* lkup, double start, double delta, double* range);


  int PlaceAnnotationsVertically(
    double barX, double barY, double barWidth, double barHeight,
    double delta, double pad);


  int PlaceAnnotationsHorizontally(
    double barX, double barY, double barWidth, double barHeight,
    double delta, double pad);


  int MaximumNumberOfColors;
  int NumberOfLabels;
  int NumberOfLabelsBuilt;
  int Orientation;
  int DrawBackground; // off by default
  int DrawFrame; // off by default
  int DrawColorBar; // on by default
  int DrawTickLabels; // on by default
  int DrawAnnotations;
  int DrawNanAnnotation;
  int AnnotationTextScaling; // off by default
  int FixedAnnotationLeaderLineColor;
  vtkProperty2D* BackgroundProperty;
  vtkProperty2D* FrameProperty;
  char* Title;
  char* ComponentTitle;
  char* LabelFormat;
  int UseOpacity; // off by default
  double TextureGridWidth;
  int TextPosition;
  char* NanAnnotation;
  double AnnotationLeaderPadding;
  int MaximumWidthInPixels;
  int MaximumHeightInPixels;
  int TextPad;
  int VerticalTitleSeparation;
  double BarRatio;
  double TitleRatio;


  vtkTimeStamp BuildTime; 
  int LastSize[2]; 
  int LastOrigin[2]; 

  vtkScalarBarActorInternal* P; 

  vtkScalarsToColors* LookupTable; 

  vtkTextProperty* TitleTextProperty; 
  vtkTextProperty* LabelTextProperty; 
  vtkTextActor* TitleActor; 

  vtkPolyData* ScalarBar; 
  vtkPolyDataMapper2D* ScalarBarMapper; 
  vtkActor2D* ScalarBarActor; 
  vtkPolyData* TexturePolyData; 
  vtkTexture* Texture; 
  vtkActor2D* TextureActor; 

  vtkPolyData* Background; 
  vtkPolyDataMapper2D* BackgroundMapper; 
  vtkActor2D* BackgroundActor; 

  vtkPolyData* Frame; 
  vtkPolyDataMapper2D* FrameMapper; 
  vtkActor2D* FrameActor; 


private:
  vtkScalarBarActor(const vtkScalarBarActor&);  // Not implemented.
  void operator=(const vtkScalarBarActor&);  // Not implemented.
};


#endif