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;

// 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;
};

class VTKCOMMONDATAMODEL_EXPORT vtkGraph : public vtkDataObject
{
public:
  vtkTypeMacro(vtkGraph, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  vtkGetObjectMacro(VertexData, vtkDataSetAttributes);
  vtkGetObjectMacro(EdgeData, vtkDataSetAttributes);

  int GetDataObjectType() override { return VTK_GRAPH; }

  void Initialize() override;


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

  vtkMTimeType GetMTime() override;

  virtual void GetOutEdges(vtkIdType v, vtkOutEdgeIterator* it);

  virtual vtkIdType GetDegree(vtkIdType v);

  virtual vtkIdType GetOutDegree(vtkIdType v);

  virtual vtkOutEdgeType GetOutEdge(vtkIdType v, vtkIdType index);

  virtual void GetOutEdge(vtkIdType v, vtkIdType index, vtkGraphEdge* e);

  virtual void GetInEdges(vtkIdType v, vtkInEdgeIterator* it);

  virtual vtkIdType GetInDegree(vtkIdType v);

  virtual vtkInEdgeType GetInEdge(vtkIdType v, vtkIdType index);

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

  void SetDistributedGraphHelper(vtkDistributedGraphHelper* helper);

  vtkDistributedGraphHelper* GetDistributedGraphHelper();

  vtkIdType FindVertex(const vtkVariant& pedigreeID);

  void ShallowCopy(vtkDataObject* obj) override;

  void DeepCopy(vtkDataObject* obj) override;

  virtual void CopyStructure(vtkGraph* g);

  virtual bool CheckedShallowCopy(vtkGraph* g);

  virtual bool CheckedDeepCopy(vtkGraph* g);

  virtual void Squeeze();

  unsigned long GetActualMemorySize() override;


  static vtkGraph* GetData(vtkInformation* info);
  static vtkGraph* GetData(vtkInformationVector* v, int i = 0);

  void ReorderOutVertices(vtkIdType v, vtkIdTypeArray* vertices);

  bool IsSameStructure(vtkGraph* other);


  vtkIdType GetSourceVertex(vtkIdType e);
  vtkIdType GetTargetVertex(vtkIdType e);


  void SetEdgePoints(vtkIdType e, vtkIdType npts, const double pts[]) VTK_SIZEHINT(pts, 3 * npts);
  void GetEdgePoints(vtkIdType e, vtkIdType& npts, double*& pts) VTK_SIZEHINT(pts, 3 * npts);

  vtkIdType GetNumberOfEdgePoints(vtkIdType e);

  double* GetEdgePoint(vtkIdType e, vtkIdType i) VTK_SIZEHINT(3);

  void ClearEdgePoints(vtkIdType e);

  void SetEdgePoint(vtkIdType e, vtkIdType i, const 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, const 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);

  vtkFieldData* GetAttributesAsFieldData(int type) override;

  vtkIdType GetNumberOfElements(int type) override;

  void Dump();

  vtkIdType GetEdgeId(vtkIdType a, vtkIdType b);

  bool ToDirectedGraph(vtkDirectedGraph* g);

  bool ToUndirectedGraph(vtkUndirectedGraph* g);

protected:
  vtkGraph();
  ~vtkGraph() override;

  void AddVertexInternal(vtkVariantArray* propertyArr = nullptr, vtkIdType* vertex = nullptr);

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

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


  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;


  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;

private:
  vtkGraph(const vtkGraph&) = delete;
  void operator=(const vtkGraph&) = delete;
};

bool VTKCOMMONDATAMODEL_EXPORT operator==(vtkEdgeBase e1, vtkEdgeBase e2);
bool VTKCOMMONDATAMODEL_EXPORT operator!=(vtkEdgeBase e1, vtkEdgeBase e2);
VTKCOMMONDATAMODEL_EXPORT ostream& operator<<(ostream& out, vtkEdgeBase e);

#endif