9.1/html/vtkScalarBarActor_8h_source.html

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


  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 "vtkActor2D.h"

#include "vtkDoubleArray.h"               // for ivars

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


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


  static vtkScalarBarActor* New();


  int RenderOpaqueGeometry(vtkViewport* viewport) override;

  int RenderTranslucentPolygonalGeometry(vtkViewport*) override { return 0; }

  int RenderOverlay(vtkViewport* viewport) override;


  vtkTypeBool HasTranslucentPolygonalGeometry() override;


  void ReleaseGraphicsResources(vtkWindow*) override;


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


  virtual void SetLookupTable(vtkScalarsToColors*);

  vtkGetObjectMacro(LookupTable, vtkScalarsToColors);


  vtkSetMacro(UseOpacity, vtkTypeBool);

  vtkGetMacro(UseOpacity, vtkTypeBool);

  vtkBooleanMacro(UseOpacity, vtkTypeBool);


  vtkSetClampMacro(MaximumNumberOfColors, int, 2, VTK_INT_MAX);

  vtkGetMacro(MaximumNumberOfColors, int);


  vtkSetClampMacro(NumberOfLabels, int, 0, 64);

  vtkGetMacro(NumberOfLabels, int);


  virtual void SetCustomLabels(vtkDoubleArray* labels);

  vtkGetObjectMacro(CustomLabels, vtkDoubleArray);


  vtkGetMacro(UseCustomLabels, bool);

  vtkSetMacro(UseCustomLabels, bool);

  vtkBooleanMacro(UseCustomLabels, bool);


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

  vtkGetMacro(DrawAnnotations, vtkTypeBool);

  vtkBooleanMacro(DrawAnnotations, vtkTypeBool);


  vtkSetMacro(DrawNanAnnotation, vtkTypeBool);

  vtkGetMacro(DrawNanAnnotation, vtkTypeBool);

  vtkBooleanMacro(DrawNanAnnotation, vtkTypeBool);


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

  vtkGetMacro(FixedAnnotationLeaderLineColor, vtkTypeBool);

  vtkBooleanMacro(FixedAnnotationLeaderLineColor, vtkTypeBool);


  vtkSetStringMacro(NanAnnotation);

  vtkGetStringMacro(NanAnnotation);


  vtkSetMacro(AnnotationTextScaling, vtkTypeBool);

  vtkGetMacro(AnnotationTextScaling, vtkTypeBool);

  vtkBooleanMacro(AnnotationTextScaling, vtkTypeBool);


  vtkSetMacro(DrawBackground, vtkTypeBool);

  vtkGetMacro(DrawBackground, vtkTypeBool);

  vtkBooleanMacro(DrawBackground, vtkTypeBool);


  vtkSetMacro(DrawFrame, vtkTypeBool);

  vtkGetMacro(DrawFrame, vtkTypeBool);

  vtkBooleanMacro(DrawFrame, vtkTypeBool);


  vtkSetMacro(DrawColorBar, vtkTypeBool);

  vtkGetMacro(DrawColorBar, vtkTypeBool);

  vtkBooleanMacro(DrawColorBar, vtkTypeBool);


  vtkSetMacro(DrawTickLabels, vtkTypeBool);

  vtkGetMacro(DrawTickLabels, vtkTypeBool);

  vtkBooleanMacro(DrawTickLabels, vtkTypeBool);


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


  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;

  vtkDoubleArray* CustomLabels = nullptr;

  bool UseCustomLabels = false;

  vtkTypeBool DrawBackground; // off by default

  vtkTypeBool DrawFrame;      // off by default

  vtkTypeBool DrawColorBar;   // on by default

  vtkTypeBool DrawTickLabels; // on by default

  vtkTypeBool DrawAnnotations;

  vtkTypeBool DrawNanAnnotation;

  vtkTypeBool AnnotationTextScaling; // off by default

  vtkTypeBool FixedAnnotationLeaderLineColor;

  vtkProperty2D* BackgroundProperty;

  vtkProperty2D* FrameProperty;

  char* Title;

  char* ComponentTitle;

  char* LabelFormat;

  vtkTypeBool 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&) = delete;

  void operator=(const vtkScalarBarActor&) = delete;

};


#endif