vtkGraph.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkGraph.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 vtkGraph_h
#define vtkGraph_h
 
#include "vtkCommonDataModelModule.h" // For export macro
#include "vtkDataObject.h"
 
class vtkAdjacentVertexIterator;
class vtkCellArray;
class vtkEdgeListIterator;
class vtkDataSetAttributes;
class vtkDirectedGraph;
class vtkGraphEdge;
class vtkGraphEdgePoints;
class vtkDistributedGraphHelper;
class vtkGraphInternals;
class vtkIdTypeArray;
class vtkInEdgeIterator;
class vtkOutEdgeIterator;
class vtkPoints;
class vtkUndirectedGraph;
class vtkVertexListIterator;
class vtkVariant;
class vtkVariantArray;
 
//BTX
// Forward declare some boost stuff even if boost wrappers
// are turned off.
namespace boost
{
  class vtk_edge_iterator;
  class vtk_out_edge_pointer_iterator;
  class vtk_in_edge_pointer_iterator;
}
 
// Edge structures.
struct vtkEdgeBase
{
  vtkEdgeBase() { }
  vtkEdgeBase(vtkIdType id) :
    Id(id) { }
  vtkIdType Id;
};
 
struct vtkOutEdgeType : vtkEdgeBase
{
  vtkOutEdgeType() { }
  vtkOutEdgeType(vtkIdType t, vtkIdType id) :
    vtkEdgeBase(id),
    Target(t) { }
  vtkIdType Target;
};
 
struct vtkInEdgeType : vtkEdgeBase
{
  vtkInEdgeType() { }
  vtkInEdgeType(vtkIdType s, vtkIdType id) :
    vtkEdgeBase(id),
    Source(s) { }
  vtkIdType Source;
};
 
struct vtkEdgeType : vtkEdgeBase
{
  vtkEdgeType() { }
  vtkEdgeType(vtkIdType s, vtkIdType t, vtkIdType id) :
    vtkEdgeBase(id),
    Source(s),
    Target(t) { }
  vtkIdType Source;
  vtkIdType Target;
};
//ETX
 
class VTKCOMMONDATAMODEL_EXPORT vtkGraph : public vtkDataObject
{
public:
  vtkTypeMacro(vtkGraph, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  vtkGetObjectMacro(VertexData, vtkDataSetAttributes);
  vtkGetObjectMacro(EdgeData, vtkDataSetAttributes);
 
  virtual int GetDataObjectType() {return VTK_GRAPH;}
 
  virtual void Initialize();
 
 
  double *GetPoint(vtkIdType ptId);
  void GetPoint(vtkIdType ptId, double x[3]);
 
 
  vtkPoints* GetPoints();
  virtual void SetPoints(vtkPoints *points);
 
  void ComputeBounds();
 
 
  double *GetBounds();
  void GetBounds(double bounds[6]);
 
  unsigned long int GetMTime();
 
  virtual void GetOutEdges(vtkIdType v, vtkOutEdgeIterator *it);
 
  virtual vtkIdType GetDegree(vtkIdType v);
 
  virtual vtkIdType GetOutDegree(vtkIdType v);
 
  //BTX
 
  virtual vtkOutEdgeType GetOutEdge(vtkIdType v, vtkIdType index);
  //ETX
 
  virtual void GetOutEdge(vtkIdType v, vtkIdType index, vtkGraphEdge* e);
 
  virtual void GetInEdges(vtkIdType v, vtkInEdgeIterator *it);
 
  virtual vtkIdType GetInDegree(vtkIdType v);
 
  //BTX
 
  virtual vtkInEdgeType GetInEdge(vtkIdType v, vtkIdType index);
  //ETX
 
  virtual void GetInEdge(vtkIdType v, vtkIdType index, vtkGraphEdge* e);
 
  virtual void GetAdjacentVertices(vtkIdType v, vtkAdjacentVertexIterator *it);
 
  virtual void GetEdges(vtkEdgeListIterator *it);
 
  virtual vtkIdType GetNumberOfEdges();
 
  virtual void GetVertices(vtkVertexListIterator *it);
 
  virtual vtkIdType GetNumberOfVertices();
 
  // BTX
  void SetDistributedGraphHelper(vtkDistributedGraphHelper *helper);
 
 
  vtkDistributedGraphHelper *GetDistributedGraphHelper();
  //ETX
 
  vtkIdType FindVertex(const vtkVariant& pedigreeID);
 
  virtual void ShallowCopy(vtkDataObject *obj);
 
  virtual void DeepCopy(vtkDataObject *obj);
 
  virtual void CopyStructure(vtkGraph *g);
 
  virtual bool CheckedShallowCopy(vtkGraph *g);
 
  virtual bool CheckedDeepCopy(vtkGraph *g);
 
  virtual void Squeeze();
 
  //BTX
 
  static vtkGraph *GetData(vtkInformation *info);
  static vtkGraph *GetData(vtkInformationVector *v, int i=0);
  //ETX
 
  void ReorderOutVertices(vtkIdType v, vtkIdTypeArray *vertices);
 
  bool IsSameStructure(vtkGraph *other);
 
 
  vtkIdType GetSourceVertex(vtkIdType e);
  vtkIdType GetTargetVertex(vtkIdType e);
 
  //BTX
 
  void SetEdgePoints(vtkIdType e, vtkIdType npts, double* pts);
  void GetEdgePoints(vtkIdType e, vtkIdType& npts, double*& pts);
  //ETX
 
  vtkIdType GetNumberOfEdgePoints(vtkIdType e);
 
  double* GetEdgePoint(vtkIdType e, vtkIdType i);
 
  void ClearEdgePoints(vtkIdType e);
 
 
  void SetEdgePoint(vtkIdType e, vtkIdType i, double x[3]);
  void SetEdgePoint(vtkIdType e, vtkIdType i, double x, double y, double z)
    { double p[3] = {x, y, z}; this->SetEdgePoint(e, i, p); }
 
 
  void AddEdgePoint(vtkIdType e, double x[3]);
  void AddEdgePoint(vtkIdType e, double x, double y, double z)
    { double p[3] = {x, y, z}; this->AddEdgePoint(e, p); }
 
 
  void ShallowCopyEdgePoints(vtkGraph* g);
  void DeepCopyEdgePoints(vtkGraph* g);
 
  vtkGraphInternals *GetGraphInternals(bool modifying);
 
  void GetInducedEdges(vtkIdTypeArray* verts, vtkIdTypeArray* edges);
 
  virtual vtkFieldData* GetAttributesAsFieldData(int type);
 
  virtual vtkIdType GetNumberOfElements(int type);
 
  void Dump();
 
  vtkIdType GetEdgeId(vtkIdType a, vtkIdType b);
 
  bool ToDirectedGraph(vtkDirectedGraph* g);
 
  bool ToUndirectedGraph(vtkUndirectedGraph* g);
 
protected:
  //BTX
  vtkGraph();
  ~vtkGraph();
 
 
  void AddVertexInternal(vtkVariantArray *propertyArr = 0,
                         vtkIdType *vertex = 0);
 
  void AddVertexInternal(const vtkVariant& pedigree, vtkIdType *vertex);
 
 
  void AddEdgeInternal(vtkIdType u, vtkIdType v, bool directed,
                       vtkVariantArray *propertyArr, vtkEdgeType *edge);
  void AddEdgeInternal(const vtkVariant& uPedigree, vtkIdType v, bool directed,
                       vtkVariantArray *propertyArr, vtkEdgeType *edge);
  void AddEdgeInternal(vtkIdType u, const vtkVariant& vPedigree, bool directed,
                       vtkVariantArray *propertyArr, vtkEdgeType *edge);
  void AddEdgeInternal(const vtkVariant& uPedigree, const vtkVariant& vPedigree,
                       bool directed, vtkVariantArray *propertyArr,
                       vtkEdgeType *edge);
 
  void RemoveVertexInternal(vtkIdType v, bool directed);
 
  void RemoveEdgeInternal(vtkIdType e, bool directed);
 
  void RemoveVerticesInternal(vtkIdTypeArray* arr, bool directed);
 
 
  void RemoveEdgesInternal(vtkIdTypeArray* arr, bool directed);
  //ETX
 
  virtual bool IsStructureValid(vtkGraph *g) = 0;
 
  virtual void CopyInternal(vtkGraph *g, bool deep);
 
  vtkGraphInternals *Internals;
 
  vtkDistributedGraphHelper *DistributedHelper;
 
  void SetInternals(vtkGraphInternals* internals);
 
  vtkGraphEdgePoints *EdgePoints;
 
  void SetEdgePoints(vtkGraphEdgePoints* edgePoints);
 
  void ForceOwnership();
 
 
  virtual void GetOutEdges(vtkIdType v, const vtkOutEdgeType *& edges, vtkIdType & nedges);
  virtual void GetInEdges(vtkIdType v, const vtkInEdgeType *& edges, vtkIdType & nedges);
 
  void BuildEdgeList();
 
  //BTX
 
  friend class vtkAdjacentVertexIterator;
  friend class vtkEdgeListIterator;
  friend class vtkInEdgeIterator;
  friend class vtkOutEdgeIterator;
  friend class boost::vtk_edge_iterator;
  friend class boost::vtk_in_edge_pointer_iterator;
  friend class boost::vtk_out_edge_pointer_iterator;
  //ETX
 
 
  vtkDataSetAttributes *VertexData;
  vtkDataSetAttributes *EdgeData;
 
  double Bounds[6];
 
  vtkTimeStamp ComputeTime;
 
 
  vtkPoints *Points;
  static double DefaultPoint[3];
 
 
  vtkGetObjectMacro(EdgeList, vtkIdTypeArray);
  virtual void SetEdgeList(vtkIdTypeArray* list);
  vtkIdTypeArray *EdgeList;
  //ETX
private:
  vtkGraph(const vtkGraph&);  // Not implemented.
  void operator=(const vtkGraph&);  // Not implemented.
};
 
//BTX
bool VTKCOMMONDATAMODEL_EXPORT operator==(vtkEdgeBase e1, vtkEdgeBase e2);
bool VTKCOMMONDATAMODEL_EXPORT operator!=(vtkEdgeBase e1, vtkEdgeBase e2);
VTKCOMMONDATAMODEL_EXPORT ostream& operator<<(ostream& out, vtkEdgeBase e);
//ETX
 
#endif