vtkParallelCoordinatesRepresentation.h

Go to the documentation of this file.

/*=========================================================================
 
  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