dox/Views/vtkRenderedGraphRepresentation.h

Go to the documentation of this file.

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

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