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

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


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

#include "vtkRenderedRepresentation.h"


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


  virtual void ApplyViewTheme(vtkViewTheme* theme);


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

  vtkGetMacro(UseCurves,int);

  vtkBooleanMacro(UseCurves,int);


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


//BTX

  enum InputPorts

  {

    INPUT_DATA=0,

    INPUT_TITLES,

    NUM_INPUT_PORTS

  };

//ETX


protected:

  vtkParallelCoordinatesRepresentation();

  virtual ~vtkParallelCoordinatesRepresentation();


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


  virtual int RequestData(

    vtkInformation*,

    vtkInformationVector**,

    vtkInformationVector*);


  virtual bool AddToView(vtkView* view);

  virtual bool RemoveFromView(vtkView* view);

  virtual void PrepareForRendering(vtkRenderView* view);


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

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

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


  //BTX

  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;

  //ETX


  int NumberOfAxes;

  int NumberOfAxisLabels;

  int NumberOfSamples;

  double YMin;

  double YMax;


  int CurveResolution;

  int UseCurves;

  double AngleBrushThreshold;

  double FunctionBrushThreshold;

  double SwapThreshold;


  // Indexed by screen position

  double* Xs;

  double* Mins;

  double* Maxs;

  double* MinOffsets;

  double* MaxOffsets;


  //BTX

  vtkSmartPointer<vtkAxisActor2D>* Axes;

  vtkSmartPointer<vtkTable> InputArrayTable;

  vtkSmartPointer<vtkStringArray> AxisTitles;

  //ETX


  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&); // Not implemented

  void operator=(const vtkParallelCoordinatesRepresentation&);   // Not implemented

};


#endif