dox/Filtering/vtkGraph.h

Go to the documentation of this file.

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

  Program:   Visualization Toolkit
  Module:    $RCSfile: vtkGraph.h,v $

  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 "vtkDataObject.h"

class vtkAdjacentVertexIterator;
class vtkEdgeListIterator;
class vtkDataSetAttributes;
class vtkGraphInternals;
class vtkIdTypeArray;
class vtkInEdgeIterator;
class vtkOutEdgeIterator;
class vtkPoints;
class vtkVertexListIterator;

//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 VTK_FILTERING_EXPORT vtkGraph : public vtkDataObject
{
public:
  vtkTypeRevisionMacro(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);
  
  virtual void GetInEdges(vtkIdType v, vtkInEdgeIterator *it);
  
  virtual vtkIdType GetInDegree(vtkIdType v);

  virtual void GetAdjacentVertices(vtkIdType v, vtkAdjacentVertexIterator *it);

  virtual void GetEdges(vtkEdgeListIterator *it);
  
  virtual vtkIdType GetNumberOfEdges();

  virtual void GetVertices(vtkVertexListIterator *it);
  
  virtual vtkIdType GetNumberOfVertices();

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

protected:
  //BTX
  vtkGraph();
  ~vtkGraph();

  vtkIdType AddVertexInternal();

  vtkEdgeType AddEdgeInternal(vtkIdType u, vtkIdType v, bool directed);

  virtual bool IsStructureValid(vtkGraph *g) = 0;

  virtual void CopyInternal(vtkGraph *g, bool deep);

  vtkGraphInternals *Internals;

  void SetInternals(vtkGraphInternals* internals);

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


  vtkIdTypeArray *EdgeList;
  //ETX
private:
  vtkGraph(const vtkGraph&);  // Not implemented.
  void operator=(const vtkGraph&);  // Not implemented.
};

//BTX
bool VTK_FILTERING_EXPORT operator==(vtkEdgeBase e1, vtkEdgeBase e2);
bool VTK_FILTERING_EXPORT operator!=(vtkEdgeBase e1, vtkEdgeBase e2);
VTK_FILTERING_EXPORT ostream& operator<<(ostream& out, vtkEdgeBase e);
//ETX

#endif

---