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_;
 
  232         typedef Int64                                                     index_type;
 
  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;
 
  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>(){
 
  298             : DenseEdgeReferenceMap<GraphType,T>(g){
 
  301             : DenseEdgeReferenceMap<GraphType,T>(g,val){
 
  307         struct NodeMap : DenseNodeReferenceMap<GraphType,T> {
 
  308             NodeMap(): DenseNodeReferenceMap<GraphType,T>(){
 
  311             : DenseNodeReferenceMap<GraphType,T>(g){
 
  314             : DenseNodeReferenceMap<GraphType,T>(g,val){
 
  320         struct ArcMap : DenseArcReferenceMap<GraphType,T> {
 
  321             ArcMap(): DenseArcReferenceMap<GraphType,T>(){
 
  324             : DenseArcReferenceMap<GraphType,T>(g){
 
  327             : DenseArcReferenceMap<GraphType,T>(g,val){
 
  416         index_type 
id(
const Node & node)
const;
 
  422         index_type 
id(
const Arc  & arc )
const;
 
  454         Node addNode(
const index_type 
id);
 
  460         void assignNodeRange(
const index_type beginId, 
const index_type endId);
 
  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                 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 ){
 
  503                 nodes_.reserve(mxid+1);
 
  506         void reserveEdges(
const size_t size ){
 
  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;
 
  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);
 
  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()];
 
  665 #ifndef DOXYGEN  // doxygen doesn't like out-of-line definitions 
  668         const size_t reserveNodes,
 
  669         const size_t reserveEdges
 
  676         nodes_.reserve(reserveNodes);
 
  677         edges_.reserve(reserveEdges);
 
  682     AdjacencyListGraph::addNode(){
 
  683         const index_type 
id = nodes_.size();
 
  684         nodes_.push_back(NodeStorage(
id));
 
  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()){
 
  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);
 
  733     AdjacencyListGraph::addEdge(
 
  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);
 
  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);
 
  773         if(edge!=lemon::INVALID){
 
  775                 return Arc(
id(edge),
id(edge));
 
  780             return Arc(lemon::INVALID);
 
  790             return Arc(
id(edge),
id(edge));
 
  792         else if(
v(edge)==node){
 
  796             return Arc(lemon::INVALID);
 
  813         return Node(edges_[
id(edge)].
u());
 
  821         return Node(edges_[
id(edge)].
v());
 
  830         const index_type arcIndex  = 
id(arc);
 
  832             const index_type edgeIndex = arc.edgeId();
 
  837             const index_type edgeIndex = arcIndex;
 
  849         const index_type arcIndex  = 
id(arc);
 
  851             const index_type edgeIndex = arc.edgeId();
 
  856             const index_type edgeIndex = arcIndex;
 
  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)){
 
  915     inline AdjacencyListGraph::index_type 
 
  921     inline AdjacencyListGraph::index_type 
 
  927     inline AdjacencyListGraph::index_type 
 
  933     inline AdjacencyListGraph::index_type 
 
  935         return edges_.back().id();
 
  939     inline AdjacencyListGraph::index_type 
 
  941         return nodes_.back().id();
 
  945     inline AdjacencyListGraph::index_type 
 
  952     inline AdjacencyListGraph::index_type 
 
  960     inline AdjacencyListGraph::index_type 
 
  968     inline AdjacencyListGraph::index_type 
 
  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);
 
  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);
 
 1001         const AdjacencyListGraph::index_type 
id 
 1005                 return Arc(lemon::INVALID);
 
 1010             const index_type edgeId = 
id - (
maxEdgeId() + 1);
 
 1012                 return Arc(lemon::INVALID);
 
 1014                 return Arc(
id,edgeId);
 
 1025             std::pair<index_type,bool> res =  nodes_[
id(a)].findEdge(
id(b));
 
 1027                 return Edge(res.first);
 
 1030         return Edge(lemon::INVALID);
 
 1041         if(e==lemon::INVALID){
 
 1042             return Arc(lemon::INVALID);
 
 1055     inline AdjacencyListGraph::vertex_iterator 
 
 1056     AdjacencyListGraph::get_vertex_iterator()
const{
 
 1061     inline AdjacencyListGraph::vertex_iterator 
 
 1062     AdjacencyListGraph::get_vertex_end_iterator()
const{  
 
 1068     inline AdjacencyListGraph::edge_iterator 
 
 1069     AdjacencyListGraph::get_edge_iterator()
const{
 
 1074     inline AdjacencyListGraph::edge_iterator 
 
 1075     AdjacencyListGraph::get_edge_end_iterator()
const{  
 
 1092     inline vigra::AdjacencyListGraph::vertex_size_type
 
 1096     inline vigra::AdjacencyListGraph::edge_size_type
 
 1106     inline vigra::AdjacencyListGraph::degree_size_type
 
 1111     inline vigra::AdjacencyListGraph::degree_size_type
 
 1116     inline vigra::AdjacencyListGraph::degree_size_type
 
 1125     inline vigra::AdjacencyListGraph::vertex_descriptor
 
 1130     inline vigra::AdjacencyListGraph::vertex_descriptor
 
 1138     inline  std::pair< vigra::AdjacencyListGraph::vertex_iterator, vigra::AdjacencyListGraph::vertex_iterator >
 
 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 >
 
 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 >
 
 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 >
 
 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)
 
vigra::GridGraph< N, DirectedTag >::degree_size_type degree(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Return total number of edges (incoming and outgoing) of vertex v (API: boost). 
Definition: multi_gridgraph.hxx:2828
vigra::GridGraph< N, DirectedTag >::edges_size_type num_edges(vigra::GridGraph< N, DirectedTag > const &g)
Return the number of edges in graph g (API: boost). 
Definition: multi_gridgraph.hxx:2976
Edge edgeFromId(const index_type id) const 
Get edge descriptor for given node ID i (API: LEMON). Return Edge(lemon::INVALID) when the ID does no...
default node map 
Definition: adjacency_list_graph.hxx:307
vigra::GridGraph< N, DirectedTag >::vertex_descriptor target(typename vigra::GridGraph< N, DirectedTag >::edge_descriptor const &e, vigra::GridGraph< N, DirectedTag > const &g)
Get a vertex descriptor for the end vertex of edge e in graph g (API: boost). 
Definition: multi_gridgraph.hxx:2954
vigra::GridGraph< N, DirectedTag >::degree_size_type out_degree(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Return number of outgoing edges of vertex v (API: boost). 
Definition: multi_gridgraph.hxx:2806
index_type id(const Node &node) const 
Get the ID for node desciptor v (API: LEMON). 
Node nodeFromId(const index_type id) const 
Get node descriptor for given node ID i (API: LEMON). Return Node(lemon::INVALID) when the ID does no...
detail::GenericIncEdgeIt< GraphType, NodeStorage, OutFilter > OutArcIt
outgoing arc iterator 
Definition: adjacency_list_graph.hxx:264
detail::GenericEdge< index_type > Edge
edge descriptor 
Definition: adjacency_list_graph.hxx:249
index_type maxEdgeId() const 
Get the maximum ID of any edge in this graph (API: LEMON). 
detail::GenericArc< index_type > Arc
arc descriptor 
Definition: adjacency_list_graph.hxx:251
default arc map 
Definition: adjacency_list_graph.hxx:320
vigra::GridGraph< N, DirectedTag >::degree_size_type in_degree(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Return number of incoming edges of vertex v (API: boost). 
Definition: multi_gridgraph.hxx:2817
std::pair< typename vigra::GridGraph< N, DirectedTag >::out_edge_iterator, typename vigra::GridGraph< N, DirectedTag >::out_edge_iterator > out_edges(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Get a (begin, end) iterator pair for the outgoing edges of vertex v in graph g (API: boost)...
Definition: multi_gridgraph.hxx:2903
index_type maxNodeId() const 
Get the maximum ID of any node in this graph (API: LEMON). 
undirected adjacency list graph in the LEMON API 
Definition: adjacency_list_graph.hxx:227
Arc direct(const Edge &edge, const bool forward) const 
Create an arc for the given edge e, oriented along the edge's natural (forward = true) or reversed (f...
Node oppositeNode(Node const &n, const Edge &e) const 
Return the opposite node of the given node n along edge e (API: LEMON), or return lemon::INVALID if t...
detail::SelectIntegerType< 64, detail::SignedIntTypes >::type Int64
64-bit signed int 
Definition: sized_int.hxx:177
default edge map 
Definition: adjacency_list_graph.hxx:294
index_type maxArcId() const 
Get the maximum ID of any edge in arc graph (API: LEMON). 
detail_adjacency_list_graph::ItemIter< GraphType, Node > NodeIt
node iterator 
Definition: adjacency_list_graph.hxx:255
AdjacencyListGraph(const size_t nodes=0, const size_t edges=0)
Constructor. 
std::pair< typename vigra::GridGraph< N, DirectedTag >::in_edge_iterator, typename vigra::GridGraph< N, DirectedTag >::in_edge_iterator > in_edges(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Get a (begin, end) iterator pair for the incoming edges of vertex v in graph g (API: boost)...
Definition: multi_gridgraph.hxx:2931
bool direction(const Arc &arc) const 
Return true when the arc is looking on the underlying edge in its natural (i.e. forward) direction...
vigra::GridGraph< N, DirectedTag >::vertices_size_type num_vertices(vigra::GridGraph< N, DirectedTag > const &g)
Return the number of vertices in graph g (API: boost). 
Definition: multi_gridgraph.hxx:2851
detail::GenericIncEdgeIt< GraphType, NodeStorage, BackOutFilter > OutBackArcIt
outgoing back arc iterator 
Definition: adjacency_list_graph.hxx:270
std::pair< typename vigra::GridGraph< N, DirectedTag >::vertex_iterator, typename vigra::GridGraph< N, DirectedTag >::vertex_iterator > vertices(vigra::GridGraph< N, DirectedTag > const &g)
Get a (begin, end) iterator pair for the vertices of graph g (API: boost). 
Definition: multi_gridgraph.hxx:2840
Node baseNode(const IncEdgeIt &iter) const 
Return the start node of the edge the given iterator is referring to (API: LEMON). 
vigra::GridGraph< N, DirectedTag >::vertex_descriptor source(typename vigra::GridGraph< N, DirectedTag >::edge_descriptor const &e, vigra::GridGraph< N, DirectedTag > const &g)
Get a vertex descriptor for the start vertex of edge e in graph g (API: boost). 
Definition: multi_gridgraph.hxx:2943
std::pair< typename vigra::GridGraph< N, DirectedTag >::edge_iterator, typename vigra::GridGraph< N, DirectedTag >::edge_iterator > edges(vigra::GridGraph< N, DirectedTag > const &g)
Get a (begin, end) iterator pair for the edges of graph g (API: boost). 
Definition: multi_gridgraph.hxx:2966
detail::GenericIncEdgeIt< GraphType, NodeStorage, IncFilter > IncEdgeIt
incident edge iterator 
Definition: adjacency_list_graph.hxx:260
detail_adjacency_list_graph::ArcIt< GraphType > ArcIt
arc iterator 
Definition: adjacency_list_graph.hxx:257
index_type nodeNum() const 
Get the number of nodes in this graph (API: LEMON). 
std::pair< typename vigra::GridGraph< N, DirectedTag >::edge_descriptor, bool > edge(typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &u, typename vigra::GridGraph< N, DirectedTag >::vertex_descriptor const &v, vigra::GridGraph< N, DirectedTag > const &g)
Return the pair (edge_descriptor, true) when an edge between vertices u and v exists, or (lemon::INVALID, false) otherwise (API: boost). 
Definition: multi_gridgraph.hxx:2990
index_type arcNum() const 
Get the number of arcs in this graph (API: LEMON). 
Arc arcFromId(const index_type id) const 
Get arc descriptor for given node ID i (API: LEMON). Return Arc(lemon::INVALID) when the ID does not ...
Node v(const Edge &edge) const 
Get the end node of the given edge e (API: LEMON,  the boost::graph API provides the free function bo...
Edge findEdge(const Node &a, const Node &b) const 
Get a descriptor for the edge connecting vertices u and v, or lemon::INVALID if no such edge exists (...
Node source(const Arc &arc) const 
Get the start node of the given arc a (API: LEMON). 
detail::GenericNode< index_type > Node
node descriptor 
Definition: adjacency_list_graph.hxx:247
Node target(const Arc &arc) const 
Get the end node of the given arc a (API: LEMON). 
index_type edgeNum() const 
Get the number of edges in this graph (API: LEMON). 
Arc findArc(const Node &u, const Node &v) const 
Get a descriptor for the arc connecting vertices u and v, or lemon::INVALID if no such edge exists (A...
Node u(const Edge &edge) const 
Get the start node of the given edge e (API: LEMON,  the boost::graph API provides the free function ...
detail::GenericIncEdgeIt< GraphType, NodeStorage, InFlter > InArcIt
incoming arc iterator 
Definition: adjacency_list_graph.hxx:262
Node runningNode(const IncEdgeIt &iter) const 
Return the end node of the edge the given iterator is referring to (API: LEMON). 
detail_adjacency_list_graph::ItemIter< GraphType, Edge > EdgeIt
edge iterator 
Definition: adjacency_list_graph.hxx:253