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;
class vtkTexturedActor2D;

#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) VTK_OVERRIDE;

  static vtkScalarBarActor* New();


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

  virtual int HasTranslucentPolygonalGeometry() VTK_OVERRIDE;

  virtual void ReleaseGraphicsResources(vtkWindow*) VTK_OVERRIDE;

  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);


  virtual void SetAnnotationTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(AnnotationTextProperty, vtkTextProperty);


  vtkSetStringMacro(LabelFormat);
  vtkGetStringMacro(LabelFormat);


  vtkSetStringMacro(Title);
  vtkGetStringMacro(Title);


  vtkSetStringMacro(ComponentTitle);
  vtkGetStringMacro(ComponentTitle);

  void ShallowCopy(vtkProp* prop) VTK_OVERRIDE;


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


  vtkGetObjectMacro(TextureActor, vtkTexturedActor2D);

  enum { PrecedeScalarBar = 0, SucceedScalarBar };


  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(DrawBelowRangeSwatch, bool);
  vtkGetMacro(DrawBelowRangeSwatch, bool);
  vtkBooleanMacro(DrawBelowRangeSwatch, bool);


  vtkSetStringMacro(BelowRangeAnnotation);
  vtkGetStringMacro(BelowRangeAnnotation);


  vtkSetMacro(DrawAboveRangeSwatch, bool);
  vtkGetMacro(DrawAboveRangeSwatch, bool);
  vtkBooleanMacro(DrawAboveRangeSwatch, bool);


  vtkSetStringMacro(AboveRangeAnnotation);
  vtkGetStringMacro(AboveRangeAnnotation);


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


  vtkSetStringMacro(NanAnnotation);
  vtkGetStringMacro(NanAnnotation);


  vtkSetMacro(AnnotationTextScaling, int);
  vtkGetMacro(AnnotationTextScaling, int);
  vtkBooleanMacro(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.);


  vtkSetMacro(UnconstrainedFontSize, bool);
  vtkGetMacro(UnconstrainedFontSize, bool);
  vtkBooleanMacro(UnconstrainedFontSize, bool);

protected:
  vtkScalarBarActor();
  ~vtkScalarBarActor();

  virtual void RebuildLayout(vtkViewport* viewport);

  virtual int RebuildLayoutIfNeeded(vtkViewport* viewport);


  virtual void FreeLayoutStorage();

  virtual void ComputeFrame();

  virtual void ComputeScalarBarThickness();

  virtual void ComputeSwatchPad();

  // This method must set this->P->NanSwatchSize and this->P->NanBox.
  // It may depend on layout performed by ComputeScalarBarThickness.
  virtual void LayoutNanSwatch();

  virtual void LayoutBelowRangeSwatch();

  virtual void LayoutAboveRangeSwatch();

  virtual void LayoutAboveRangeSwatchPosn();

  virtual void PrepareTitleText();

  virtual void LayoutTitle();

  virtual void LayoutForUnconstrainedFont();

  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 ConfigureAboveBelowRangeSwatch(bool above);

  virtual void EditAnnotations() { }

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

  int MapAnnotationLabels(
    vtkScalarsToColors* lkup, double start, double delta, const 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;
  char* BelowRangeAnnotation;
  char* AboveRangeAnnotation;
  double AnnotationLeaderPadding;
  int MaximumWidthInPixels;
  int MaximumHeightInPixels;
  int TextPad;
  int VerticalTitleSeparation;
  double BarRatio;
  double TitleRatio;
  bool UnconstrainedFontSize;  // off by default

  bool DrawBelowRangeSwatch;
  bool DrawAboveRangeSwatch;


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

  vtkScalarBarActorInternal* P; 

  vtkScalarsToColors* LookupTable; 

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

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

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

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


private:
  vtkScalarBarActor(const vtkScalarBarActor&) VTK_DELETE_FUNCTION;
  void operator=(const vtkScalarBarActor&) VTK_DELETE_FUNCTION;
};

#endif