dox/Views/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"

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