9.1/html/vtkParallelCoordinatesRepresentation_8h_source.html

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


  Program:   Visualization Toolkit

  Module:    vtkParallelCoordinatesRepresentation.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.


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

/*-------------------------------------------------------------------------

  Copyright 2009 Sandia Corporation.

  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,

  the U.S. Government retains certain rights in this software.

-------------------------------------------------------------------------*/

#ifndef vtkParallelCoordinatesRepresentation_h

#define vtkParallelCoordinatesRepresentation_h


#include "vtkRenderedRepresentation.h"

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


class vtkActor;

class vtkActor2D;

class vtkArrayData;

class vtkAxisActor2D;

class vtkBivariateLinearTableThreshold;

class vtkCollection;

class vtkCoordinate;

class vtkExtractSelectedPolyDataIds;

class vtkFieldData;

class vtkDataArray;

class vtkDataObject;

class vtkDoubleArray;

class vtkIdList;

class vtkIdTypeArray;

class vtkIntArray;

class vtkLookupTable;

class vtkOutlineCornerSource;

class vtkPoints;

class vtkPolyData;

class vtkPolyDataMapper2D;

class vtkPropCollection;

class vtkSelection;

class vtkSelectionNode;

class vtkTextMapper;

class vtkTimeStamp;

class vtkUnsignedIntArray;

class vtkViewport;

class vtkWindow;


class VTKVIEWSINFOVIS_EXPORT vtkParallelCoordinatesRepresentation : public vtkRenderedRepresentation

{

public:

  static vtkParallelCoordinatesRepresentation* New();

  vtkTypeMacro(vtkParallelCoordinatesRepresentation, vtkRenderedRepresentation);

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


  void ApplyViewTheme(vtkViewTheme* theme) override;


  virtual std::string GetHoverString(vtkView* view, int x, int y);

  VTK_DEPRECATED_IN_9_1_0("Use std::string GetHoverString(vtkView* view, int x, int y)")

  virtual const char* GetHoverText(vtkView* view, int x, int y);


  int SetPositionAndSize(double* position, double* size);

  int GetPositionAndSize(double* position, double* size);


  void SetAxisTitles(vtkStringArray*);

  void SetAxisTitles(vtkAlgorithmOutput*);


  void SetPlotTitle(const char*);


  vtkGetMacro(NumberOfAxes, int);


  vtkGetMacro(NumberOfSamples, int);


  void SetNumberOfAxisLabels(int num);

  vtkGetMacro(NumberOfAxisLabels, int);


  virtual int SwapAxisPositions(int position1, int position2);

  int SetXCoordinateOfPosition(int position, double xcoord);

  double GetXCoordinateOfPosition(int axis);

  void GetXCoordinatesOfPositions(double* coords);

  int GetPositionNearXCoordinate(double xcoord);


  vtkSetMacro(UseCurves, vtkTypeBool);

  vtkGetMacro(UseCurves, vtkTypeBool);

  vtkBooleanMacro(UseCurves, vtkTypeBool);


  vtkSetMacro(CurveResolution, int);

  vtkGetMacro(CurveResolution, int);


  vtkGetMacro(LineOpacity, double);

  vtkGetMacro(FontSize, double);

  vtkGetVector3Macro(LineColor, double);

  vtkGetVector3Macro(AxisColor, double);

  vtkGetVector3Macro(AxisLabelColor, double);

  vtkSetMacro(LineOpacity, double);

  vtkSetMacro(FontSize, double);

  vtkSetVector3Macro(LineColor, double);

  vtkSetVector3Macro(AxisColor, double);

  vtkSetVector3Macro(AxisLabelColor, double);


  vtkSetMacro(AngleBrushThreshold, double);

  vtkGetMacro(AngleBrushThreshold, double);


  vtkSetMacro(FunctionBrushThreshold, double);

  vtkGetMacro(FunctionBrushThreshold, double);


  int GetRangeAtPosition(int position, double range[2]);

  virtual int SetRangeAtPosition(int position, double range[2]);


  void ResetAxes();


  virtual void LassoSelect(int brushClass, int brushOperator, vtkPoints* brushPoints);

  virtual void AngleSelect(int brushClass, int brushOperator, double* p1, double* p2);

  virtual void FunctionSelect(

    int brushClass, int brushOperator, double* p1, double* p2, double* q1, double* q2);

  virtual void RangeSelect(int brushClass, int brushOperator, double* p1, double* p2);


  enum InputPorts

  {

    INPUT_DATA = 0,

    INPUT_TITLES,

    NUM_INPUT_PORTS

  };


protected:

  vtkParallelCoordinatesRepresentation();

  ~vtkParallelCoordinatesRepresentation() override;


  int FillInputPortInformation(int port, vtkInformation* info) override;


  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;


  bool AddToView(vtkView* view) override;

  bool RemoveFromView(vtkView* view) override;

  void PrepareForRendering(vtkRenderView* view) override;


  void UpdateHoverHighlight(vtkView* view, int x, int y);


  virtual int AllocatePolyData(vtkPolyData* polyData, int numLines, int numPointsPerLine,

    int numStrips, int numPointsPerStrip, int numQuads, int numPoints, int numCellScalars,

    int numPointScalars);


  int PlaceAxes();


  virtual int PlaceLines(vtkPolyData* polyData, vtkTable* data, vtkIdTypeArray* idsToPlot);

  virtual int PlaceCurves(vtkPolyData* polyData, vtkTable* data, vtkIdTypeArray* idsToPlot);


  virtual int PlaceSelection(

    vtkPolyData* polyData, vtkTable* data, vtkSelectionNode* selectionNode);


  virtual int ComputeDataProperties();


  virtual int UpdatePlotProperties(vtkStringArray* inputTitles);


  virtual int ReallocateInternals();


  int ComputePointPosition(double* p);

  int ComputeLinePosition(double* p1, double* p2);


  virtual void SelectRows(vtkIdType brushClass, vtkIdType brushOperator, vtkIdTypeArray* rowIds);

  vtkSelection* ConvertSelection(vtkView* view, vtkSelection* selection) override;

  virtual void BuildInverseSelection();

  virtual vtkPolyDataMapper2D* InitializePlotMapper(

    vtkPolyData* input, vtkActor2D* actor, bool forceStandard = false);


  void BuildDefaultSCurve(vtkDoubleArray* array, int numValues);


  virtual void LassoSelectInternal(vtkPoints* brushPoints, vtkIdTypeArray* outIds);


  virtual void UpdateSelectionActors();


  vtkPolyDataMapper2D* GetSelectionMapper(int idx);

  int GetNumberOfSelections();


  vtkSmartPointer<vtkPolyData> PlotData;

  vtkSmartPointer<vtkPolyDataMapper2D> PlotMapper;

  vtkSmartPointer<vtkActor2D> PlotActor;

  vtkSmartPointer<vtkTextMapper> PlotTitleMapper;

  vtkSmartPointer<vtkActor2D> PlotTitleActor;

  vtkSmartPointer<vtkTextMapper> FunctionTextMapper;

  vtkSmartPointer<vtkActor2D> FunctionTextActor;


  vtkSmartPointer<vtkSelection> InverseSelection;

  vtkSmartPointer<vtkBivariateLinearTableThreshold> LinearThreshold;


  class Internals;

  Internals* I;


  int NumberOfAxes;

  int NumberOfAxisLabels;

  int NumberOfSamples;

  double YMin;

  double YMax;


  int CurveResolution;

  vtkTypeBool UseCurves;

  double AngleBrushThreshold;

  double FunctionBrushThreshold;

  double SwapThreshold;


  // Indexed by screen position

  double* Xs;

  double* Mins;

  double* Maxs;

  double* MinOffsets;

  double* MaxOffsets;


  vtkSmartPointer<vtkAxisActor2D>* Axes;

  vtkSmartPointer<vtkTable> InputArrayTable;

  vtkSmartPointer<vtkStringArray> AxisTitles;


  vtkTimeStamp BuildTime;


  double LineOpacity;

  double FontSize;

  double LineColor[3];

  double AxisColor[3];

  double AxisLabelColor[3];


  vtkGetStringMacro(InternalHoverText);

  vtkSetStringMacro(InternalHoverText);

  char* InternalHoverText;


private:

  vtkParallelCoordinatesRepresentation(const vtkParallelCoordinatesRepresentation&) = delete;

  void operator=(const vtkParallelCoordinatesRepresentation&) = delete;

};


#endif