VTK  9.0.20210919
vtkBoostGraphAdapter.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkBoostGraphAdapter.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 /*-------------------------------------------------------------------------
16  Copyright 2008 Sandia Corporation.
17  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
18  the U.S. Government retains certain rights in this software.
19 -------------------------------------------------------------------------*/
69 #ifndef vtkBoostGraphAdapter_h
70 #define vtkBoostGraphAdapter_h
71 
72 #include "vtkAbstractArray.h"
73 #include "vtkDataArray.h"
74 #include "vtkDataObject.h"
75 #include "vtkDirectedGraph.h"
77 #include "vtkDoubleArray.h"
78 #include "vtkFloatArray.h"
79 #include "vtkIdTypeArray.h"
80 #include "vtkInformation.h"
81 #include "vtkIntArray.h"
84 #include "vtkTree.h"
85 #include "vtkUndirectedGraph.h"
86 #include "vtkVariant.h"
87 
88 #include <boost/version.hpp>
89 
90 namespace boost
91 {
92 //===========================================================================
93 // VTK arrays as property maps
94 // These need to be defined before including other boost stuff
95 
96 // Forward declarations are required here, so that we aren't forced
97 // to include boost/property_map.hpp.
98 template <typename>
100 struct read_write_property_map_tag;
101 
102 #define vtkPropertyMapMacro(T, V) \
103  template <> \
104  struct property_traits<T*> \
105  { \
106  typedef V value_type; \
107  typedef V reference; \
108  typedef vtkIdType key_type; \
109  typedef read_write_property_map_tag category; \
110  }; \
111  \
112  inline property_traits<T*>::reference get(T* const& arr, property_traits<T*>::key_type key) \
113  { \
114  return arr->GetValue(key); \
115  } \
116  \
117  inline void put( \
118  T* arr, property_traits<T*>::key_type key, const property_traits<T*>::value_type& value) \
119  { \
120  arr->InsertValue(key, value); \
121  }
122 
127 
128 // vtkDataArray
129 template <>
131 {
132  typedef double value_type;
133  typedef double reference;
135  typedef read_write_property_map_tag category;
136 };
137 
138 inline double get(vtkDataArray* const& arr, vtkIdType key)
139 {
140  return arr->GetTuple1(key);
141 }
142 
143 inline void put(vtkDataArray* arr, vtkIdType key, const double& value)
144 {
145  arr->SetTuple1(key, value);
146 }
147 
148 // vtkAbstractArray as a property map of vtkVariants
149 template <>
151 {
155  typedef read_write_property_map_tag category;
156 };
157 
159 {
160  return arr->GetVariantValue(key);
161 }
162 
163 inline void put(vtkAbstractArray* arr, vtkIdType key, const vtkVariant& value)
164 {
166 }
167 #if defined(_MSC_VER)
168 namespace detail
169 {
172 }
173 #endif
174 }
175 
176 #include <utility> // STL Header
177 
178 #include <boost/config.hpp>
179 #include <boost/graph/adjacency_iterator.hpp>
180 #include <boost/graph/graph_traits.hpp>
181 #include <boost/graph/properties.hpp>
182 #include <boost/iterator/iterator_facade.hpp>
183 
184 // The functions and classes in this file allows the user to
185 // treat a vtkDirectedGraph or vtkUndirectedGraph object
186 // as a boost graph "as is".
187 
188 namespace boost
189 {
190 
192  : public iterator_facade<vtk_vertex_iterator, vtkIdType, bidirectional_traversal_tag,
193  const vtkIdType&, vtkIdType>
194 {
195 public:
197  : index(i)
198  {
199  }
200 
201 private:
202  const vtkIdType& dereference() const { return index; }
203 
204  bool equal(const vtk_vertex_iterator& other) const { return index == other.index; }
205 
206  void increment() { index++; }
207  void decrement() { index--; }
208 
209  vtkIdType index;
210 
211  friend class iterator_core_access;
212 };
213 
215  : public iterator_facade<vtk_edge_iterator, vtkEdgeType, forward_traversal_tag,
216  const vtkEdgeType&, vtkIdType>
217 {
218 public:
219  explicit vtk_edge_iterator(vtkGraph* g = 0, vtkIdType v = 0)
220  : directed(false)
221  , vertex(v)
222  , lastVertex(v)
223  , iter(nullptr)
224  , end(nullptr)
225  , graph(g)
226  {
227  if (graph)
228  {
229  lastVertex = graph->GetNumberOfVertices();
230  }
231 
232  vtkIdType myRank = -1;
233  vtkDistributedGraphHelper* helper = this->graph ? this->graph->GetDistributedGraphHelper() : 0;
234  if (helper)
235  {
236  myRank = this->graph->GetInformation()->Get(vtkDataObject::DATA_PIECE_NUMBER());
237  vertex = helper->MakeDistributedId(myRank, vertex);
238  lastVertex = helper->MakeDistributedId(myRank, lastVertex);
239  }
240 
241  if (graph != 0)
242  {
243  directed = (vtkDirectedGraph::SafeDownCast(graph) != 0);
244  while (vertex < lastVertex && this->graph->GetOutDegree(vertex) == 0)
245  {
246  ++vertex;
247  }
248 
249  if (vertex < lastVertex)
250  {
251  // Get the outgoing edges of the first vertex that has outgoing
252  // edges
253  vtkIdType nedges;
254  graph->GetOutEdges(vertex, iter, nedges);
255  if (iter)
256  {
257  end = iter + nedges;
258 
259  if (!directed)
260  {
261  while ( // Skip non-local edges
262  (helper && helper->GetEdgeOwner(iter->Id) != myRank)
263  // Skip entirely-local edges where Source > Target
264  || (((helper && myRank == helper->GetVertexOwner(iter->Target)) || !helper) &&
265  vertex > iter->Target))
266  {
267  this->inc();
268  }
269  }
270  }
271  }
272  else
273  {
274  iter = nullptr;
275  }
276  }
277 
278  RecalculateEdge();
279  }
280 
281 private:
282  const vtkEdgeType& dereference() const
283  {
284  assert(iter);
285  return edge;
286  }
287 
288  bool equal(const vtk_edge_iterator& other) const
289  {
290  return vertex == other.vertex && iter == other.iter;
291  }
292 
293  void increment()
294  {
295  inc();
296  if (!directed)
297  {
298  vtkIdType myRank = -1;
299  vtkDistributedGraphHelper* helper =
300  this->graph ? this->graph->GetDistributedGraphHelper() : 0;
301  if (helper)
302  {
303  myRank = this->graph->GetInformation()->Get(vtkDataObject::DATA_PIECE_NUMBER());
304  }
305 
306  while (iter != 0 &&
307  ( // Skip non-local edges
308  (helper && helper->GetEdgeOwner(iter->Id) != myRank)
309  // Skip entirely-local edges where Source > Target
310  || (((helper && myRank == helper->GetVertexOwner(iter->Target)) || !helper) &&
311  vertex > iter->Target)))
312  {
313  inc();
314  }
315  }
316  RecalculateEdge();
317  }
318 
319  void inc()
320  {
321  ++iter;
322  if (iter == end)
323  {
324  // Find a vertex with nonzero out degree.
325  ++vertex;
326  while (vertex < lastVertex && this->graph->GetOutDegree(vertex) == 0)
327  {
328  ++vertex;
329  }
330 
331  if (vertex < lastVertex)
332  {
333  vtkIdType nedges;
334  graph->GetOutEdges(vertex, iter, nedges);
335  end = iter + nedges;
336  }
337  else
338  {
339  iter = nullptr;
340  }
341  }
342  }
343 
344  void RecalculateEdge()
345  {
346  if (iter)
347  {
348  edge = vtkEdgeType(vertex, iter->Target, iter->Id);
349  }
350  }
351 
352  bool directed;
353  vtkIdType vertex;
354  vtkIdType lastVertex;
355  const vtkOutEdgeType* iter;
356  const vtkOutEdgeType* end;
357  vtkGraph* graph;
358  vtkEdgeType edge;
359 
360  friend class iterator_core_access;
361 };
362 
364  : public iterator_facade<vtk_out_edge_pointer_iterator, vtkEdgeType, bidirectional_traversal_tag,
365  const vtkEdgeType&, ptrdiff_t>
366 {
367 public:
368  explicit vtk_out_edge_pointer_iterator(vtkGraph* g = 0, vtkIdType v = 0, bool end = false)
369  : vertex(v)
370  , iter(nullptr)
371  {
372  if (g)
373  {
374  vtkIdType nedges;
375  g->GetOutEdges(vertex, iter, nedges);
376  if (end)
377  {
378  iter += nedges;
379  }
380  }
381  RecalculateEdge();
382  }
383 
384 private:
385  const vtkEdgeType& dereference() const
386  {
387  assert(iter);
388  return edge;
389  }
390 
391  bool equal(const vtk_out_edge_pointer_iterator& other) const { return iter == other.iter; }
392 
393  void increment()
394  {
395  iter++;
396  RecalculateEdge();
397  }
398 
399  void decrement()
400  {
401  iter--;
402  RecalculateEdge();
403  }
404 
405  void RecalculateEdge()
406  {
407  if (iter)
408  {
409  edge = vtkEdgeType(vertex, iter->Target, iter->Id);
410  }
411  }
412 
413  vtkIdType vertex;
414  const vtkOutEdgeType* iter;
415  vtkEdgeType edge;
416 
417  friend class iterator_core_access;
418 };
419 
421  : public iterator_facade<vtk_in_edge_pointer_iterator, vtkEdgeType, bidirectional_traversal_tag,
422  const vtkEdgeType&, ptrdiff_t>
423 {
424 public:
425  explicit vtk_in_edge_pointer_iterator(vtkGraph* g = 0, vtkIdType v = 0, bool end = false)
426  : vertex(v)
427  , iter(nullptr)
428  {
429  if (g)
430  {
431  vtkIdType nedges;
432  g->GetInEdges(vertex, iter, nedges);
433  if (end)
434  {
435  iter += nedges;
436  }
437  }
438  RecalculateEdge();
439  }
440 
441 private:
442  const vtkEdgeType& dereference() const
443  {
444  assert(iter);
445  return edge;
446  }
447 
448  bool equal(const vtk_in_edge_pointer_iterator& other) const { return iter == other.iter; }
449 
450  void increment()
451  {
452  iter++;
453  RecalculateEdge();
454  }
455 
456  void decrement()
457  {
458  iter--;
459  RecalculateEdge();
460  }
461 
462  void RecalculateEdge()
463  {
464  if (iter)
465  {
466  edge = vtkEdgeType(iter->Source, vertex, iter->Id);
467  }
468  }
469 
470  vtkIdType vertex;
471  const vtkInEdgeType* iter;
472  vtkEdgeType edge;
473 
474  friend class iterator_core_access;
475 };
476 
477 //===========================================================================
478 // vtkGraph
479 // VertexAndEdgeListGraphConcept
480 // BidirectionalGraphConcept
481 // AdjacencyGraphConcept
482 
484  : public virtual bidirectional_graph_tag
485  , public virtual edge_list_graph_tag
486  , public virtual vertex_list_graph_tag
487  , public virtual adjacency_graph_tag
488 {
489 };
490 
491 template <>
492 struct graph_traits<vtkGraph*>
493 {
495  static vertex_descriptor null_vertex() { return -1; }
497  static edge_descriptor null_edge() { return vtkEdgeType(-1, -1, -1); }
500 
503 
504  typedef allow_parallel_edge_tag edge_parallel_category;
509 
512 };
513 
514 #if BOOST_VERSION >= 104500
515 template <>
516 struct graph_property_type<vtkGraph*>
517 {
518  typedef no_property type;
519 };
520 #endif
521 
522 template <>
523 struct vertex_property_type<vtkGraph*>
524 {
525  typedef no_property type;
526 };
527 
528 template <>
529 struct edge_property_type<vtkGraph*>
530 {
531  typedef no_property type;
532 };
533 
534 #if BOOST_VERSION >= 104500
535 template <>
536 struct graph_bundle_type<vtkGraph*>
537 {
538  typedef no_property type;
539 };
540 #endif
541 
542 template <>
543 struct vertex_bundle_type<vtkGraph*>
544 {
545  typedef no_property type;
546 };
547 
548 template <>
549 struct edge_bundle_type<vtkGraph*>
550 {
551  typedef no_property type;
552 };
553 
554 inline bool has_no_edges(vtkGraph* g)
555 {
556  return ((g->GetNumberOfEdges() > 0) ? false : true);
557 }
558 
560 {
562  {
564  }
566  {
568  }
569 }
570 
571 //===========================================================================
572 // vtkDirectedGraph
573 
574 template <>
576 {
577  typedef directed_tag directed_category;
578 };
579 
580 // The graph_traits for a const graph are the same as a non-const graph.
581 template <>
583 {
584 };
585 
586 // The graph_traits for a const graph are the same as a non-const graph.
587 template <>
589 {
590 };
591 
592 #if BOOST_VERSION >= 104500
593 // Internal graph properties
594 template <>
595 struct graph_property_type<vtkDirectedGraph*> : graph_property_type<vtkGraph*>
596 {
597 };
598 
599 // Internal graph properties
600 template <>
601 struct graph_property_type<vtkDirectedGraph* const> : graph_property_type<vtkGraph*>
602 {
603 };
604 #endif
605 
606 // Internal vertex properties
607 template <>
608 struct vertex_property_type<vtkDirectedGraph*> : vertex_property_type<vtkGraph*>
609 {
610 };
611 
612 // Internal vertex properties
613 template <>
614 struct vertex_property_type<vtkDirectedGraph* const> : vertex_property_type<vtkGraph*>
615 {
616 };
617 
618 // Internal edge properties
619 template <>
620 struct edge_property_type<vtkDirectedGraph*> : edge_property_type<vtkGraph*>
621 {
622 };
623 
624 // Internal edge properties
625 template <>
626 struct edge_property_type<vtkDirectedGraph* const> : edge_property_type<vtkGraph*>
627 {
628 };
629 
630 #if BOOST_VERSION >= 104500
631 // Internal graph properties
632 template <>
633 struct graph_bundle_type<vtkDirectedGraph*> : graph_bundle_type<vtkGraph*>
634 {
635 };
636 
637 // Internal graph properties
638 template <>
639 struct graph_bundle_type<vtkDirectedGraph* const> : graph_bundle_type<vtkGraph*>
640 {
641 };
642 #endif
643 
644 // Internal vertex properties
645 template <>
646 struct vertex_bundle_type<vtkDirectedGraph*> : vertex_bundle_type<vtkGraph*>
647 {
648 };
649 
650 // Internal vertex properties
651 template <>
652 struct vertex_bundle_type<vtkDirectedGraph* const> : vertex_bundle_type<vtkGraph*>
653 {
654 };
655 
656 // Internal edge properties
657 template <>
659 {
660 };
661 
662 // Internal edge properties
663 template <>
664 struct edge_bundle_type<vtkDirectedGraph* const> : edge_bundle_type<vtkGraph*>
665 {
666 };
667 
668 //===========================================================================
669 // vtkTree
670 
671 template <>
673 {
674 };
675 
676 // The graph_traits for a const graph are the same as a non-const graph.
677 template <>
678 struct graph_traits<const vtkTree*> : graph_traits<vtkTree*>
679 {
680 };
681 
682 // The graph_traits for a const graph are the same as a non-const graph.
683 template <>
684 struct graph_traits<vtkTree* const> : graph_traits<vtkTree*>
685 {
686 };
687 
688 //===========================================================================
689 // vtkUndirectedGraph
690 template <>
692 {
693  typedef undirected_tag directed_category;
694 };
695 
696 // The graph_traits for a const graph are the same as a non-const graph.
697 template <>
699 {
700 };
701 
702 // The graph_traits for a const graph are the same as a non-const graph.
703 template <>
705 {
706 };
707 
708 #if BOOST_VERSION >= 104500
709 // Internal graph properties
710 template <>
711 struct graph_property_type<vtkUndirectedGraph*> : graph_property_type<vtkGraph*>
712 {
713 };
714 
715 // Internal graph properties
716 template <>
717 struct graph_property_type<vtkUndirectedGraph* const> : graph_property_type<vtkGraph*>
718 {
719 };
720 #endif
721 
722 // Internal vertex properties
723 template <>
725 {
726 };
727 
728 // Internal vertex properties
729 template <>
730 struct vertex_property_type<vtkUndirectedGraph* const> : vertex_property_type<vtkGraph*>
731 {
732 };
733 
734 // Internal edge properties
735 template <>
737 {
738 };
739 
740 // Internal edge properties
741 template <>
742 struct edge_property_type<vtkUndirectedGraph* const> : edge_property_type<vtkGraph*>
743 {
744 };
745 
746 #if BOOST_VERSION >= 104500
747 // Internal graph properties
748 template <>
749 struct graph_bundle_type<vtkUndirectedGraph*> : graph_bundle_type<vtkGraph*>
750 {
751 };
752 
753 // Internal graph properties
754 template <>
755 struct graph_bundle_type<vtkUndirectedGraph* const> : graph_bundle_type<vtkGraph*>
756 {
757 };
758 #endif
759 
760 // Internal vertex properties
761 template <>
763 {
764 };
765 
766 // Internal vertex properties
767 template <>
768 struct vertex_bundle_type<vtkUndirectedGraph* const> : vertex_bundle_type<vtkGraph*>
769 {
770 };
771 
772 // Internal edge properties
773 template <>
775 {
776 };
777 
778 // Internal edge properties
779 template <>
780 struct edge_bundle_type<vtkUndirectedGraph* const> : edge_bundle_type<vtkGraph*>
781 {
782 };
783 
784 //===========================================================================
785 // vtkMutableDirectedGraph
786 
787 template <>
789 {
790 };
791 
792 // The graph_traits for a const graph are the same as a non-const graph.
793 template <>
795 {
796 };
797 
798 // The graph_traits for a const graph are the same as a non-const graph.
799 template <>
801 {
802 };
803 
804 #if BOOST_VERSION >= 104500
805 // Internal graph properties
806 template <>
807 struct graph_property_type<vtkMutableDirectedGraph*> : graph_property_type<vtkDirectedGraph*>
808 {
809 };
810 
811 // Internal graph properties
812 template <>
813 struct graph_property_type<vtkMutableDirectedGraph* const> : graph_property_type<vtkDirectedGraph*>
814 {
815 };
816 #endif
817 
818 // Internal vertex properties
819 template <>
821 {
822 };
823 
824 // Internal vertex properties
825 template <>
826 struct vertex_property_type<vtkMutableDirectedGraph* const>
828 {
829 };
830 
831 // Internal edge properties
832 template <>
834 {
835 };
836 
837 // Internal edge properties
838 template <>
840 {
841 };
842 
843 #if BOOST_VERSION >= 104500
844 // Internal graph properties
845 template <>
846 struct graph_bundle_type<vtkMutableDirectedGraph*> : graph_bundle_type<vtkDirectedGraph*>
847 {
848 };
849 
850 // Internal graph properties
851 template <>
852 struct graph_bundle_type<vtkMutableDirectedGraph* const> : graph_bundle_type<vtkDirectedGraph*>
853 {
854 };
855 #endif
856 
857 // Internal vertex properties
858 template <>
860 {
861 };
862 
863 // Internal vertex properties
864 template <>
866 {
867 };
868 
869 // Internal edge properties
870 template <>
872 {
873 };
874 
875 // Internal edge properties
876 template <>
878 {
879 };
880 
881 //===========================================================================
882 // vtkMutableUndirectedGraph
883 
884 template <>
886 {
887 };
888 
889 // The graph_traits for a const graph are the same as a non-const graph.
890 template <>
892 {
893 };
894 
895 // The graph_traits for a const graph are the same as a non-const graph.
896 template <>
898 {
899 };
900 
901 #if BOOST_VERSION >= 104500
902 // Internal graph properties
903 template <>
904 struct graph_property_type<vtkMutableUndirectedGraph*> : graph_property_type<vtkUndirectedGraph*>
905 {
906 };
907 
908 // Internal graph properties
909 template <>
910 struct graph_property_type<vtkMutableUndirectedGraph* const>
911  : graph_property_type<vtkUndirectedGraph*>
912 {
913 };
914 #endif
915 
916 // Internal vertex properties
917 template <>
919 {
920 };
921 
922 // Internal vertex properties
923 template <>
924 struct vertex_property_type<vtkMutableUndirectedGraph* const>
926 {
927 };
928 
929 // Internal edge properties
930 template <>
932 {
933 };
934 
935 // Internal edge properties
936 template <>
937 struct edge_property_type<vtkMutableUndirectedGraph* const>
939 {
940 };
941 
942 #if BOOST_VERSION >= 104500
943 // Internal graph properties
944 template <>
945 struct graph_bundle_type<vtkMutableUndirectedGraph*> : graph_bundle_type<vtkUndirectedGraph*>
946 {
947 };
948 
949 // Internal graph properties
950 template <>
951 struct graph_bundle_type<vtkMutableUndirectedGraph* const> : graph_bundle_type<vtkUndirectedGraph*>
952 {
953 };
954 #endif
955 
956 // Internal vertex properties
957 template <>
959 {
960 };
961 
962 // Internal vertex properties
963 template <>
964 struct vertex_bundle_type<vtkMutableUndirectedGraph* const>
966 {
967 };
968 
969 // Internal edge properties
970 template <>
972 {
973 };
974 
975 // Internal edge properties
976 template <>
978 {
979 };
980 
981 //===========================================================================
982 // API implementation
983 template <>
984 class vertex_property<vtkGraph*>
985 {
986 public:
987  typedef vtkIdType type;
988 };
989 
990 template <>
991 class edge_property<vtkGraph*>
992 {
993 public:
994  typedef vtkIdType type;
995 };
996 } // end namespace boost
997 
1000 {
1001  return e.Source;
1002 }
1003 
1006 {
1007  return e.Target;
1008 }
1009 
1010 inline std::pair<boost::graph_traits<vtkGraph*>::vertex_iterator,
1013 {
1015  vtkIdType start = 0;
1017  {
1019  start = helper->MakeDistributedId(rank, start);
1020  }
1021 
1022  return std::make_pair(Iter(start), Iter(start + g->GetNumberOfVertices()));
1023 }
1024 
1025 inline std::pair<boost::graph_traits<vtkGraph*>::edge_iterator,
1028 {
1030  return std::make_pair(Iter(g), Iter(g, g->GetNumberOfVertices()));
1031 }
1032 
1033 inline std::pair<boost::graph_traits<vtkGraph*>::out_edge_iterator,
1036 {
1038  std::pair<Iter, Iter> p = std::make_pair(Iter(g, u), Iter(g, u, true));
1039  return p;
1040 }
1041 
1042 inline std::pair<boost::graph_traits<vtkGraph*>::in_edge_iterator,
1045 {
1047  std::pair<Iter, Iter> p = std::make_pair(Iter(g, u), Iter(g, u, true));
1048  return p;
1049 }
1050 
1051 inline std::pair<boost::graph_traits<vtkGraph*>::adjacency_iterator,
1054 {
1057  std::pair<OutEdgeIter, OutEdgeIter> out = out_edges(u, g);
1058  return std::make_pair(Iter(out.first, &g), Iter(out.second, &g));
1059 }
1060 
1062 {
1063  return g->GetNumberOfVertices();
1064 }
1065 
1067 {
1068  return g->GetNumberOfEdges();
1069 }
1070 
1073 {
1074  return g->GetOutDegree(u);
1075 }
1076 
1079 {
1080  return g->GetInDegree(u);
1081 }
1082 
1085 {
1086  return g->GetDegree(u);
1087 }
1088 
1091 {
1092  return g->AddVertex();
1093 }
1094 
1095 inline std::pair<boost::graph_traits<vtkMutableDirectedGraph*>::edge_descriptor, bool> add_edge(
1098 {
1100  return std::make_pair(e, true);
1101 }
1102 
1105 {
1106  return g->AddVertex();
1107 }
1108 
1109 inline std::pair<boost::graph_traits<vtkMutableUndirectedGraph*>::edge_descriptor, bool> add_edge(
1113 {
1115  return std::make_pair(e, true);
1116 }
1117 
1118 namespace boost
1119 {
1120 //===========================================================================
1121 // An edge map for vtkGraph.
1122 // This is a common input needed for algorithms.
1123 
1125 {
1126 };
1127 
1128 template <>
1130 {
1134  typedef readable_property_map_tag category;
1135 };
1136 
1139 {
1140  return key.Id;
1141 }
1142 
1143 //===========================================================================
1144 // Helper for vtkGraph edge property maps
1145 // Automatically converts boost edge ids to vtkGraph edge ids.
1146 
1147 template <typename PMap>
1149 {
1150 public:
1152  : pmap(m)
1153  {
1154  }
1155  PMap pmap;
1160 
1161  reference operator[](const key_type& key) const { return get(pmap, key.Id); }
1162 };
1163 
1164 template <typename PMap>
1167 {
1168  return get(helper.pmap, key.Id);
1169 }
1170 
1171 template <typename PMap>
1173  const typename property_traits<PMap>::value_type& value)
1174 {
1175  put(helper.pmap, key.Id, value);
1176 }
1177 
1178 //===========================================================================
1179 // Helper for vtkGraph vertex property maps
1180 // Automatically converts boost vertex ids to vtkGraph vertex ids.
1181 
1182 template <typename PMap>
1184 {
1185 public:
1187  : pmap(m)
1188  {
1189  }
1190  PMap pmap;
1195 
1196  reference operator[](const key_type& key) const { return get(pmap, key); }
1197 };
1198 
1199 template <typename PMap>
1202 {
1203  return get(helper.pmap, key);
1204 }
1205 
1206 template <typename PMap>
1208  const typename property_traits<PMap>::value_type& value)
1209 {
1210  put(helper.pmap, key, value);
1211 }
1212 
1213 //===========================================================================
1214 // An index map for vtkGraph
1215 // This is a common input needed for algorithms
1216 
1218 {
1219 };
1220 
1221 template <>
1223 {
1227  typedef readable_property_map_tag category;
1228 };
1229 
1232 {
1233  return key;
1234 }
1235 
1236 //===========================================================================
1237 // Helper for vtkGraph property maps
1238 // Automatically multiplies the property value by some value (default 1)
1239 template <typename PMap>
1241 {
1242 public:
1243  vtkGraphPropertyMapMultiplier(PMap m, float multi = 1)
1244  : pmap(m)
1245  , multiplier(multi)
1246  {
1247  }
1248  PMap pmap;
1249  float multiplier;
1254 };
1255 
1256 template <typename PMap>
1259 {
1260  return multi.multiplier * get(multi.pmap, key);
1261 }
1262 
1263 template <typename PMap>
1265  const typename property_traits<PMap>::key_type& key,
1266  const typename property_traits<PMap>::value_type& value)
1267 {
1268  put(multi.pmap, key, value);
1269 }
1270 
1271 // Allow algorithms to automatically extract vtkGraphIndexMap from a
1272 // VTK graph
1273 template <>
1274 struct property_map<vtkGraph*, vertex_index_t>
1275 {
1278 };
1279 
1280 template <>
1281 struct property_map<vtkDirectedGraph*, vertex_index_t> : property_map<vtkGraph*, vertex_index_t>
1282 {
1283 };
1284 
1285 template <>
1286 struct property_map<vtkUndirectedGraph*, vertex_index_t> : property_map<vtkGraph*, vertex_index_t>
1287 {
1288 };
1289 
1290 inline vtkGraphIndexMap get(vertex_index_t, vtkGraph*)
1291 {
1292  return vtkGraphIndexMap();
1293 }
1294 
1295 template <>
1296 struct property_map<vtkGraph*, edge_index_t>
1297 {
1300 };
1301 
1302 template <>
1303 struct property_map<vtkDirectedGraph*, edge_index_t> : property_map<vtkGraph*, edge_index_t>
1304 {
1305 };
1306 
1307 template <>
1308 struct property_map<vtkUndirectedGraph*, edge_index_t> : property_map<vtkGraph*, edge_index_t>
1309 {
1310 };
1311 
1312 inline vtkGraphIndexMap get(edge_index_t, vtkGraph*)
1313 {
1314  return vtkGraphIndexMap();
1315 }
1316 
1317 // property_map specializations for const-qualified graphs
1318 template <>
1319 struct property_map<vtkDirectedGraph* const, vertex_index_t>
1321 {
1322 };
1323 
1324 template <>
1325 struct property_map<vtkUndirectedGraph* const, vertex_index_t>
1327 {
1328 };
1329 
1330 template <>
1331 struct property_map<vtkDirectedGraph* const, edge_index_t>
1333 {
1334 };
1335 
1336 template <>
1337 struct property_map<vtkUndirectedGraph* const, edge_index_t>
1339 {
1340 };
1341 } // namespace boost
1342 
1343 #if BOOST_VERSION > 104000
1344 #include <boost/property_map/vector_property_map.hpp>
1345 #else
1346 #include <boost/vector_property_map.hpp>
1347 #endif
1348 
1349 #endif // vtkBoostGraphAdapter_h
1350 // VTK-HeaderTest-Exclude: vtkBoostGraphAdapter.h
vtkEdgeBase::Id
vtkIdType Id
Definition: vtkGraph.h:300
boost::graph_traits< vtkGraph * >
Definition: vtkBoostGraphAdapter.h:493
boost::vtkGraphEdgeMap
Definition: vtkBoostGraphAdapter.h:1125
boost::graph_traits< vtkGraph * >::null_edge
static edge_descriptor null_edge()
Definition: vtkBoostGraphAdapter.h:497
boost::remove_edge
void remove_edge(graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *g)
Definition: vtkBoostGraphAdapter.h:559
vtkAbstractArray::GetVariantValue
virtual vtkVariant GetVariantValue(vtkIdType valueIdx)
Retrieve value from the array as a variant.
vtkVariant.h
vtkMutableDirectedGraph
An editable directed graph.
Definition: vtkMutableDirectedGraph.h:155
degree
boost::graph_traits< vtkGraph * >::degree_size_type degree(boost::graph_traits< vtkGraph * >::vertex_descriptor u, vtkGraph *g)
Definition: vtkBoostGraphAdapter.h:1083
boost::put
void put(vtkGraphPropertyMapMultiplier< PMap > multi, const typename property_traits< PMap >::key_type &key, const typename property_traits< PMap >::value_type &value)
Definition: vtkBoostGraphAdapter.h:1264
boost::vtkGraphEdgePropertyMapHelper::key_type
vtkEdgeType key_type
Definition: vtkBoostGraphAdapter.h:1158
vtkDistributedGraphHelper
helper for the vtkGraph class that allows the graph to be distributed across multiple memory spaces.
Definition: vtkDistributedGraphHelper.h:77
vtkMutableDirectedGraph::AddEdge
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...
vtkGraph::GetDistributedGraphHelper
vtkDistributedGraphHelper * GetDistributedGraphHelper()
Retrieves the distributed graph helper for this graph.
boost::property_map< vtkUndirectedGraph *, edge_index_t >
Definition: vtkBoostGraphAdapter.h:1309
vtkUndirectedGraph
An undirected graph.
Definition: vtkUndirectedGraph.h:88
boost::vtkGraphEdgePropertyMapHelper::operator[]
reference operator[](const key_type &key) const
Definition: vtkBoostGraphAdapter.h:1161
boost::vtk_vertex_iterator::iterator_core_access
friend class iterator_core_access
Definition: vtkBoostGraphAdapter.h:211
boost::property_traits< vtkAbstractArray * >::reference
vtkVariant reference
Definition: vtkBoostGraphAdapter.h:153
vtkMutableUndirectedGraph
An editable undirected graph.
Definition: vtkMutableUndirectedGraph.h:153
boost::vertex_property_type< vtkUndirectedGraph * >
Definition: vtkBoostGraphAdapter.h:725
boost::property_traits
Definition: vtkBoostGraphAdapter.h:99
boost::vtkGraphEdgePropertyMapHelper::vtkGraphEdgePropertyMapHelper
vtkGraphEdgePropertyMapHelper(PMap m)
Definition: vtkBoostGraphAdapter.h:1151
vtkX3D::value
@ value
Definition: vtkX3D.h:226
vtkDataArray::SetTuple1
void SetTuple1(vtkIdType tupleIdx, double value)
These methods are included as convenience for the wrappers.
boost::vtkGraphVertexPropertyMapHelper::vtkGraphVertexPropertyMapHelper
vtkGraphVertexPropertyMapHelper(PMap m)
Definition: vtkBoostGraphAdapter.h:1186
vtkX3D::type
@ type
Definition: vtkX3D.h:522
vtkIdType
int vtkIdType
Definition: vtkType.h:332
boost::vertex_property_type< vtkDirectedGraph * >
Definition: vtkBoostGraphAdapter.h:609
boost::vtk_edge_iterator::vtk_edge_iterator
vtk_edge_iterator(vtkGraph *g=0, vtkIdType v=0)
Definition: vtkBoostGraphAdapter.h:219
boost::property_traits< vtkAbstractArray * >::category
read_write_property_map_tag category
Definition: vtkBoostGraphAdapter.h:155
boost::vtkGraphVertexPropertyMapHelper::category
property_traits< PMap >::category category
Definition: vtkBoostGraphAdapter.h:1194
vtkMutableUndirectedGraph.h
vtkFloatArray
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:145
boost::property_traits< vtkDataArray * >::category
read_write_property_map_tag category
Definition: vtkBoostGraphAdapter.h:135
boost::graph_traits< vtkDirectedGraph * >
Definition: vtkBoostGraphAdapter.h:576
boost::property_traits< vtkGraphIndexMap >::reference
vtkIdType reference
Definition: vtkBoostGraphAdapter.h:1225
vtkGraph::GetNumberOfVertices
virtual vtkIdType GetNumberOfVertices()
The number of vertices in the graph.
boost::vtkGraphPropertyMapMultiplier::vtkGraphPropertyMapMultiplier
vtkGraphPropertyMapMultiplier(PMap m, float multi=1)
Definition: vtkBoostGraphAdapter.h:1243
boost::edge_property_type< vtkGraph * >
Definition: vtkBoostGraphAdapter.h:530
boost::vtkGraphVertexPropertyMapHelper::value_type
property_traits< PMap >::value_type value_type
Definition: vtkBoostGraphAdapter.h:1191
vtkX3D::key
@ key
Definition: vtkX3D.h:263
boost::property_traits< vtkDataArray * >::key_type
vtkIdType key_type
Definition: vtkBoostGraphAdapter.h:134
vtkUndirectedGraph.h
boost::edge_bundle_type< vtkGraph * >::type
no_property type
Definition: vtkBoostGraphAdapter.h:551
vtkTree.h
boost::property_traits< vtkGraphIndexMap >::key_type
vtkIdType key_type
Definition: vtkBoostGraphAdapter.h:1226
num_edges
boost::graph_traits< vtkGraph * >::edges_size_type num_edges(vtkGraph *g)
Definition: vtkBoostGraphAdapter.h:1066
boost::vertex_bundle_type< vtkGraph * >
Definition: vtkBoostGraphAdapter.h:544
add_vertex
boost::graph_traits< vtkMutableDirectedGraph * >::vertex_descriptor add_vertex(vtkMutableDirectedGraph *g)
Definition: vtkBoostGraphAdapter.h:1089
boost::property_traits< vtkAbstractArray * >::value_type
vtkVariant value_type
Definition: vtkBoostGraphAdapter.h:152
boost::graph_traits< vtkMutableDirectedGraph * >
Definition: vtkBoostGraphAdapter.h:789
boost::vtkGraphPropertyMapMultiplier::multiplier
float multiplier
Definition: vtkBoostGraphAdapter.h:1249
boost::property_traits< vtkGraphEdgeMap >::value_type
vtkIdType value_type
Definition: vtkBoostGraphAdapter.h:1131
detail
Definition: vtkGenericDataArrayLookupHelper.h:33
vtkDirectedGraph
A directed graph.
Definition: vtkDirectedGraph.h:84
boost
Forward declaration required for Boost serialization.
Definition: vtkVariantArray.h:111
vtkGraph::GetNumberOfEdges
virtual vtkIdType GetNumberOfEdges()
The number of edges in the graph.
boost::vtk_edge_iterator::iterator_core_access
friend class iterator_core_access
Definition: vtkBoostGraphAdapter.h:360
vtkInEdgeType
Definition: vtkGraph.h:315
vtkDataArray
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:159
vtkMutableDirectedGraph.h
boost::graph_traits< vtkMutableUndirectedGraph * >
Definition: vtkBoostGraphAdapter.h:886
vtkAbstractArray.h
boost::vtk_out_edge_pointer_iterator
Definition: vtkBoostGraphAdapter.h:366
boost::property_map< vtkGraph *, edge_index_t >
Definition: vtkBoostGraphAdapter.h:1297
boost::property_traits< vtkDataArray * >::value_type
double value_type
Definition: vtkBoostGraphAdapter.h:132
vtkDirectedGraph.h
boost::put
void put(vtkDataArray *arr, vtkIdType key, const double &value)
Definition: vtkBoostGraphAdapter.h:143
boost::vertex_bundle_type< vtkGraph * >::type
no_property type
Definition: vtkBoostGraphAdapter.h:545
boost::has_no_edges
bool has_no_edges(vtkGraph *g)
Definition: vtkBoostGraphAdapter.h:554
vtkOutEdgeType::Target
vtkIdType Target
Definition: vtkGraph.h:311
vtkAbstractArray::InsertVariantValue
virtual void InsertVariantValue(vtkIdType valueIdx, vtkVariant value)=0
Insert a value into the array from a variant.
boost::property_traits< vtkGraphIndexMap >::value_type
vtkIdType value_type
Definition: vtkBoostGraphAdapter.h:1224
boost::property_map< vtkGraph *, vertex_index_t >::type
vtkGraphIndexMap type
Definition: vtkBoostGraphAdapter.h:1276
boost::vertex_property_type< vtkGraph * >
Definition: vtkBoostGraphAdapter.h:524
boost::vtkGraphEdgePropertyMapHelper::category
property_traits< PMap >::category category
Definition: vtkBoostGraphAdapter.h:1159
in_degree
boost::graph_traits< vtkDirectedGraph * >::degree_size_type in_degree(boost::graph_traits< vtkDirectedGraph * >::vertex_descriptor u, vtkDirectedGraph *g)
Definition: vtkBoostGraphAdapter.h:1077
boost::vtkGraphPropertyMapMultiplier::key_type
property_traits< PMap >::key_type key_type
Definition: vtkBoostGraphAdapter.h:1252
boost::vtkGraphPropertyMapMultiplier::category
property_traits< PMap >::category category
Definition: vtkBoostGraphAdapter.h:1253
boost::vertex_bundle_type< vtkUndirectedGraph * >
Definition: vtkBoostGraphAdapter.h:763
vtkTree
A rooted tree data structure.
Definition: vtkTree.h:164
vtkEdgeType
Definition: vtkGraph.h:326
vtkMutableUndirectedGraph::AddEdge
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...
target
boost::graph_traits< vtkGraph * >::vertex_descriptor target(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:1004
boost::graph_traits< vtkUndirectedGraph * >::directed_category
undirected_tag directed_category
Definition: vtkBoostGraphAdapter.h:693
boost::vtkGraphVertexPropertyMapHelper::reference
property_traits< PMap >::reference reference
Definition: vtkBoostGraphAdapter.h:1192
boost::vtkGraphVertexPropertyMapHelper::pmap
PMap pmap
Definition: vtkBoostGraphAdapter.h:1190
boost::graph_traits< vtkDirectedGraph * >::directed_category
directed_tag directed_category
Definition: vtkBoostGraphAdapter.h:577
boost::vtkGraphEdgePropertyMapHelper::pmap
PMap pmap
Definition: vtkBoostGraphAdapter.h:1155
boost::property_map< vtkGraph *, edge_index_t >::type
vtkGraphIndexMap type
Definition: vtkBoostGraphAdapter.h:1298
vtkFloatArray.h
vtkDistributedGraphHelper::GetVertexOwner
vtkIdType GetVertexOwner(vtkIdType v) const
Returns owner of vertex v, by extracting top ceil(log2 P) bits of v.
boost::property_map< vtkUndirectedGraph *, vertex_index_t >
Definition: vtkBoostGraphAdapter.h:1287
boost::vtkGraph_traversal_category
Definition: vtkBoostGraphAdapter.h:488
boost::vtk_in_edge_pointer_iterator::vtk_in_edge_pointer_iterator
vtk_in_edge_pointer_iterator(vtkGraph *g=0, vtkIdType v=0, bool end=false)
Definition: vtkBoostGraphAdapter.h:425
boost::property_traits< vtkGraphEdgeMap >::key_type
vtkEdgeType key_type
Definition: vtkBoostGraphAdapter.h:1133
boost::graph_traits< vtkGraph * >::vertex_iterator
vtk_vertex_iterator vertex_iterator
Definition: vtkBoostGraphAdapter.h:501
vtkGraph::GetOutDegree
virtual vtkIdType GetOutDegree(vtkIdType v)
The number of outgoing edges from vertex v.
vtkMutableUndirectedGraph::SafeDownCast
static vtkMutableUndirectedGraph * SafeDownCast(vtkObjectBase *o)
vtkGraph::GetInDegree
virtual vtkIdType GetInDegree(vtkIdType v)
The number of incoming edges to vertex v.
boost::get
double get(vtkDataArray *const &arr, vtkIdType key)
Definition: vtkBoostGraphAdapter.h:138
vtkDataObject::DATA_PIECE_NUMBER
static vtkInformationIntegerKey * DATA_PIECE_NUMBER()
boost::vtkGraphEdgePropertyMapHelper::reference
property_traits< PMap >::reference reference
Definition: vtkBoostGraphAdapter.h:1157
boost::vertex_bundle_type< vtkDirectedGraph * >
Definition: vtkBoostGraphAdapter.h:647
vtkDoubleArray.h
boost::property_traits< vtkGraphEdgeMap >::reference
vtkIdType reference
Definition: vtkBoostGraphAdapter.h:1132
vtkMutableUndirectedGraph::RemoveEdge
void RemoveEdge(vtkIdType e)
Removes the edge from the graph.
boost::property_traits< vtkGraphEdgeMap >::category
readable_property_map_tag category
Definition: vtkBoostGraphAdapter.h:1134
boost::property_map< vtkDirectedGraph *, edge_index_t >
Definition: vtkBoostGraphAdapter.h:1304
vtkGraph::GetDegree
virtual vtkIdType GetDegree(vtkIdType v)
The total of all incoming and outgoing vertices for vertex v.
boost::get
vtkGraphIndexMap get(edge_index_t, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:1312
boost::vtkGraphIndexMap
Definition: vtkBoostGraphAdapter.h:1218
boost::edge_bundle_type< vtkGraph * >
Definition: vtkBoostGraphAdapter.h:550
boost::vtkGraphPropertyMapMultiplier
Definition: vtkBoostGraphAdapter.h:1241
boost::vtkGraphVertexPropertyMapHelper::operator[]
reference operator[](const key_type &key) const
Definition: vtkBoostGraphAdapter.h:1196
vtkDistributedGraphHelper.h
boost::edge_property_type< vtkDirectedGraph * >
Definition: vtkBoostGraphAdapter.h:621
vtkIntArray
dynamic, self-adjusting array of int
Definition: vtkIntArray.h:149
out_edges
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)
Definition: vtkBoostGraphAdapter.h:1035
vtkMutableUndirectedGraph::AddVertex
vtkIdType AddVertex()
Adds a vertex to the graph and returns the index of the new vertex.
vtkVariant
A atomic type representing the union of many types.
Definition: vtkVariant.h:135
boost::vtk_vertex_iterator
Definition: vtkBoostGraphAdapter.h:194
boost::vtk_in_edge_pointer_iterator
Definition: vtkBoostGraphAdapter.h:423
out_degree
boost::graph_traits< vtkGraph * >::degree_size_type out_degree(boost::graph_traits< vtkGraph * >::vertex_descriptor u, vtkGraph *g)
Definition: vtkBoostGraphAdapter.h:1071
vtkDistributedGraphHelper::MakeDistributedId
vtkIdType MakeDistributedId(int owner, vtkIdType local)
Builds a distributed ID consisting of the given owner and the local ID.
boost::property_traits< vtkAbstractArray * >::key_type
vtkIdType key_type
Definition: vtkBoostGraphAdapter.h:154
add_edge
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)
Definition: vtkBoostGraphAdapter.h:1095
vtkIdTypeArray.h
vtkInEdgeType::Source
vtkIdType Source
Definition: vtkGraph.h:322
boost::edge_property_type< vtkUndirectedGraph * >
Definition: vtkBoostGraphAdapter.h:737
boost::property_map< vtkGraph *, edge_index_t >::const_type
vtkGraphIndexMap const_type
Definition: vtkBoostGraphAdapter.h:1299
boost::vtk_out_edge_pointer_iterator::vtk_out_edge_pointer_iterator
vtk_out_edge_pointer_iterator(vtkGraph *g=0, vtkIdType v=0, bool end=false)
Definition: vtkBoostGraphAdapter.h:368
boost::edge_property_type< vtkGraph * >::type
no_property type
Definition: vtkBoostGraphAdapter.h:531
boost::property_traits< vtkDataArray * >::reference
double reference
Definition: vtkBoostGraphAdapter.h:133
boost::vtk_vertex_iterator::vtk_vertex_iterator
vtk_vertex_iterator(vtkIdType i=0)
Definition: vtkBoostGraphAdapter.h:196
boost::graph_traits< vtkGraph * >::in_edge_iterator
vtk_in_edge_pointer_iterator in_edge_iterator
Definition: vtkBoostGraphAdapter.h:499
vtkAbstractArray
Abstract superclass for all arrays.
Definition: vtkAbstractArray.h:76
boost::vtkGraphEdgePropertyMapHelper
Definition: vtkBoostGraphAdapter.h:1149
boost::graph_traits< vtkTree * >
Definition: vtkBoostGraphAdapter.h:673
boost::vtkGraphPropertyMapMultiplier::pmap
PMap pmap
Definition: vtkBoostGraphAdapter.h:1248
boost::graph_traits< vtkGraph * >::out_edge_iterator
vtk_out_edge_pointer_iterator out_edge_iterator
Definition: vtkBoostGraphAdapter.h:498
vtkGraph::GetOutEdges
virtual void GetOutEdges(vtkIdType v, vtkOutEdgeIterator *it)
Initializes the out edge iterator to iterate over all outgoing edges of vertex v.
boost::edge_bundle_type< vtkDirectedGraph * >
Definition: vtkBoostGraphAdapter.h:659
boost::vtkGraphPropertyMapMultiplier::value_type
property_traits< PMap >::value_type value_type
Definition: vtkBoostGraphAdapter.h:1250
boost::vtkGraphVertexPropertyMapHelper
Definition: vtkBoostGraphAdapter.h:1184
vtkIntArray.h
boost::graph_traits< vtkGraph * >::vertices_size_type
vtkIdType vertices_size_type
Definition: vtkBoostGraphAdapter.h:506
boost::graph_traits< vtkGraph * >::edge_descriptor
vtkEdgeType edge_descriptor
Definition: vtkBoostGraphAdapter.h:496
boost::vtkGraphEdgePropertyMapHelper::value_type
property_traits< PMap >::value_type value_type
Definition: vtkBoostGraphAdapter.h:1156
vtkDataArray.h
vtkIdTypeArray
dynamic, self-adjusting array of vtkIdType
Definition: vtkIdTypeArray.h:145
vtkDataObject::GetInformation
virtual vtkInformation * GetInformation()
Set/Get the information object associated with this data object.
in_edges
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)
Definition: vtkBoostGraphAdapter.h:1044
vtkDirectedGraph::SafeDownCast
static vtkDirectedGraph * SafeDownCast(vtkObjectBase *o)
vtkOutEdgeType
Definition: vtkGraph.h:304
vtkDataObject.h
vtkInformation.h
vtkMutableDirectedGraph::RemoveEdge
void RemoveEdge(vtkIdType e)
Removes the edge from the graph.
boost::graph_traits< vtkGraph * >::edges_size_type
vtkIdType edges_size_type
Definition: vtkBoostGraphAdapter.h:507
boost::edge_property< vtkGraph * >::type
vtkIdType type
Definition: vtkBoostGraphAdapter.h:994
boost::property_map< vtkGraph *, vertex_index_t >::const_type
vtkGraphIndexMap const_type
Definition: vtkBoostGraphAdapter.h:1277
adjacent_vertices
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)
Definition: vtkBoostGraphAdapter.h:1053
boost::graph_traits< vtkGraph * >::degree_size_type
vtkIdType degree_size_type
Definition: vtkBoostGraphAdapter.h:508
boost::vertex_property< vtkGraph * >::type
vtkIdType type
Definition: vtkBoostGraphAdapter.h:987
edges
std::pair< boost::graph_traits< vtkGraph * >::edge_iterator, boost::graph_traits< vtkGraph * >::edge_iterator > edges(vtkGraph *g)
Definition: vtkBoostGraphAdapter.h:1027
boost::graph_traits< vtkGraph * >::null_vertex
static vertex_descriptor null_vertex()
Definition: vtkBoostGraphAdapter.h:495
vtkDoubleArray
dynamic, self-adjusting array of double
Definition: vtkDoubleArray.h:145
boost::graph_traits< vtkGraph * >::vertex_descriptor
vtkIdType vertex_descriptor
Definition: vtkBoostGraphAdapter.h:494
vtkMutableDirectedGraph::SafeDownCast
static vtkMutableDirectedGraph * SafeDownCast(vtkObjectBase *o)
source
boost::graph_traits< vtkGraph * >::vertex_descriptor source(boost::graph_traits< vtkGraph * >::edge_descriptor e, vtkGraph *)
Definition: vtkBoostGraphAdapter.h:998
vtkInformation::Get
int Get(vtkInformationIntegerKey *key)
Get/Set an integer-valued entry.
boost::vtk_out_edge_pointer_iterator::iterator_core_access
friend class iterator_core_access
Definition: vtkBoostGraphAdapter.h:417
vertices
std::pair< boost::graph_traits< vtkGraph * >::vertex_iterator, boost::graph_traits< vtkGraph * >::vertex_iterator > vertices(vtkGraph *g)
Definition: vtkBoostGraphAdapter.h:1012
boost::vtk_edge_iterator
Definition: vtkBoostGraphAdapter.h:217
boost::graph_traits< vtkGraph * >::traversal_category
vtkGraph_traversal_category traversal_category
Definition: vtkBoostGraphAdapter.h:505
boost::graph_traits< vtkUndirectedGraph * >
Definition: vtkBoostGraphAdapter.h:692
vtkGraph
Base class for graph data types.
Definition: vtkGraph.h:339
vtkDistributedGraphHelper::GetEdgeOwner
vtkIdType GetEdgeOwner(vtkIdType e_id) const
Returns owner of edge with ID e_id, by extracting top ceil(log2 P) bits of e_id.
boost::vtkGraphVertexPropertyMapHelper::key_type
vtkIdType key_type
Definition: vtkBoostGraphAdapter.h:1193
boost::property_traits< vtkGraphIndexMap >::category
readable_property_map_tag category
Definition: vtkBoostGraphAdapter.h:1227
boost::edge_bundle_type< vtkUndirectedGraph * >
Definition: vtkBoostGraphAdapter.h:775
boost::graph_traits< vtkGraph * >::edge_iterator
vtk_edge_iterator edge_iterator
Definition: vtkBoostGraphAdapter.h:502
boost::vertex_property_type< vtkGraph * >::type
no_property type
Definition: vtkBoostGraphAdapter.h:525
vtkMutableDirectedGraph::AddVertex
vtkIdType AddVertex()
Adds a vertex to the graph and returns the index of the new vertex.
boost::property_map< vtkDirectedGraph *, vertex_index_t >
Definition: vtkBoostGraphAdapter.h:1282
boost::vtkGraphPropertyMapMultiplier::reference
property_traits< PMap >::reference reference
Definition: vtkBoostGraphAdapter.h:1251
boost::vtk_in_edge_pointer_iterator::iterator_core_access
friend class iterator_core_access
Definition: vtkBoostGraphAdapter.h:474
vtkDataArray::GetTuple1
double GetTuple1(vtkIdType tupleIdx)
These methods are included as convenience for the wrappers.
boost::graph_traits< vtkGraph * >::edge_parallel_category
allow_parallel_edge_tag edge_parallel_category
Definition: vtkBoostGraphAdapter.h:504
boost::vtkPropertyMapMacro
vtkPropertyMapMacro(vtkIntArray, int)
num_vertices
boost::graph_traits< vtkGraph * >::vertices_size_type num_vertices(vtkGraph *g)
Definition: vtkBoostGraphAdapter.h:1061
boost::property_map< vtkGraph *, vertex_index_t >
Definition: vtkBoostGraphAdapter.h:1275
boost::graph_traits< vtkGraph * >::adjacency_iterator
adjacency_iterator_generator< vtkGraph *, vertex_descriptor, out_edge_iterator >::type adjacency_iterator
Definition: vtkBoostGraphAdapter.h:511