37#ifndef VIGRA_ADJACENCY_LIST_GRAPH_HXX
38#define VIGRA_ADJACENCY_LIST_GRAPH_HXX
45#include "multi_array.hxx"
46#include "multi_gridgraph.hxx"
48#include "tinyvector.hxx"
49#include "random_access_set.hxx"
50#include "graph_maps.hxx"
51#include "iteratorfacade.hxx"
53#include "algorithm.hxx"
54#include "graph_item_impl.hxx"
63 namespace detail_adjacency_list_graph{
65 template<
class G,
class ITEM>
67 :
public ForwardIteratorFacade<
68 ItemIter<G,ITEM>,ITEM,true
72 typedef vigra::GraphItemHelper<G,ITEM> ItemHelper;
73 typedef typename G::index_type index_type;
76 ItemIter(
const lemon::Invalid & = lemon::INVALID)
86 item_(ItemHelper::itemFromId(*graph_,id_))
88 while( !isEnd() && item_==lemon::INVALID ){
90 item_ = ItemHelper::itemFromId(*graph_,id_);
94 ItemIter(
const G & g,
const ITEM & item)
104 friend class vigra::IteratorFacadeCoreAccess;
106 return graph_==NULL || ItemHelper::itemNum(*graph_)==0 || id_>ItemHelper::maxItemId(*graph_);
108 bool isBegin( )
const{
109 return graph_!=NULL && id_ == 0 ;
112 bool equal(
const ItemIter & other)
const{
113 return (isEnd() && other.isEnd() ) || (isEnd()==other.isEnd() && (id_ == other.id_) );
118 item_ = ItemHelper::itemFromId(*graph_,id_);
119 while( !isEnd() && item_==lemon::INVALID ){
121 item_ = ItemHelper::itemFromId(*graph_,id_);
124 const ITEM & dereference()
const{
134 template<
class GRAPH>
136 :
public ForwardIteratorFacade<
138 typename GRAPH::Arc,true
143 typedef typename Graph::Arc Arc;
144 typedef typename Graph::Edge Edge;
145 typedef typename Graph::EdgeIt EdgeIt;
146 ArcIt(
const lemon::Invalid = lemon::INVALID )
153 ArcIt(
const GRAPH & g )
157 veryEnd_( g.edgeNum()==0 ? true : false),
161 ArcIt(
const GRAPH & g ,
const Arc & arc )
163 pos_(g,arc.edgeId()),
164 inFirstHalf_(g.id(arc)<=g.maxEdgeId()),
169 friend class vigra::IteratorFacadeCoreAccess;
171 return veryEnd_ || graph_==NULL;
175 return graph_!=NULL && veryEnd_==
false && pos_ == EdgeIt(*graph_);
180 if(pos_ == lemon::INVALID ) {
181 pos_ = EdgeIt(*graph_);
188 if(pos_ == lemon::INVALID){
196 bool equal(ArcIt
const& other)
const{
199 isEnd()==other.isEnd() &&
200 inFirstHalf_==other.inFirstHalf_
202 (isEnd() || graph_==NULL || pos_==other.pos_ )
207 const Arc & dereference()
const {
209 arc_ = graph_->direct(*pos_,inFirstHalf_);
214 const GRAPH * graph_;
227 class AdjacencyListGraph
232 typedef Int64 index_type;
235 typedef AdjacencyListGraph GraphType;
236 typedef detail::GenericNodeImpl<index_type,false> NodeStorage;
237 typedef detail::GenericEdgeImpl<index_type > EdgeStorage;
238 typedef detail::NeighborNodeFilter<GraphType> NnFilter;
239 typedef detail::IncEdgeFilter<GraphType> IncFilter;
240 typedef detail::IsInFilter<GraphType> InFlter;
241 typedef detail::IsOutFilter<GraphType> OutFilter;
242 typedef detail::IsBackOutFilter<GraphType> BackOutFilter;
247 typedef detail::GenericNode<index_type> Node;
249 typedef detail::GenericEdge<index_type> Edge;
251 typedef detail::GenericArc<index_type> Arc;
253 typedef detail_adjacency_list_graph::ItemIter<GraphType,Edge> EdgeIt;
255 typedef detail_adjacency_list_graph::ItemIter<GraphType,Node> NodeIt;
257 typedef detail_adjacency_list_graph::ArcIt<GraphType> ArcIt;
260 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,IncFilter > IncEdgeIt;
262 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,InFlter > InArcIt;
264 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,OutFilter > OutArcIt;
266 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,NnFilter > NeighborNodeIt;
270 typedef detail::GenericIncEdgeIt<GraphType,NodeStorage,BackOutFilter > OutBackArcIt;
275 typedef directed_tag directed_category;
277 typedef NeighborNodeIt adjacency_iterator;
278 typedef EdgeIt edge_iterator;
279 typedef NodeIt vertex_iterator;
280 typedef IncEdgeIt in_edge_iterator;
281 typedef IncEdgeIt out_edge_iterator;
284 typedef size_t degree_size_type;
285 typedef size_t edge_size_type;
286 typedef size_t vertex_size_type;
288 typedef Edge edge_descriptor;
289 typedef Node vertex_descriptor;
294 struct EdgeMap : DenseEdgeReferenceMap<GraphType,T> {
295 EdgeMap(): DenseEdgeReferenceMap<GraphType,T>(){
297 EdgeMap(
const GraphType & g)
298 : DenseEdgeReferenceMap<GraphType,T>(g){
300 EdgeMap(
const GraphType & g,
const T & val)
301 : DenseEdgeReferenceMap<GraphType,T>(g,val){
307 struct NodeMap : DenseNodeReferenceMap<GraphType,T> {
308 NodeMap(): DenseNodeReferenceMap<GraphType,T>(){
310 NodeMap(
const GraphType & g)
311 : DenseNodeReferenceMap<GraphType,T>(g){
313 NodeMap(
const GraphType & g,
const T & val)
314 : DenseNodeReferenceMap<GraphType,T>(g,val){
320 struct ArcMap : DenseArcReferenceMap<GraphType,T> {
321 ArcMap(): DenseArcReferenceMap<GraphType,T>(){
323 ArcMap(
const GraphType & g)
324 : DenseArcReferenceMap<GraphType,T>(g){
326 ArcMap(
const GraphType & g,
const T & val)
327 : DenseArcReferenceMap<GraphType,T>(g,val){
340 AdjacencyListGraph(
const size_t nodes=0,
const size_t edges=0);
344 index_type edgeNum()
const;
348 index_type nodeNum()
const;
351 index_type arcNum()
const;
355 index_type maxEdgeId()
const;
358 index_type maxNodeId()
const;
361 index_type maxArcId()
const;
367 Arc direct(
const Edge & edge,
const bool forward)
const;
373 Arc direct(
const Edge & edge,
const Node & node)
const;
378 bool direction(
const Arc & arc)
const;
382 Node u(
const Edge & edge)
const;
386 Node v(
const Edge & edge)
const;
389 Node source(
const Arc & arc)
const;
392 Node target(
const Arc & arc)
const;
397 Node oppositeNode(Node
const &n,
const Edge &e)
const;
401 Node baseNode(
const IncEdgeIt & iter)
const;
404 Node baseNode(
const OutArcIt & iter)
const;
408 Node runningNode(
const IncEdgeIt & iter)
const;
411 Node runningNode(
const OutArcIt & iter)
const;
416 index_type id(
const Node & node)
const;
419 index_type id(
const Edge & edge)
const;
422 index_type id(
const Arc & arc )
const;
427 Edge edgeFromId(
const index_type
id)
const;
432 Node nodeFromId(
const index_type
id)
const;
436 Arc arcFromId(
const index_type
id)
const;
441 Edge findEdge(
const Node & a,
const Node & b)
const;
444 Arc findArc(
const Node & u,
const Node & v)
const;
454 Node addNode(
const index_type
id);
460 void assignNodeRange(
const index_type beginId,
const index_type endId);
467 Edge addEdge(
const Node & u ,
const Node & v);
472 Edge addEdge(
const index_type u ,
const index_type v);
475 size_t maxDegree()
const{
477 for(NodeIt it(*
this);it!=lemon::INVALID;++it){
478 md = std::max(md,
size_t( degree(*it) ) );
489 vertex_iterator get_vertex_iterator()
const;
490 vertex_iterator get_vertex_end_iterator()
const ;
491 edge_iterator get_edge_iterator()
const;
492 edge_iterator get_edge_end_iterator()
const ;
493 degree_size_type degree(
const vertex_descriptor & node)
const{
494 return nodeImpl(node).numberOfEdges();
497 static const bool is_directed =
false;
501 void reserveMaxNodeId(
const index_type mxid ){
502 if(nodeNum()==0 || mxid>maxNodeId())
503 nodes_.reserve(mxid+1);
506 void reserveEdges(
const size_t size ){
507 if(size>(
size_t)edgeNum())
508 edges_.reserve(size);
518 size_t serializationSize()
const{
528 for(NodeIt iter(*
this); iter!= lemon::INVALID ; ++iter){
529 size+= 2+this->degree(*iter)*2;
536 void serialize(ITER outIter)
const {
539 *outIter = nodeNum(); ++outIter;
540 *outIter = edgeNum(); ++outIter;
541 *outIter = maxNodeId(); ++outIter;
542 *outIter = maxEdgeId(); ++outIter;
545 for(EdgeIt iter(*
this); iter!=lemon::INVALID; ++iter){
547 const size_t ui = this->id(this->u(e));
548 const size_t vi = this->id(this->v(e));
549 *outIter = ui; ++outIter;
550 *outIter = vi; ++outIter;
556 for(NodeIt iter(*
this); iter!= lemon::INVALID ; ++iter){
559 *outIter = this->id(*iter); ++outIter;
560 *outIter = this->degree(*iter); ++outIter;
562 for(OutArcIt eIter(*
this,n); eIter!=lemon::INVALID; ++eIter){
563 const Edge e(*eIter);
564 const Node oNode(this->target(*eIter));
566 const size_t ei = this->id(e);
567 const size_t oni = this->id(oNode);
569 *outIter = ei; ++outIter;
570 *outIter = oni; ++outIter;
577 void deserialize(ITER begin, ITER){
580 nodeNum_ = *begin; ++begin;
581 edgeNum_ = *begin; ++begin;
582 const size_t maxNid = *begin; ++begin;
583 const size_t maxEid = *begin; ++begin;
587 nodes_.resize(maxNid+1, NodeStorage());
588 edges_.resize(maxEid+1, EdgeStorage());
591 for(
size_t eid=0; eid<edgeNum_; ++eid){
592 const size_t u = *begin; ++begin;
593 const size_t v = *begin; ++begin;
596 edges_[eid]=EdgeStorage(u,v,eid);
600 for(
size_t i=0; i<nodeNum_; ++i){
602 const size_t id = *begin; ++begin;
603 const size_t nodeDegree=*begin; ++begin;
605 NodeStorage & nodeImpl = nodes_[id];
607 for(
size_t d=0; d<nodeDegree; ++d){
608 const size_t ei = *begin; ++begin;
609 const size_t oni = *begin; ++begin;
610 nodeImpl.insert(oni, ei);
617 typedef std::vector<NodeStorage> NodeVector;
618 typedef std::vector<EdgeStorage> EdgeVector;
622 template<
class G,
class NIMPL,
class FILT>
623 friend class detail::GenericIncEdgeIt;
626 friend struct detail::NeighborNodeFilter;
628 friend struct detail::IncEdgeFilter;
630 friend struct detail::BackEdgeFilter;
632 friend struct detail::IsOutFilter;
634 friend struct detail::IsBackOutFilter;
636 friend struct detail::IsInFilter;
639 friend class detail_adjacency_list_graph::ItemIter<GraphType,Node>;
640 friend class detail_adjacency_list_graph::ItemIter<GraphType,Edge>;
643 const NodeStorage & nodeImpl(
const Node & node)
const{
644 return nodes_[node.id()];
647 NodeStorage & nodeImpl(
const Node & node){
648 return nodes_[node.id()];
667 inline AdjacencyListGraph::AdjacencyListGraph(
668 const size_t reserveNodes,
669 const size_t reserveEdges
676 nodes_.reserve(reserveNodes);
677 edges_.reserve(reserveEdges);
681 inline AdjacencyListGraph::Node
682 AdjacencyListGraph::addNode(){
683 const index_type
id = nodes_.size();
684 nodes_.push_back(NodeStorage(
id));
689 inline AdjacencyListGraph::Node
690 AdjacencyListGraph::addNode(
const AdjacencyListGraph::index_type
id){
691 if((std::size_t)
id == nodes_.size()){
692 nodes_.push_back(NodeStorage(
id));
696 else if((std::size_t)
id < nodes_.size()){
697 const Node node = nodeFromId(
id);
698 if(node==lemon::INVALID){
699 nodes_[id]=NodeStorage(
id);
709 while(nodes_.size() < (std::size_t)
id){
710 nodes_.push_back(NodeStorage(lemon::INVALID));
712 nodes_.push_back(NodeStorage(
id));
720 AdjacencyListGraph::assignNodeRange(
const AdjacencyListGraph::index_type beginId,
const AdjacencyListGraph::index_type endId){
724 nodeNum_ = endId - beginId;
725 nodes_.resize(endId);
726 for(index_type i=beginId; i<endId; ++i)
727 nodes_[i]=NodeStorage(i);
732 inline AdjacencyListGraph::Edge
733 AdjacencyListGraph::addEdge(
734 const AdjacencyListGraph::Node & u ,
735 const AdjacencyListGraph::Node & v
737 const Edge foundEdge = findEdge(u,v);
738 if(foundEdge!=lemon::INVALID){
741 else if(u==lemon::INVALID || v==lemon::INVALID){
742 return Edge(lemon::INVALID);
745 const index_type eid = edges_.size();
746 const index_type uid = u.id();
747 const index_type vid = v.id();
748 edges_.push_back(EdgeStorage(uid,vid,eid));
749 nodeImpl(u).insert(vid,eid);
750 nodeImpl(v).insert(uid,eid);
756 inline AdjacencyListGraph::Edge
757 AdjacencyListGraph::addEdge(
758 const AdjacencyListGraph::index_type u ,
759 const AdjacencyListGraph::index_type v
761 const Node uu = addNode(u);
762 const Node vv = addNode(v);
763 return addEdge(uu,vv);
768 inline AdjacencyListGraph::Arc
769 AdjacencyListGraph::direct(
770 const AdjacencyListGraph::Edge & edge,
773 if(edge!=lemon::INVALID){
775 return Arc(
id(edge),
id(edge));
777 return Arc(
id(edge)+maxEdgeId()+1,
id(edge));
780 return Arc(lemon::INVALID);
784 inline AdjacencyListGraph::Arc
785 AdjacencyListGraph::direct(
786 const AdjacencyListGraph::Edge & edge,
787 const AdjacencyListGraph::Node & node
790 return Arc(
id(edge),
id(edge));
792 else if(v(edge)==node){
793 return Arc(
id(edge)+maxEdgeId()+1,
id(edge));
796 return Arc(lemon::INVALID);
802 AdjacencyListGraph::direction(
803 const AdjacencyListGraph::Arc & arc
805 return id(arc)<=maxEdgeId();
809 inline AdjacencyListGraph::Node
810 AdjacencyListGraph::u(
811 const AdjacencyListGraph::Edge & edge
813 return Node(edges_[
id(edge)].u());
817 inline AdjacencyListGraph::Node
818 AdjacencyListGraph::v(
819 const AdjacencyListGraph::Edge & edge
821 return Node(edges_[
id(edge)].v());
826 inline AdjacencyListGraph::Node
827 AdjacencyListGraph::source(
828 const AdjacencyListGraph::Arc & arc
830 const index_type arcIndex = id(arc);
831 if (arcIndex > maxEdgeId() ){
832 const index_type edgeIndex = arc.edgeId();
833 const Edge edge = edgeFromId(edgeIndex);
837 const index_type edgeIndex = arcIndex;
838 const Edge edge = edgeFromId(edgeIndex);
845 inline AdjacencyListGraph::Node
846 AdjacencyListGraph::target(
847 const AdjacencyListGraph::Arc & arc
849 const index_type arcIndex = id(arc);
850 if (arcIndex > maxEdgeId() ){
851 const index_type edgeIndex = arc.edgeId();
852 const Edge edge = edgeFromId(edgeIndex);
856 const index_type edgeIndex = arcIndex;
857 const Edge edge = edgeFromId(edgeIndex);
862 inline AdjacencyListGraph::Node
863 AdjacencyListGraph::oppositeNode(
864 const AdjacencyListGraph::Node &n,
865 const AdjacencyListGraph::Edge &e
867 const Node uNode = u(e);
868 const Node vNode = v(e);
869 if(
id(uNode)==
id(n)){
872 else if(
id(vNode)==
id(n)){
882 inline AdjacencyListGraph::Node
883 AdjacencyListGraph::baseNode(
884 const AdjacencyListGraph::IncEdgeIt & iter
890 inline AdjacencyListGraph::Node
891 AdjacencyListGraph::baseNode(
892 const AdjacencyListGraph::OutArcIt & iter
894 return source(*iter);
899 inline AdjacencyListGraph::Node
900 AdjacencyListGraph::runningNode(
901 const AdjacencyListGraph::IncEdgeIt & iter
907 inline AdjacencyListGraph::Node
908 AdjacencyListGraph::runningNode(
909 const AdjacencyListGraph::OutArcIt & iter
911 return target(*iter);
915 inline AdjacencyListGraph::index_type
916 AdjacencyListGraph::edgeNum()
const{
921 inline AdjacencyListGraph::index_type
922 AdjacencyListGraph::nodeNum()
const{
927 inline AdjacencyListGraph::index_type
928 AdjacencyListGraph::arcNum()
const{
933 inline AdjacencyListGraph::index_type
934 AdjacencyListGraph::maxEdgeId()
const{
935 return edges_.back().id();
939 inline AdjacencyListGraph::index_type
940 AdjacencyListGraph::maxNodeId()
const{
941 return nodes_.back().id();
945 inline AdjacencyListGraph::index_type
946 AdjacencyListGraph::maxArcId()
const{
947 return maxEdgeId()*2+1;
952 inline AdjacencyListGraph::index_type
953 AdjacencyListGraph::id(
954 const AdjacencyListGraph::Node & node
960 inline AdjacencyListGraph::index_type
961 AdjacencyListGraph::id(
962 const AdjacencyListGraph::Edge & edge
968 inline AdjacencyListGraph::index_type
969 AdjacencyListGraph::id(
970 const AdjacencyListGraph::Arc & arc
977 inline AdjacencyListGraph::Edge
978 AdjacencyListGraph::edgeFromId(
979 const AdjacencyListGraph::index_type
id
981 if((std::size_t)
id < edges_.size() && edges_[
id].id() != -1)
982 return Edge(edges_[
id].
id());
984 return Edge(lemon::INVALID);
988 inline AdjacencyListGraph::Node
989 AdjacencyListGraph::nodeFromId(
990 const AdjacencyListGraph::index_type
id
992 if((std::size_t)
id < nodes_.size() && nodes_[
id].id() != -1)
993 return Node(nodes_[
id].
id());
995 return Node(lemon::INVALID);
999 inline AdjacencyListGraph::Arc
1000 AdjacencyListGraph::arcFromId(
1001 const AdjacencyListGraph::index_type
id
1003 if(
id<=maxEdgeId()){
1004 if(edgeFromId(
id)==lemon::INVALID)
1005 return Arc(lemon::INVALID);
1010 const index_type edgeId =
id - (maxEdgeId() + 1);
1011 if( edgeFromId(edgeId)==lemon::INVALID)
1012 return Arc(lemon::INVALID);
1014 return Arc(
id,edgeId);
1019 inline AdjacencyListGraph::Edge
1020 AdjacencyListGraph::findEdge(
1021 const AdjacencyListGraph::Node & a,
1022 const AdjacencyListGraph::Node & b
1025 std::pair<index_type,bool> res = nodes_[id(a)].findEdge(
id(b));
1027 return Edge(res.first);
1030 return Edge(lemon::INVALID);
1035 inline AdjacencyListGraph::Arc
1036 AdjacencyListGraph::findArc(
1037 const AdjacencyListGraph::Node & uNode,
1038 const AdjacencyListGraph::Node & vNode
1040 const Edge e = findEdge(uNode,vNode);
1041 if(e==lemon::INVALID){
1042 return Arc(lemon::INVALID);
1046 return direct(e,
true) ;
1048 return direct(e,
false) ;
1055 inline AdjacencyListGraph::vertex_iterator
1056 AdjacencyListGraph::get_vertex_iterator()
const{
1057 return NodeIt(0,nodeNum());
1061 inline AdjacencyListGraph::vertex_iterator
1062 AdjacencyListGraph::get_vertex_end_iterator()
const{
1063 return NodeIt(nodeNum(),nodeNum());
1068 inline AdjacencyListGraph::edge_iterator
1069 AdjacencyListGraph::get_edge_iterator()
const{
1070 return EdgeIt(0,edgeNum());
1074 inline AdjacencyListGraph::edge_iterator
1075 AdjacencyListGraph::get_edge_end_iterator()
const{
1076 return EdgeIt(edgeNum(),edgeNum());
1092 inline vigra::AdjacencyListGraph::vertex_size_type
1093 num_vertices(
const vigra::AdjacencyListGraph & g){
1096 inline vigra::AdjacencyListGraph::edge_size_type
1097 num_edges(
const vigra::AdjacencyListGraph & g){
1106 inline vigra::AdjacencyListGraph::degree_size_type
1107 degree(
const vigra::AdjacencyListGraph::vertex_descriptor & v ,
const vigra::AdjacencyListGraph & g){
1111 inline vigra::AdjacencyListGraph::degree_size_type
1112 in_degree(
const vigra::AdjacencyListGraph::vertex_descriptor & v ,
const vigra::AdjacencyListGraph & g){
1116 inline vigra::AdjacencyListGraph::degree_size_type
1117 out_degree(
const vigra::AdjacencyListGraph::vertex_descriptor & v ,
const vigra::AdjacencyListGraph & g){
1125 inline vigra::AdjacencyListGraph::vertex_descriptor
1126 source(
const vigra::AdjacencyListGraph::edge_descriptor & e ,
const vigra::AdjacencyListGraph & g){
1130 inline vigra::AdjacencyListGraph::vertex_descriptor
1131 target(
const vigra::AdjacencyListGraph::edge_descriptor & e ,
const vigra::AdjacencyListGraph & g){
1138 inline std::pair< vigra::AdjacencyListGraph::vertex_iterator, vigra::AdjacencyListGraph::vertex_iterator >
1139 vertices(
const vigra::AdjacencyListGraph & g ){
1140 return std::pair< vigra::AdjacencyListGraph::vertex_iterator, vigra::AdjacencyListGraph::vertex_iterator >(
1141 g.get_vertex_iterator(), g.get_vertex_end_iterator());
1143 inline std::pair< vigra::AdjacencyListGraph::edge_iterator, vigra::AdjacencyListGraph::edge_iterator >
1144 edges(
const vigra::AdjacencyListGraph & g ){
1145 return std::pair< vigra::AdjacencyListGraph::edge_iterator, vigra::AdjacencyListGraph::edge_iterator >(
1146 g.get_edge_iterator(),g.get_edge_end_iterator());
1150 inline std::pair< vigra::AdjacencyListGraph::in_edge_iterator, vigra::AdjacencyListGraph::in_edge_iterator >
1151 in_edges(
const vigra::AdjacencyListGraph::vertex_descriptor & v,
const vigra::AdjacencyListGraph & g ){
1152 return std::pair< vigra::AdjacencyListGraph::in_edge_iterator, vigra::AdjacencyListGraph::in_edge_iterator >(
1153 vigra::AdjacencyListGraph::in_edge_iterator(g,v),vigra::AdjacencyListGraph::in_edge_iterator(lemon::INVALID)
1156 inline std::pair< vigra::AdjacencyListGraph::out_edge_iterator, vigra::AdjacencyListGraph::out_edge_iterator >
1157 out_edges(
const vigra::AdjacencyListGraph::vertex_descriptor & v,
const vigra::AdjacencyListGraph & g ){
1158 return std::pair< vigra::AdjacencyListGraph::out_edge_iterator, vigra::AdjacencyListGraph::out_edge_iterator >(
1159 vigra::AdjacencyListGraph::out_edge_iterator(g,v),vigra::AdjacencyListGraph::out_edge_iterator(lemon::INVALID)
degree_size_type degree(vertex_descriptor const &v) const
Get the total number of edges (incoming plus outgoing) of the given vertex (convenience function,...
Definition multi_gridgraph.hxx:2486
edges_size_type edgeNum() const
Get the number of edges in this graph (API: LEMON).
Definition multi_gridgraph.hxx:2506
Node u(Edge const &e) const
Get the start node of the given edge e (API: LEMON, the boost::graph API provides the free function ...
Definition multi_gridgraph.hxx:2382
vertices_size_type nodeNum() const
Get the number of nodes in this graph (API: LEMON).
Definition multi_gridgraph.hxx:2091
Node v(Edge const &e) const
Get the end node of the given edge e (API: LEMON, the boost::graph API provides the free function bo...
Definition multi_gridgraph.hxx:2390
detail::SelectIntegerType< 64, detail::SignedIntTypes >::type Int64
64-bit signed int
Definition sized_int.hxx:177