vtkXYPlotActor.h

Go to the documentation of this file.

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

  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

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

class vtkXYPlotActorConnections;
class vtkAlgorithmOutput;
class vtkAppendPolyData;
class vtkAxisActor2D;
class vtkDataObject;
class vtkDataObjectCollection;
class vtkDataSet;
class vtkDataSetCollection;
class vtkGlyph2D;
class vtkGlyphSource2D;
class vtkIntArray;
class vtkLegendBoxActor;
class vtkPlanes;
class vtkPolyData;
class vtkPolyDataMapper2D;
class vtkTextMapper;
class vtkTextProperty;

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

  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, NULL, 0);}
  void AddDataSetInputConnection(vtkAlgorithmOutput *in, const char* arrayName, int component);
  void AddDataSetInputConnection(vtkAlgorithmOutput *in) {this->AddDataSetInputConnection(in, NULL, 0);}


  void RemoveDataSetInput(vtkDataSet *ds, const char* arrayName, int component);
  void RemoveDataSetInput(vtkDataSet *ds) {this->RemoveDataSetInput(ds, NULL, 0);}
  void RemoveDataSetInputConnection(vtkAlgorithmOutput *in, const char* arrayName, int component);
  void RemoveDataSetInputConnection(vtkAlgorithmOutput *in)
  {
    this->RemoveDataSetInputConnection(in, NULL, 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);
  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, int);
  vtkSetMacro(PlotCurvePoints, int);
  vtkBooleanMacro(PlotCurvePoints, int);

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

  void SetPlotLines(int i, int);
  int GetPlotLines(int i);

  void SetPlotPoints(int i, int);
  int GetPlotPoints(int i);
  //---end Per Curve Properties-----------------------------------------------


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


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


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


  vtkGetObjectMacro(LegendActor,vtkLegendBoxActor);
  vtkGetObjectMacro(GlyphSource,vtkGlyphSource2D);


  vtkSetStringMacro(Title);
  vtkGetStringMacro(Title);
  vtkSetStringMacro(XTitle);
  vtkGetStringMacro(XTitle);
  vtkSetStringMacro(YTitle);
  vtkGetStringMacro(YTitle);


  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 SetXTitlePosition(double position);
  double GetXTitlePosition();
  void SetYTitlePosition(double position);
  double GetYTitlePosition();


  void SetNumberOfXMinorTicks(int num);
  int GetNumberOfXMinorTicks();
  void SetNumberOfYMinorTicks(int num);
  int GetNumberOfYMinorTicks();


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


  vtkSetVector2Macro(TitlePosition,double);
  vtkGetVector2Macro(TitlePosition,double);


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

//BTX
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,
};
//ETX

  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, int);
  vtkGetMacro(Logx, int);
  vtkBooleanMacro(Logx, int);


  virtual void SetLabelFormat (const char* _arg);
  const char* GetLabelFormat()
    {
      return this->GetXLabelFormat();
    }


  virtual void SetXLabelFormat (const char* _arg);
  vtkGetStringMacro(XLabelFormat);


  virtual void SetYLabelFormat (const char* _arg);
  vtkGetStringMacro(YLabelFormat);


  vtkSetClampMacro(Border, int, 0, 50);
  vtkGetMacro(Border, int);


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


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


  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, int);
  vtkGetMacro(ChartBox, int);
  vtkBooleanMacro(ChartBox, int);


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

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


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


  vtkSetMacro(ReferenceXValue, double);
  vtkGetMacro(ReferenceXValue, double);


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


  vtkSetMacro(ReferenceYValue, double);
  vtkGetMacro(ReferenceYValue, double);

  unsigned long GetMTime();

  void PrintAsCSV(ostream &os);

//BTX

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

  virtual int HasTranslucentPolygonalGeometry();


  void ReleaseGraphicsResources(vtkWindow *);
//ETX

protected:
  vtkXYPlotActor();
  ~vtkXYPlotActor();

  vtkXYPlotActorConnections* InputConnectionHolder;
  char** SelectedInputScalars; // list of data set arrays to plot
  vtkIntArray* SelectedInputScalarsComponent; // list of componenents
  vtkXYPlotActorConnections *DataObjectInputConnectionHolder; //list of data objects to plot
  char  *Title;
  char  *XTitle;
  char  *YTitle;
  int   XValues;
  int   NumberOfXLabels;
  int   NumberOfYLabels;
  int   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;
  int PlotLines;
  int PlotPoints;
  int PlotCurveLines;
  int PlotCurvePoints;
  int ExchangeAxes;
  int ReverseXAxis;
  int ReverseYAxis;
  int AdjustXLabels;
  int AdjustYLabels;
  int 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.
  int Legend;
  double LegendPosition[2];
  double LegendPosition2[2];
  vtkLegendBoxActor *LegendActor;
  vtkGlyphSource2D *GlyphSource;
  vtkPlanes *ClipPlanes;
  double GlyphSize;

  // Background box
  int ChartBox;
  vtkPolyData                *ChartBoxPolyData;
  vtkPolyDataMapper2D        *ChartBoxMapper;
  vtkActor2D                 *ChartBoxActor;
  int ChartBorder;
  vtkPolyData                *ChartBorderPolyData;
  vtkPolyDataMapper2D        *ChartBorderMapper;
  vtkActor2D                 *ChartBorderActor;

  // Reference lines
  int ShowReferenceXLine;
  int 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, 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]);

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

  bool DoesConnectionMatch(int i, vtkAlgorithmOutput* in);

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


#endif