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

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


  Program:   Visualization Toolkit

  Module:    vtkRenderedGraphRepresentation.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 2008 Sandia Corporation.

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

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

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

#ifndef vtkRenderedGraphRepresentation_h

#define vtkRenderedGraphRepresentation_h


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

#include "vtkRenderedRepresentation.h"

#include "vtkSmartPointer.h" // for SP ivars


class vtkActor;

class vtkApplyColors;

class vtkApplyIcons;

class vtkEdgeCenters;

class vtkEdgeLayout;

class vtkEdgeLayoutStrategy;

class vtkGraphLayout;

class vtkGraphLayoutStrategy;

class vtkGraphToGlyphs;

class vtkGraphToPoints;

class vtkGraphToPolyData;

class vtkIconGlyphFilter;

class vtkInformation;

class vtkInformationVector;

class vtkLookupTable;

class vtkPerturbCoincidentVertices;

class vtkPointSetToLabelHierarchy;

class vtkPolyData;

class vtkPolyDataMapper;

class vtkPolyDataMapper2D;

class vtkRemoveHiddenData;

class vtkRenderView;

class vtkScalarBarWidget;

class vtkScalarsToColors;

class vtkTextProperty;

class vtkTexturedActor2D;

class vtkTransformCoordinateSystems;

class vtkVertexDegree;

class vtkView;

class vtkViewTheme;


class VTKVIEWSINFOVIS_EXPORT vtkRenderedGraphRepresentation : public vtkRenderedRepresentation

{

public:

  static vtkRenderedGraphRepresentation* New();

  vtkTypeMacro(vtkRenderedGraphRepresentation, vtkRenderedRepresentation);

  void PrintSelf(ostream& os, vtkIndent indent);


  // ------------------------------------------------------------------------

  // Vertex labels


  virtual void SetVertexLabelArrayName(const char* name);

  virtual const char* GetVertexLabelArrayName();

  virtual void SetVertexLabelPriorityArrayName(const char* name);

  virtual const char* GetVertexLabelPriorityArrayName();

  virtual void SetVertexLabelVisibility(bool b);

  virtual bool GetVertexLabelVisibility();

  vtkBooleanMacro(VertexLabelVisibility, bool);

  virtual void SetVertexLabelTextProperty(vtkTextProperty* p);

  virtual vtkTextProperty* GetVertexLabelTextProperty();

  vtkSetStringMacro(VertexHoverArrayName);

  vtkGetStringMacro(VertexHoverArrayName);


  vtkSetMacro(HideVertexLabelsOnInteraction, bool)

  vtkGetMacro(HideVertexLabelsOnInteraction, bool)

  vtkBooleanMacro(HideVertexLabelsOnInteraction, bool)


  // ------------------------------------------------------------------------

  // Edge labels


  virtual void SetEdgeLabelArrayName(const char* name);

  virtual const char* GetEdgeLabelArrayName();

  virtual void SetEdgeLabelPriorityArrayName(const char* name);

  virtual const char* GetEdgeLabelPriorityArrayName();

  virtual void SetEdgeLabelVisibility(bool b);

  virtual bool GetEdgeLabelVisibility();

  vtkBooleanMacro(EdgeLabelVisibility, bool);

  virtual void SetEdgeLabelTextProperty(vtkTextProperty* p);

  virtual vtkTextProperty* GetEdgeLabelTextProperty();

  vtkSetStringMacro(EdgeHoverArrayName);

  vtkGetStringMacro(EdgeHoverArrayName);


  vtkSetMacro(HideEdgeLabelsOnInteraction, bool)

  vtkGetMacro(HideEdgeLabelsOnInteraction, bool)

  vtkBooleanMacro(HideEdgeLabelsOnInteraction, bool)


  // ------------------------------------------------------------------------

  // Vertex icons


  virtual void SetVertexIconArrayName(const char* name);

  virtual const char* GetVertexIconArrayName();

  virtual void SetVertexIconPriorityArrayName(const char* name);

  virtual const char* GetVertexIconPriorityArrayName();

  virtual void SetVertexIconVisibility(bool b);

  virtual bool GetVertexIconVisibility();

  vtkBooleanMacro(VertexIconVisibility, bool);

  virtual void AddVertexIconType(const char* name, int type);

  virtual void ClearVertexIconTypes();

  virtual void SetUseVertexIconTypeMap(bool b);

  virtual bool GetUseVertexIconTypeMap();

  vtkBooleanMacro(UseVertexIconTypeMap, bool);

  virtual void SetVertexIconAlignment(int align);

  virtual int GetVertexIconAlignment();

  virtual void SetVertexSelectedIcon(int icon);

  virtual int GetVertexSelectedIcon();

  virtual void SetVertexDefaultIcon(int icon);

  virtual int GetVertexDefaultIcon();


  virtual void SetVertexIconSelectionMode(int mode);

  virtual int GetVertexIconSelectionMode();

  virtual void SetVertexIconSelectionModeToSelectedIcon()

    { this->SetVertexIconSelectionMode(0); }

  virtual void SetVertexIconSelectionModeToSelectedOffset()

    { this->SetVertexIconSelectionMode(1); }

  virtual void SetVertexIconSelectionModeToAnnotationIcon()

    { this->SetVertexIconSelectionMode(2); }

  virtual void SetVertexIconSelectionModeToIgnoreSelection()

    { this->SetVertexIconSelectionMode(3); }


  // ------------------------------------------------------------------------

  // Edge icons


  virtual void SetEdgeIconArrayName(const char* name);

  virtual const char* GetEdgeIconArrayName();

  virtual void SetEdgeIconPriorityArrayName(const char* name);

  virtual const char* GetEdgeIconPriorityArrayName();

  virtual void SetEdgeIconVisibility(bool b);

  virtual bool GetEdgeIconVisibility();

  vtkBooleanMacro(EdgeIconVisibility, bool);

  virtual void AddEdgeIconType(const char* name, int type);

  virtual void ClearEdgeIconTypes();

  virtual void SetUseEdgeIconTypeMap(bool b);

  virtual bool GetUseEdgeIconTypeMap();

  vtkBooleanMacro(UseEdgeIconTypeMap, bool);

  virtual void SetEdgeIconAlignment(int align);

  virtual int GetEdgeIconAlignment();


  // ------------------------------------------------------------------------

  // Vertex colors


  virtual void SetColorVerticesByArray(bool b);

  virtual bool GetColorVerticesByArray();

  vtkBooleanMacro(ColorVerticesByArray, bool);

  virtual void SetVertexColorArrayName(const char* name);

  virtual const char* GetVertexColorArrayName();


  // ------------------------------------------------------------------------

  // Edge colors


  virtual void SetColorEdgesByArray(bool b);

  virtual bool GetColorEdgesByArray();

  vtkBooleanMacro(ColorEdgesByArray, bool);

  virtual void SetEdgeColorArrayName(const char* name);

  virtual const char* GetEdgeColorArrayName();


  // ------------------------------------------------------------------------

  // Enabled vertices


  virtual void SetEnableVerticesByArray(bool b);

  virtual bool GetEnableVerticesByArray();

  vtkBooleanMacro(EnableVerticesByArray, bool);

  virtual void SetEnabledVerticesArrayName(const char* name);

  virtual const char* GetEnabledVerticesArrayName();


  // ------------------------------------------------------------------------

  // Enabled edges


  virtual void SetEnableEdgesByArray(bool b);

  virtual bool GetEnableEdgesByArray();

  vtkBooleanMacro(EnableEdgesByArray, bool);

  virtual void SetEnabledEdgesArrayName(const char* name);

  virtual const char* GetEnabledEdgesArrayName();


  virtual void SetEdgeVisibility(bool b);

  virtual bool GetEdgeVisibility();

  vtkBooleanMacro(EdgeVisibility, bool);


  void SetEdgeSelection(bool b);

  bool GetEdgeSelection();


  // ------------------------------------------------------------------------

  // Vertex layout strategy


  virtual void SetLayoutStrategy(vtkGraphLayoutStrategy* strategy);

  virtual vtkGraphLayoutStrategy* GetLayoutStrategy();


  virtual void SetLayoutStrategy(const char* name);

  vtkGetStringMacro(LayoutStrategyName);


  void SetLayoutStrategyToRandom()

    { this->SetLayoutStrategy("Random"); }

  void SetLayoutStrategyToForceDirected()

    { this->SetLayoutStrategy("Force Directed"); }

  void SetLayoutStrategyToSimple2D()

    { this->SetLayoutStrategy("Simple 2D"); }

  void SetLayoutStrategyToClustering2D()

    { this->SetLayoutStrategy("Clustering 2D"); }

  void SetLayoutStrategyToCommunity2D()

    { this->SetLayoutStrategy("Community 2D"); }

  void SetLayoutStrategyToFast2D()

    { this->SetLayoutStrategy("Fast 2D"); }

  void SetLayoutStrategyToPassThrough()

    { this->SetLayoutStrategy("Pass Through"); }

  void SetLayoutStrategyToCircular()

    { this->SetLayoutStrategy("Circular"); }

  void SetLayoutStrategyToTree()

    { this->SetLayoutStrategy("Tree"); }

  void SetLayoutStrategyToCosmicTree()

    { this->SetLayoutStrategy("Cosmic Tree"); }

  void SetLayoutStrategyToCone()

    { this->SetLayoutStrategy("Cone"); }

  void SetLayoutStrategyToSpanTree()

    { this->SetLayoutStrategy("Span Tree"); }


  virtual void SetLayoutStrategyToAssignCoordinates(

    const char* xarr, const char* yarr = 0, const char* zarr = 0);


  virtual void SetLayoutStrategyToTree(

    bool radial,

    double angle = 90,

    double leafSpacing = 0.9,

    double logSpacing = 1.0);


  virtual void SetLayoutStrategyToCosmicTree(

    const char* nodeSizeArrayName,

    bool sizeLeafNodesOnly = true,

    int layoutDepth = 0,

    vtkIdType layoutRoot = -1);


  // ------------------------------------------------------------------------

  // Edge layout strategy


  virtual void SetEdgeLayoutStrategy(vtkEdgeLayoutStrategy* strategy);

  virtual vtkEdgeLayoutStrategy* GetEdgeLayoutStrategy();

  void SetEdgeLayoutStrategyToArcParallel()

    { this->SetEdgeLayoutStrategy("Arc Parallel"); }

  void SetEdgeLayoutStrategyToPassThrough()

    { this->SetEdgeLayoutStrategy("Pass Through"); }


  virtual void SetEdgeLayoutStrategyToGeo(double explodeFactor = 0.2);


  virtual void SetEdgeLayoutStrategy(const char* name);

  vtkGetStringMacro(EdgeLayoutStrategyName);


  // ------------------------------------------------------------------------

  // Miscellaneous


  virtual void ApplyViewTheme(vtkViewTheme* theme);


  virtual void SetGlyphType(int type);

  virtual int GetGlyphType();


  virtual void SetScaling(bool b);

  virtual bool GetScaling();

  vtkBooleanMacro(Scaling, bool);


  virtual void SetScalingArrayName(const char* name);

  virtual const char* GetScalingArrayName();


  virtual void SetVertexScalarBarVisibility(bool b);

  virtual bool GetVertexScalarBarVisibility();

  virtual void SetEdgeScalarBarVisibility(bool b);

  virtual bool GetEdgeScalarBarVisibility();


  virtual vtkScalarBarWidget* GetVertexScalarBar();

  virtual vtkScalarBarWidget* GetEdgeScalarBar();


  virtual bool IsLayoutComplete();


  virtual void UpdateLayout();


  void ComputeSelectedGraphBounds( double bounds[6] );


protected:

  vtkRenderedGraphRepresentation();

  ~vtkRenderedGraphRepresentation();


  virtual bool AddToView(vtkView* view);

  virtual bool RemoveFromView(vtkView* view);


  virtual void PrepareForRendering(vtkRenderView* view);


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


  virtual vtkUnicodeString GetHoverTextInternal(vtkSelection* sel);


  virtual int RequestData(

    vtkInformation* request,

    vtkInformationVector** inputVector,

    vtkInformationVector* outputVector);


  //BTX


  vtkSmartPointer<vtkApplyColors>          ApplyColors;

  vtkSmartPointer<vtkVertexDegree>         VertexDegree;

  vtkSmartPointer<vtkPolyData>             EmptyPolyData;

  vtkSmartPointer<vtkEdgeCenters>          EdgeCenters;

  vtkSmartPointer<vtkGraphToPoints>        GraphToPoints;

  vtkSmartPointer<vtkPointSetToLabelHierarchy> VertexLabelHierarchy;

  vtkSmartPointer<vtkPointSetToLabelHierarchy> EdgeLabelHierarchy;

  vtkSmartPointer<vtkGraphLayout>          Layout;

  vtkSmartPointer<vtkPerturbCoincidentVertices> Coincident;

  vtkSmartPointer<vtkEdgeLayout>           EdgeLayout;

  vtkSmartPointer<vtkGraphToPolyData>      GraphToPoly;

  vtkSmartPointer<vtkPolyDataMapper>       EdgeMapper;

  vtkSmartPointer<vtkActor>                EdgeActor;

  vtkSmartPointer<vtkGraphToGlyphs>        VertexGlyph;

  vtkSmartPointer<vtkPolyDataMapper>       VertexMapper;

  vtkSmartPointer<vtkActor>                VertexActor;

  vtkSmartPointer<vtkGraphToGlyphs>        OutlineGlyph;

  vtkSmartPointer<vtkPolyDataMapper>       OutlineMapper;

  vtkSmartPointer<vtkActor>                OutlineActor;

  vtkSmartPointer<vtkScalarBarWidget>      VertexScalarBar;

  vtkSmartPointer<vtkScalarBarWidget>      EdgeScalarBar;

  vtkSmartPointer<vtkRemoveHiddenData>     RemoveHiddenGraph;

  vtkSmartPointer<vtkApplyIcons>           ApplyVertexIcons;

  vtkSmartPointer<vtkGraphToPoints>        VertexIconPoints;

  vtkSmartPointer<vtkTransformCoordinateSystems> VertexIconTransform;

  vtkSmartPointer<vtkIconGlyphFilter>      VertexIconGlyph;

  vtkSmartPointer<vtkPolyDataMapper2D>     VertexIconMapper;

  vtkSmartPointer<vtkTexturedActor2D>      VertexIconActor;

  //ETX


  char* VertexHoverArrayName;

  char* EdgeHoverArrayName;


  vtkSetStringMacro(VertexColorArrayNameInternal);

  vtkGetStringMacro(VertexColorArrayNameInternal);

  char* VertexColorArrayNameInternal;


  vtkSetStringMacro(EdgeColorArrayNameInternal);

  vtkGetStringMacro(EdgeColorArrayNameInternal);

  char* EdgeColorArrayNameInternal;


  vtkSetStringMacro(ScalingArrayNameInternal);

  vtkGetStringMacro(ScalingArrayNameInternal);

  char* ScalingArrayNameInternal;


  vtkSetStringMacro(LayoutStrategyName);

  char* LayoutStrategyName;

  vtkSetStringMacro(EdgeLayoutStrategyName);

  char* EdgeLayoutStrategyName;

  bool HideVertexLabelsOnInteraction;

  bool HideEdgeLabelsOnInteraction;


  bool EdgeSelection;


private:

  vtkRenderedGraphRepresentation(const vtkRenderedGraphRepresentation&); // Not implemented

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

};


#endif