9.1/html/vtkXYPlotActor_8h_source.html

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


  Program:   Visualization Toolkit

  Module:    vtkXYPlotActor.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 vtkXYPlotActor_h

#define vtkXYPlotActor_h


#define VTK_XYPLOT_INDEX 0

#define VTK_XYPLOT_ARC_LENGTH 1

#define VTK_XYPLOT_NORMALIZED_ARC_LENGTH 2

#define VTK_XYPLOT_VALUE 3


#define VTK_XYPLOT_ROW 0

#define VTK_XYPLOT_COLUMN 1


#define VTK_XYPLOT_Y_AXIS_TOP 0

#define VTK_XYPLOT_Y_AXIS_HCENTER 1

#define VTK_XYPLOT_Y_AXIS_VCENTER 2 // rotate by 90 degrees (y-axis aligned)


#include "vtkActor2D.h"

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

#include "vtkSmartPointer.h"              // For SP


class vtkXYPlotActorConnections;

class vtkAlgorithmOutput;

class vtkAppendPolyData;

class vtkAxisActor2D;

class vtkDataObject;

class vtkDataObjectCollection;

class vtkDataSet;

class vtkDataSetCollection;

class vtkDoubleArray;

class vtkGlyph2D;

class vtkGlyphSource2D;

class vtkIntArray;

class vtkLegendBoxActor;

class vtkPlanes;

class vtkPolyData;

class vtkPolyDataMapper2D;

class vtkTextActor;

class vtkTextMapper;

class vtkTextProperty;


class VTKRENDERINGANNOTATION_EXPORT vtkXYPlotActor : public vtkActor2D

{

public:

  vtkTypeMacro(vtkXYPlotActor, vtkActor2D);

  void PrintSelf(ostream& os, vtkIndent indent) override;


  static vtkXYPlotActor* New();


  //---Data Set Input----------------------------------------------------------

  // The following methods are used to plot input datasets. Datasets

  // will be plotted if set as input; otherwise the input data objects

  // will be plotted (if defined).


  void AddDataSetInput(vtkDataSet* ds, const char* arrayName, int component);

  void AddDataSetInput(vtkDataSet* ds) { this->AddDataSetInput(ds, nullptr, 0); }

  void AddDataSetInputConnection(vtkAlgorithmOutput* in, const char* arrayName, int component);

  void AddDataSetInputConnection(vtkAlgorithmOutput* in)

  {

    this->AddDataSetInputConnection(in, nullptr, 0);

  }


  void RemoveDataSetInput(vtkDataSet* ds, const char* arrayName, int component);

  void RemoveDataSetInput(vtkDataSet* ds) { this->RemoveDataSetInput(ds, nullptr, 0); }

  void RemoveDataSetInputConnection(vtkAlgorithmOutput* in, const char* arrayName, int component);

  void RemoveDataSetInputConnection(vtkAlgorithmOutput* in)

  {

    this->RemoveDataSetInputConnection(in, nullptr, 0);

  }


  void RemoveAllDataSetInputConnections();


  void SetPointComponent(int i, int comp);

  int GetPointComponent(int i);

  //---end Data Set Input-----------------------------------------------------


  vtkSetClampMacro(XValues, int, VTK_XYPLOT_INDEX, VTK_XYPLOT_VALUE);

  vtkGetMacro(XValues, int);

  void SetXValuesToIndex() { this->SetXValues(VTK_XYPLOT_INDEX); }

  void SetXValuesToArcLength() { this->SetXValues(VTK_XYPLOT_ARC_LENGTH); }

  void SetXValuesToNormalizedArcLength() { this->SetXValues(VTK_XYPLOT_NORMALIZED_ARC_LENGTH); }

  void SetXValuesToValue() { this->SetXValues(VTK_XYPLOT_VALUE); }

  const char* GetXValuesAsString();


  //---Data Object Input------------------------------------------------------

  // The following methods are used to plot input data objects. Datasets will

  // be plotted in preference to data objects if set as input; otherwise the

  // input data objects will be plotted (if defined).


  void AddDataObjectInput(vtkDataObject* in);

  void AddDataObjectInputConnection(vtkAlgorithmOutput* alg);


  void RemoveDataObjectInputConnection(vtkAlgorithmOutput* aout);

  void RemoveDataObjectInput(vtkDataObject* in);


  vtkSetClampMacro(DataObjectPlotMode, int, VTK_XYPLOT_ROW, VTK_XYPLOT_COLUMN);

  vtkGetMacro(DataObjectPlotMode, int);

  void SetDataObjectPlotModeToRows() { this->SetDataObjectPlotMode(VTK_XYPLOT_ROW); }

  void SetDataObjectPlotModeToColumns() { this->SetDataObjectPlotMode(VTK_XYPLOT_COLUMN); }

  const char* GetDataObjectPlotModeAsString();


  void SetDataObjectXComponent(int i, int comp);

  int GetDataObjectXComponent(int i);


  void SetDataObjectYComponent(int i, int comp);

  int GetDataObjectYComponent(int i);

  //---end Data Object Input--------------------------------------------------


  //---Per Curve Properties---------------------------------------------------

  // The following methods are used to set properties on each curve that is

  // plotted. Each input dataset (or data object) results in one curve. The

  // methods that follow have an index i that corresponds to the input dataset

  // or data object.

  void SetPlotColor(int i, double r, double g, double b);

  void SetPlotColor(int i, const double color[3])

  {

    this->SetPlotColor(i, color[0], color[1], color[2]);

  }

  double* GetPlotColor(int i) VTK_SIZEHINT(3);

  void SetPlotSymbol(int i, vtkPolyData* input);

  vtkPolyData* GetPlotSymbol(int i);

  void SetPlotLabel(int i, const char* label);

  const char* GetPlotLabel(int i);


  // Allow per-curve specification of line and point rendering.  These override

  // global settings PlotPoints and PlotLines.  If not on, the default behavior

  // is governed by PlotPoints and PlotLines ivars.

  vtkGetMacro(PlotCurvePoints, vtkTypeBool);

  vtkSetMacro(PlotCurvePoints, vtkTypeBool);

  vtkBooleanMacro(PlotCurvePoints, vtkTypeBool);


  vtkGetMacro(PlotCurveLines, vtkTypeBool);

  vtkSetMacro(PlotCurveLines, vtkTypeBool);

  vtkBooleanMacro(PlotCurveLines, vtkTypeBool);


  void SetPlotLines(int i, int);

  int GetPlotLines(int i);


  void SetPlotPoints(int i, int);

  int GetPlotPoints(int i);

  //---end Per Curve Properties-----------------------------------------------


  vtkSetMacro(ExchangeAxes, vtkTypeBool);

  vtkGetMacro(ExchangeAxes, vtkTypeBool);

  vtkBooleanMacro(ExchangeAxes, vtkTypeBool);


  vtkSetMacro(ReverseXAxis, vtkTypeBool);

  vtkGetMacro(ReverseXAxis, vtkTypeBool);

  vtkBooleanMacro(ReverseXAxis, vtkTypeBool);


  vtkSetMacro(ReverseYAxis, vtkTypeBool);

  vtkGetMacro(ReverseYAxis, vtkTypeBool);

  vtkBooleanMacro(ReverseYAxis, vtkTypeBool);


  vtkGetObjectMacro(LegendActor, vtkLegendBoxActor);

  vtkGetObjectMacro(GlyphSource, vtkGlyphSource2D);


  vtkSetStringMacro(Title);

  vtkGetStringMacro(Title);


  vtkSetStringMacro(XTitle);

  vtkGetStringMacro(XTitle);


  virtual void SetYTitle(const char*);

  char* GetYTitle();


  vtkAxisActor2D* GetXAxisActor2D() { return this->XAxis; }

  vtkAxisActor2D* GetYAxisActor2D() { return this->YAxis; }


  vtkSetVector2Macro(XRange, double);

  vtkGetVectorMacro(XRange, double, 2);

  vtkSetVector2Macro(YRange, double);

  vtkGetVectorMacro(YRange, double, 2);

  void SetPlotRange(double xmin, double ymin, double xmax, double ymax)

  {

    this->SetXRange(xmin, xmax);

    this->SetYRange(ymin, ymax);

  }


  vtkSetClampMacro(NumberOfXLabels, int, 0, 50);

  vtkGetMacro(NumberOfXLabels, int);

  vtkSetClampMacro(NumberOfYLabels, int, 0, 50);

  vtkGetMacro(NumberOfYLabels, int);

  void SetNumberOfLabels(int num)

  {

    this->SetNumberOfXLabels(num);

    this->SetNumberOfYLabels(num);

  }


  void SetAdjustXLabels(int adjust);

  vtkGetMacro(AdjustXLabels, int);

  void SetAdjustYLabels(int adjust);

  vtkGetMacro(AdjustYLabels, int);


  void SetNumberOfXMinorTicks(int num);

  int GetNumberOfXMinorTicks();

  void SetNumberOfYMinorTicks(int num);

  int GetNumberOfYMinorTicks();


  vtkSetMacro(Legend, vtkTypeBool);

  vtkGetMacro(Legend, vtkTypeBool);

  vtkBooleanMacro(Legend, vtkTypeBool);


  vtkSetVector2Macro(TitlePosition, double);

  vtkGetVector2Macro(TitlePosition, double);


  vtkSetMacro(AdjustTitlePosition, vtkTypeBool);

  vtkGetMacro(AdjustTitlePosition, vtkTypeBool);

  vtkBooleanMacro(AdjustTitlePosition, vtkTypeBool);


  enum Alignment

  {

    AlignLeft = 0x1,

    AlignRight = 0x2,

    AlignHCenter = 0x4,

    AlignTop = 0x10,

    AlignBottom = 0x20,

    AlignVCenter = 0x40,

    AlignAxisLeft = 0x100,

    AlignAxisRight = 0x200,

    AlignAxisHCenter = 0x400,

    AlignAxisTop = 0x1000,

    AlignAxisBottom = 0x2000,

    AlignAxisVCenter = 0x4000

  };


  vtkSetMacro(AdjustTitlePositionMode, int);

  vtkGetMacro(AdjustTitlePositionMode, int);


  vtkSetVector2Macro(LegendPosition, double);

  vtkGetVector2Macro(LegendPosition, double);

  vtkSetVector2Macro(LegendPosition2, double);

  vtkGetVector2Macro(LegendPosition2, double);


  virtual void SetTitleTextProperty(vtkTextProperty* p);

  vtkGetObjectMacro(TitleTextProperty, vtkTextProperty);


  virtual void SetAxisTitleTextProperty(vtkTextProperty* p);

  vtkGetObjectMacro(AxisTitleTextProperty, vtkTextProperty);


  virtual void SetAxisLabelTextProperty(vtkTextProperty* p);

  vtkGetObjectMacro(AxisLabelTextProperty, vtkTextProperty);


  vtkSetMacro(Logx, vtkTypeBool);

  vtkGetMacro(Logx, vtkTypeBool);

  vtkBooleanMacro(Logx, vtkTypeBool);


  virtual void SetLabelFormat(const char*);

  const char* GetLabelFormat() { return this->GetXLabelFormat(); }


  virtual void SetXLabelFormat(const char*);

  vtkGetStringMacro(XLabelFormat);


  virtual void SetYLabelFormat(const char*);

  vtkGetStringMacro(YLabelFormat);


  vtkSetClampMacro(Border, int, 0, 50);

  vtkGetMacro(Border, int);


  vtkGetMacro(PlotPoints, vtkTypeBool);

  vtkSetMacro(PlotPoints, vtkTypeBool);

  vtkBooleanMacro(PlotPoints, vtkTypeBool);


  vtkGetMacro(PlotLines, vtkTypeBool);

  vtkSetMacro(PlotLines, vtkTypeBool);

  vtkBooleanMacro(PlotLines, vtkTypeBool);


  vtkSetClampMacro(GlyphSize, double, 0.0, 0.2);

  vtkGetMacro(GlyphSize, double);


  void ViewportToPlotCoordinate(vtkViewport* viewport, double& u, double& v);


  void ViewportToPlotCoordinate(vtkViewport* viewport);

  vtkSetVector2Macro(PlotCoordinate, double);

  vtkGetVector2Macro(PlotCoordinate, double);


  void PlotToViewportCoordinate(vtkViewport* viewport, double& u, double& v);


  void PlotToViewportCoordinate(vtkViewport* viewport);

  vtkSetVector2Macro(ViewportCoordinate, double);

  vtkGetVector2Macro(ViewportCoordinate, double);


  int IsInPlot(vtkViewport* viewport, double u, double v);


  vtkSetMacro(ChartBox, vtkTypeBool);

  vtkGetMacro(ChartBox, vtkTypeBool);

  vtkBooleanMacro(ChartBox, vtkTypeBool);


  vtkSetMacro(ChartBorder, vtkTypeBool);

  vtkGetMacro(ChartBorder, vtkTypeBool);

  vtkBooleanMacro(ChartBorder, vtkTypeBool);


  vtkProperty2D* GetChartBoxProperty() { return this->ChartBoxActor->GetProperty(); }


  vtkSetMacro(ShowReferenceXLine, vtkTypeBool);

  vtkGetMacro(ShowReferenceXLine, vtkTypeBool);

  vtkBooleanMacro(ShowReferenceXLine, vtkTypeBool);


  vtkSetMacro(ReferenceXValue, double);

  vtkGetMacro(ReferenceXValue, double);


  vtkSetMacro(ShowReferenceYLine, vtkTypeBool);

  vtkGetMacro(ShowReferenceYLine, vtkTypeBool);

  vtkBooleanMacro(ShowReferenceYLine, vtkTypeBool);


  vtkSetMacro(ReferenceYValue, double);

  vtkGetMacro(ReferenceYValue, double);


  vtkMTimeType GetMTime() override;


  void PrintAsCSV(ostream& os);


  int RenderOpaqueGeometry(vtkViewport*) override;

  int RenderOverlay(vtkViewport*) override;

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


  vtkTypeBool HasTranslucentPolygonalGeometry() override;


  void ReleaseGraphicsResources(vtkWindow*) override;


  void SetXTitlePosition(double position);

  double GetXTitlePosition();


  vtkSetMacro(YTitlePosition, int);

  vtkGetMacro(YTitlePosition, int);

  void SetYTitlePositionToTop() { this->SetYTitlePosition(VTK_XYPLOT_Y_AXIS_TOP); }

  void SetYTitlePositionToHCenter() { this->SetYTitlePosition(VTK_XYPLOT_Y_AXIS_HCENTER); }

  void SetYTitlePositionToVCenter() { this->SetYTitlePosition(VTK_XYPLOT_Y_AXIS_VCENTER); }


  virtual void SetPlotGlyphType(int, int);

  virtual void SetLineWidth(double);

  virtual void AddUserCurvesPoint(double, double, double);

  virtual void RemoveAllActiveCurves();


  virtual void SetLegendBorder(int);

  virtual void SetLegendBox(int);

  virtual void SetLegendUseBackground(int);

  virtual void SetLegendBackgroundColor(double, double, double);


  virtual void SetTitleColor(double, double, double);

  virtual void SetTitleFontFamily(int);

  virtual void SetTitleBold(int);

  virtual void SetTitleItalic(int);

  virtual void SetTitleShadow(int);

  virtual void SetTitleFontSize(int);

  virtual void SetTitleJustification(int);

  virtual void SetTitleVerticalJustification(int);


  virtual void SetXAxisColor(double, double, double);

  virtual void SetYAxisColor(double, double, double);


  virtual void SetAxisTitleColor(double, double, double);

  virtual void SetAxisTitleFontFamily(int);

  virtual void SetAxisTitleBold(int);

  virtual void SetAxisTitleItalic(int);

  virtual void SetAxisTitleShadow(int);

  virtual void SetAxisTitleFontSize(int);

  virtual void SetAxisTitleJustification(int);

  virtual void SetAxisTitleVerticalJustification(int);


  virtual void SetAxisLabelColor(double, double, double);

  virtual void SetAxisLabelFontFamily(int);

  virtual void SetAxisLabelBold(int);

  virtual void SetAxisLabelItalic(int);

  virtual void SetAxisLabelShadow(int);

  virtual void SetAxisLabelFontSize(int);

  virtual void SetAxisLabelJustification(int);

  virtual void SetAxisLabelVerticalJustification(int);


protected:

  vtkXYPlotActor();

  ~vtkXYPlotActor() override;


  vtkXYPlotActorConnections* InputConnectionHolder;

  char** SelectedInputScalars;                                // list of data set arrays to plot

  vtkIntArray* SelectedInputScalarsComponent;                 // list of components

  vtkXYPlotActorConnections* DataObjectInputConnectionHolder; // list of data objects to plot

  char* Title;

  char* XTitle;

  vtkTextActor* YTitleActor;

  int XValues;

  int NumberOfXLabels;

  int NumberOfYLabels;

  vtkTypeBool Logx;

  char* XLabelFormat;

  char* YLabelFormat;

  double XRange[2];

  double YRange[2];

  double XComputedRange[2]; // range actually used by plot

  double YComputedRange[2]; // range actually used by plot

  int Border;

  vtkTypeBool PlotLines;

  vtkTypeBool PlotPoints;

  vtkTypeBool PlotCurveLines;

  vtkTypeBool PlotCurvePoints;

  vtkTypeBool ExchangeAxes;

  vtkTypeBool ReverseXAxis;

  vtkTypeBool ReverseYAxis;

  int AdjustXLabels;

  int AdjustYLabels;

  vtkTypeBool AdjustTitlePosition;

  double TitlePosition[2];

  int AdjustTitlePositionMode;


  vtkTextMapper* TitleMapper;

  vtkActor2D* TitleActor;

  vtkTextProperty* TitleTextProperty;


  vtkAxisActor2D* XAxis;

  vtkAxisActor2D* YAxis;


  vtkTextProperty* AxisTitleTextProperty;

  vtkTextProperty* AxisLabelTextProperty;


  double ViewportCoordinate[2];

  double PlotCoordinate[2];


  // Handle data objects and datasets

  int DataObjectPlotMode;

  vtkIntArray* XComponent;

  vtkIntArray* YComponent;

  vtkIntArray* LinesOn;

  vtkIntArray* PointsOn;


  // The data drawn within the axes. Each curve is one polydata.

  // color is controlled by scalar data. The curves are appended

  // together, possibly glyphed with point symbols.

  int NumberOfInputs;

  vtkPolyData** PlotData;

  vtkGlyph2D** PlotGlyph;

  vtkAppendPolyData** PlotAppend;

  vtkPolyDataMapper2D** PlotMapper;

  vtkActor2D** PlotActor;

  void InitializeEntries();


  // Legends and plot symbols. The legend also keeps track of

  // the symbols and such.

  vtkTypeBool Legend;

  double LegendPosition[2];

  double LegendPosition2[2];

  vtkLegendBoxActor* LegendActor;

  vtkGlyphSource2D* GlyphSource;

  vtkPlanes* ClipPlanes;

  double GlyphSize;


  // Background box

  vtkTypeBool ChartBox;

  vtkPolyData* ChartBoxPolyData;

  vtkPolyDataMapper2D* ChartBoxMapper;

  vtkActor2D* ChartBoxActor;

  vtkTypeBool ChartBorder;

  vtkPolyData* ChartBorderPolyData;

  vtkPolyDataMapper2D* ChartBorderMapper;

  vtkActor2D* ChartBorderActor;


  // Reference lines

  vtkTypeBool ShowReferenceXLine;

  vtkTypeBool ShowReferenceYLine;

  double ReferenceXValue;

  double ReferenceYValue;


  vtkPolyData* ReferenceLinesPolyData;

  vtkPolyDataMapper2D* ReferenceLinesMapper;

  vtkActor2D* ReferenceLinesActor;


  // Keep track of changes.

  int CachedSize[2];

  vtkTimeStamp BuildTime;


  void ComputeXRange(double range[2], double* lengths);

  void ComputeYRange(double range[2]);

  void ComputeDORange(double xrange[2], double yrange[2], double* lengths);


  virtual void CreatePlotData(

    int* pos, int* pos2, double xRange[2], double yRange[2], double* norms, int numDS, int numDO);

  void PlaceAxes(vtkViewport* viewport, const int* size, int pos[2], int pos2[2]);

  void GenerateClipPlanes(int* pos, int* pos2);

  double ComputeGlyphScale(int i, int* pos, int* pos2);

  void ClipPlotData(int* pos, int* pos2, vtkPolyData* pd);

  double* TransformPoint(int pos[2], int pos2[2], double x[3], double xNew[3]);


  vtkSmartPointer<vtkDoubleArray> ActiveCurve;


  int YAxisTitleSize;

  int ActiveCurveIndex;

  int PlotColorIndex;


private:

  vtkXYPlotActor(const vtkXYPlotActor&) = delete;

  void operator=(const vtkXYPlotActor&) = delete;


  bool DoesConnectionMatch(int i, vtkAlgorithmOutput* in);


  int IsInputPresent(vtkAlgorithmOutput* in, const char* arrayName, int component);


  int YTitleSize[2];


  int YTitlePosition;


  int YTitleDelta;

};


#endif