v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

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


  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 "vtkRenderingAnnotationModule.h" // For export macro

#include "vtkActor2D.h"

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


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


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

  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, 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


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


  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;

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


//BTX

  vtkSmartPointer<vtkDoubleArray> ActiveCurve;

//ETX

  int YAxisTitleSize;

  int ActiveCurveIndex;

  int PlotColorIndex;


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


  int YTitleSize[2];


  int YTitlePosition;


  int YTitleDelta;

};


#endif