|  | VTK
    9.0.1
    | 
 
 
 
Go to the documentation of this file.
   30 #ifndef vtkBoostGraphAdapter_h 
   31 #define vtkBoostGraphAdapter_h 
   49 #include <boost/version.hpp> 
   61 struct read_write_property_map_tag;
 
   63 #define vtkPropertyMapMacro(T, V)                                                                  \ 
   65   struct property_traits<T*>                                                                       \ 
   67     typedef V value_type;                                                                          \ 
   68     typedef V reference;                                                                           \ 
   69     typedef vtkIdType key_type;                                                                    \ 
   70     typedef read_write_property_map_tag category;                                                  \ 
   73   inline property_traits<T*>::reference get(T* const& arr, property_traits<T*>::key_type key)      \ 
   75     return arr->GetValue(key);                                                                     \ 
   79     T* arr, property_traits<T*>::key_type key, const property_traits<T*>::value_type& value)       \ 
   81     arr->InsertValue(key, value);                                                                  \ 
  128 #if defined(_MSC_VER) 
  139 #include <boost/config.hpp> 
  140 #include <boost/graph/adjacency_iterator.hpp> 
  141 #include <boost/graph/graph_traits.hpp> 
  142 #include <boost/graph/properties.hpp> 
  143 #include <boost/iterator/iterator_facade.hpp> 
  153   : 
public iterator_facade<vtk_vertex_iterator, vtkIdType, bidirectional_traversal_tag,
 
  154       const vtkIdType&, vtkIdType>
 
  163   const vtkIdType& dereference()
 const { 
return index; }
 
  167   void increment() { index++; }
 
  168   void decrement() { index--; }
 
  176   : 
public iterator_facade<vtk_edge_iterator, vtkEdgeType, forward_traversal_tag,
 
  177       const vtkEdgeType&, vtkIdType>
 
  205       while (vertex < lastVertex && this->graph->
GetOutDegree(vertex) == 0)
 
  210       if (vertex < lastVertex)
 
  251     return vertex == other.vertex && iter == other.iter;
 
  287       while (vertex < lastVertex && this->graph->
GetOutDegree(vertex) == 0)
 
  292       if (vertex < lastVertex)
 
  305   void RecalculateEdge()
 
  325   : 
public iterator_facade<vtk_out_edge_pointer_iterator, vtkEdgeType, bidirectional_traversal_tag,
 
  326       const vtkEdgeType&, ptrdiff_t>
 
  336       g->GetOutEdges(vertex, iter, nedges);
 
  366   void RecalculateEdge()
 
  382   : 
public iterator_facade<vtk_in_edge_pointer_iterator, vtkEdgeType, bidirectional_traversal_tag,
 
  383       const vtkEdgeType&, ptrdiff_t>
 
  393       g->GetInEdges(vertex, iter, nedges);
 
  423   void RecalculateEdge()
 
  445   : 
public virtual bidirectional_graph_tag
 
  446   , 
public virtual edge_list_graph_tag
 
  447   , 
public virtual vertex_list_graph_tag
 
  448   , 
public virtual adjacency_graph_tag
 
  475 #if BOOST_VERSION >= 104500 
  477 struct graph_property_type<
vtkGraph*>
 
  479   typedef no_property 
type;
 
  495 #if BOOST_VERSION >= 104500 
  499   typedef no_property 
type;
 
  553 #if BOOST_VERSION >= 104500 
  556 struct graph_property_type<
vtkDirectedGraph*> : graph_property_type<vtkGraph*>
 
  562 struct graph_property_type<
vtkDirectedGraph* 
const> : graph_property_type<vtkGraph*>
 
  591 #if BOOST_VERSION >= 104500 
  600 struct graph_bundle_type<
vtkDirectedGraph* 
const> : graph_bundle_type<vtkGraph*>
 
  669 #if BOOST_VERSION >= 104500 
  678 struct graph_property_type<
vtkUndirectedGraph* 
const> : graph_property_type<vtkGraph*>
 
  707 #if BOOST_VERSION >= 104500 
  765 #if BOOST_VERSION >= 104500 
  804 #if BOOST_VERSION >= 104500 
  862 #if BOOST_VERSION >= 104500 
  872   : graph_property_type<vtkUndirectedGraph*>
 
  903 #if BOOST_VERSION >= 104500 
  971 inline std::pair<boost::graph_traits<vtkGraph*>::vertex_iterator,
 
  986 inline std::pair<boost::graph_traits<vtkGraph*>::edge_iterator,
 
  994 inline std::pair<boost::graph_traits<vtkGraph*>::out_edge_iterator,
 
  999   std::pair<Iter, Iter> p = std::make_pair(Iter(g, u), Iter(g, u, 
true));
 
 1003 inline std::pair<boost::graph_traits<vtkGraph*>::in_edge_iterator,
 
 1008   std::pair<Iter, Iter> p = std::make_pair(Iter(g, u), Iter(g, u, 
true));
 
 1012 inline std::pair<boost::graph_traits<vtkGraph*>::adjacency_iterator,
 
 1018   std::pair<OutEdgeIter, OutEdgeIter> out = 
out_edges(u, g);
 
 1019   return std::make_pair(Iter(out.first, &g), Iter(out.second, &g));
 
 1056 inline std::pair<boost::graph_traits<vtkMutableDirectedGraph*>::edge_descriptor, 
bool> 
add_edge(
 
 1061   return std::make_pair(e, 
true);
 
 1070 inline std::pair<boost::graph_traits<vtkMutableUndirectedGraph*>::edge_descriptor, 
bool> 
add_edge(
 
 1076   return std::make_pair(e, 
true);
 
 1108 template <
typename PMap>
 
 1125 template <
typename PMap>
 
 1132 template <
typename PMap>
 
 1143 template <
typename PMap>
 
 1160 template <
typename PMap>
 
 1167 template <
typename PMap>
 
 1200 template <
typename PMap>
 
 1217 template <
typename PMap>
 
 1224 template <
typename PMap>
 
 1304 #if BOOST_VERSION > 104000 
 1305 #include <boost/property_map/vector_property_map.hpp> 
 1307 #include <boost/vector_property_map.hpp> 
 1310 #endif // vtkBoostGraphAdapter_h 
  
static edge_descriptor null_edge()
void remove_edge(graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *g)
virtual vtkVariant GetVariantValue(vtkIdType valueIdx)
Retrieve value from the array as a variant.
An editable directed graph.
boost::graph_traits< vtkGraph * >::degree_size_type degree(boost::graph_traits< vtkGraph * >::vertex_descriptor u, vtkGraph *g)
void put(vtkGraphPropertyMapMultiplier< PMap > multi, const typename property_traits< PMap >::key_type &key, const typename property_traits< PMap >::value_type &value)
helper for the vtkGraph class that allows the graph to be distributed across multiple memory spaces.
vtkEdgeType AddEdge(vtkIdType u, vtkIdType v)
Adds a directed edge from u to v, where u and v are vertex indices, and returns a vtkEdgeType structu...
vtkDistributedGraphHelper * GetDistributedGraphHelper()
Retrieves the distributed graph helper for this graph.
reference operator[](const key_type &key) const
friend class iterator_core_access
An editable undirected graph.
vtkGraphEdgePropertyMapHelper(PMap m)
void SetTuple1(vtkIdType tupleIdx, double value)
These methods are included as convenience for the wrappers.
vtkGraphVertexPropertyMapHelper(PMap m)
vtk_edge_iterator(vtkGraph *g=0, vtkIdType v=0)
read_write_property_map_tag category
property_traits< PMap >::category category
dynamic, self-adjusting array of float
read_write_property_map_tag category
virtual vtkIdType GetNumberOfVertices()
The number of vertices in the graph.
vtkGraphPropertyMapMultiplier(PMap m, float multi=1)
property_traits< PMap >::value_type value_type
boost::graph_traits< vtkGraph * >::edges_size_type num_edges(vtkGraph *g)
boost::graph_traits< vtkMutableDirectedGraph * >::vertex_descriptor add_vertex(vtkMutableDirectedGraph *g)
Forward declaration required for Boost serialization.
virtual vtkIdType GetNumberOfEdges()
The number of edges in the graph.
friend class iterator_core_access
abstract superclass for arrays of numeric data
void put(vtkDataArray *arr, vtkIdType key, const double &value)
bool has_no_edges(vtkGraph *g)
virtual void InsertVariantValue(vtkIdType valueIdx, vtkVariant value)=0
Insert a value into the array from a variant.
property_traits< PMap >::category category
boost::graph_traits< vtkDirectedGraph * >::degree_size_type in_degree(boost::graph_traits< vtkDirectedGraph * >::vertex_descriptor u, vtkDirectedGraph *g)
property_traits< PMap >::key_type key_type
property_traits< PMap >::category category
A rooted tree data structure.
vtkEdgeType AddEdge(vtkIdType u, vtkIdType v)
Adds an undirected edge from u to v, where u and v are vertex indices, and returns a vtkEdgeType stru...
boost::graph_traits< vtkGraph * >::vertex_descriptor target(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
undirected_tag directed_category
property_traits< PMap >::reference reference
directed_tag directed_category
vtkIdType GetVertexOwner(vtkIdType v) const
Returns owner of vertex v, by extracting top ceil(log2 P) bits of v.
vtk_in_edge_pointer_iterator(vtkGraph *g=0, vtkIdType v=0, bool end=false)
vtk_vertex_iterator vertex_iterator
virtual vtkIdType GetOutDegree(vtkIdType v)
The number of outgoing edges from vertex v.
static vtkMutableUndirectedGraph * SafeDownCast(vtkObjectBase *o)
virtual vtkIdType GetInDegree(vtkIdType v)
The number of incoming edges to vertex v.
double get(vtkDataArray *const &arr, vtkIdType key)
static vtkInformationIntegerKey * DATA_PIECE_NUMBER()
property_traits< PMap >::reference reference
void RemoveEdge(vtkIdType e)
Removes the edge from the graph.
readable_property_map_tag category
virtual vtkIdType GetDegree(vtkIdType v)
The total of all incoming and outgoing vertices for vertex v.
vtkGraphIndexMap get(edge_index_t, vtkGraph *)
reference operator[](const key_type &key) const
dynamic, self-adjusting array of int
std::pair< boost::graph_traits< vtkGraph * >::out_edge_iterator, boost::graph_traits< vtkGraph * >::out_edge_iterator > out_edges(boost::graph_traits< vtkGraph * >::vertex_descriptor u, vtkGraph *g)
vtkIdType AddVertex()
Adds a vertex to the graph and returns the index of the new vertex.
A atomic type representing the union of many types.
boost::graph_traits< vtkGraph * >::degree_size_type out_degree(boost::graph_traits< vtkGraph * >::vertex_descriptor u, vtkGraph *g)
vtkIdType MakeDistributedId(int owner, vtkIdType local)
Builds a distributed ID consisting of the given owner and the local ID.
std::pair< boost::graph_traits< vtkMutableDirectedGraph * >::edge_descriptor, bool > add_edge(boost::graph_traits< vtkMutableDirectedGraph * >::vertex_descriptor u, boost::graph_traits< vtkMutableDirectedGraph * >::vertex_descriptor v, vtkMutableDirectedGraph *g)
vtkGraphIndexMap const_type
vtk_out_edge_pointer_iterator(vtkGraph *g=0, vtkIdType v=0, bool end=false)
vtk_vertex_iterator(vtkIdType i=0)
vtk_in_edge_pointer_iterator in_edge_iterator
Abstract superclass for all arrays.
vtk_out_edge_pointer_iterator out_edge_iterator
virtual void GetOutEdges(vtkIdType v, vtkOutEdgeIterator *it)
Initializes the out edge iterator to iterate over all outgoing edges of vertex v.
property_traits< PMap >::value_type value_type
vtkIdType vertices_size_type
vtkEdgeType edge_descriptor
property_traits< PMap >::value_type value_type
dynamic, self-adjusting array of vtkIdType
virtual vtkInformation * GetInformation()
Set/Get the information object associated with this data object.
std::pair< boost::graph_traits< vtkGraph * >::in_edge_iterator, boost::graph_traits< vtkGraph * >::in_edge_iterator > in_edges(boost::graph_traits< vtkGraph * >::vertex_descriptor u, vtkGraph *g)
static vtkDirectedGraph * SafeDownCast(vtkObjectBase *o)
void RemoveEdge(vtkIdType e)
Removes the edge from the graph.
vtkIdType edges_size_type
vtkGraphIndexMap const_type
std::pair< boost::graph_traits< vtkGraph * >::adjacency_iterator, boost::graph_traits< vtkGraph * >::adjacency_iterator > adjacent_vertices(boost::graph_traits< vtkGraph * >::vertex_descriptor u, vtkGraph *g)
vtkIdType degree_size_type
std::pair< boost::graph_traits< vtkGraph * >::edge_iterator, boost::graph_traits< vtkGraph * >::edge_iterator > edges(vtkGraph *g)
static vertex_descriptor null_vertex()
dynamic, self-adjusting array of double
vtkIdType vertex_descriptor
static vtkMutableDirectedGraph * SafeDownCast(vtkObjectBase *o)
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
friend class iterator_core_access
std::pair< boost::graph_traits< vtkGraph * >::vertex_iterator, boost::graph_traits< vtkGraph * >::vertex_iterator > vertices(vtkGraph *g)
vtkGraph_traversal_category traversal_category
Base class for graph data types.
vtkIdType GetEdgeOwner(vtkIdType e_id) const
Returns owner of edge with ID e_id, by extracting top ceil(log2 P) bits of e_id.
readable_property_map_tag category
vtk_edge_iterator edge_iterator
vtkIdType AddVertex()
Adds a vertex to the graph and returns the index of the new vertex.
property_traits< PMap >::reference reference
friend class iterator_core_access
double GetTuple1(vtkIdType tupleIdx)
These methods are included as convenience for the wrappers.
allow_parallel_edge_tag edge_parallel_category
vtkPropertyMapMacro(vtkIntArray, int)
boost::graph_traits< vtkGraph * >::vertices_size_type num_vertices(vtkGraph *g)
adjacency_iterator_generator< vtkGraph *, vertex_descriptor, out_edge_iterator >::type adjacency_iterator