How to access edge information in Boost Graph?

Question

The main question:

I am able to create a graph implementation with information structs assigned to the vertices and edges:

struct vertex_info {std::string name;};
struct edge_info {std::string name;};

typedef boost::adjacency_list<
  boost::vecS,
  boost::vecS,
  boost::undirectedS,
  vertex_info,
  edge_info> UndirectedGraph;

And for an instance of UndirectedGraph, g, I can easily iterate over the vertices, and access their information:

for(size_t i=0; i<boost::num_vertices(g); i++){
  std::cout << g[i].name << std::endl;
}

but I am unable to figure out how to do the same for the edges. I have come across some iterators to loop over all the edges, but I cannot access these edges as some kind of object or something with properties. How can I access the edge information of g?

A minimal working demonstration:

#include <iostream>
#include <utility>
#include <vector>
#include <string>

#include "boost/graph/graph_traits.hpp"
#include "boost/graph/adjacency_list.hpp"

int main(int argc, char *argv[])
{

  //Add vertex information struct
  struct vertex_info {
    std::string name;
  };

  //Add edge information struct
  struct edge_info {
    std::string name;
  };

  //Typedef my graph implimentation
  typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, vertex_info, edge_info> UndirectedGraph;

  //Our set of edges, and count N: (0-7) and 8
  enum {C, D, G, I, S, J, L, H, N};
  const char *name = "CDGISJLH";

  //Create a vector of edges
  typedef std::pair<int, int> Edge;
  std::vector<Edge> edgeVec;
  edgeVec.push_back(Edge(C,D));
  edgeVec.push_back(Edge(D,G));
  edgeVec.push_back(Edge(I,G));
  edgeVec.push_back(Edge(G,L));
  edgeVec.push_back(Edge(H,G));
  edgeVec.push_back(Edge(I,S));
  edgeVec.push_back(Edge(S,J));
  edgeVec.push_back(Edge(L,J));
  edgeVec.push_back(Edge(H,J));

  //Now we can initialize our graph using iterators from our above vector
  UndirectedGraph g(edgeVec.begin(), edgeVec.end(), N);

  std::cout << num_edges(g) << "\n";  //Outputs: 9

  //loop over vertices, access "name" property
  for(size_t i=0; i<boost::num_vertices(g); i++){
    //And add information to the edges
    g[i].name = "foo";
  }

  //We can access the first vertice and print the property
  std::cout << g[0].name << std::endl; //Outputs: foo

  //Edge iterator for or graph
  typedef boost::graph_traits<UndirectedGraph>::edge_iterator edge_iterator;

  //Iterate through all the edges
  std::pair<edge_iterator, edge_iterator> ei = boost::edges(g);
  for(edge_iterator edge_iter = ei.first; edge_iter != ei.second; ++edge_iter) {
   //How can I access the edge property???

  }
}

Answer 1

I have figure out the problem by walking through this example: https://www.boost.org/doc/libs/1_71_0/libs/graph/doc/bundles.html

The fix:

Although I still don't exactly understand how it all works. It seems like you have to use edge_iter as some kind of index into g:

//Edge iterator for or graph
typedef boost::graph_traits<MRFGraph>::edge_iterator edge_iterator;

//Iterate through all the edges
std::pair<edge_iterator, edge_iterator> ei = boost::edges(g);
for(edge_iterator edge_iter = ei.first; edge_iter != ei.second; ++edge_iter) {
  g[*edge_iter].name = "bar";
  std::cout << *edge_iter << ": " << g[*edge_iter].name << std::endl;
}

Output:

If I add this to the minimal working demonstration, it produces the following output:

9
foo
(0,1): bar
(1,2): bar
(3,2): bar
(2,6): bar
(7,2): bar
(3,4): bar
(4,5): bar
(6,5): bar
(7,5): bar

Answer 2

May not be exactly what you are looking for but does achieve what you are after

#include <iostream>
#include <utility>
#include <vector>
#include <string>

#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>

namespace boost {
enum edge_myname_t { edge_myname };
BOOST_INSTALL_PROPERTY(boost::edge, myname);
}

int main(int argc, char* argv[]) {
  // Add vertex information struct
  struct vertex_info {
    std::string name;
  };

  // Add edge information struct
  //struct edge_info {
    //std::string name;
  //};

  using EdgeName = boost::property<boost::edge_myname_t, std::string>;

  // Typedef my graph implimentation
  using UndirectedGraph =
      boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
                            vertex_info, EdgeName>;

  // Our set of edges, and count N: (0-7) and 8
  enum { C, D, G, I, S, J, L, H, N };
  const char* name = "CDGISJLH";

  // Create a vector of edges
  //using Edge = std::pair<int, int>;
  //std::vector<Edge> edgeVec;
  //edgeVec.push_back(Edge(C, D));
  //edgeVec.push_back(Edge(D, G));
  //edgeVec.push_back(Edge(I, G));
  //edgeVec.push_back(Edge(G, L));
  //edgeVec.push_back(Edge(H, G));
  //edgeVec.push_back(Edge(I, S));
  //edgeVec.push_back(Edge(S, J));
  //edgeVec.push_back(Edge(L, J));
  //edgeVec.push_back(Edge(H, J));

  // Now we can initialize our graph using iterators from our above vector
  UndirectedGraph g(N);
  //UndirectedGraph g(edgeVec.begin(), edgeVec.end(), N);

  boost::add_edge(C, D, EdgeName("#1"), g);
  boost::add_edge(D, G, EdgeName("#2"), g);
  boost::add_edge(I, G, EdgeName("#3"), g);
  boost::add_edge(G, L, EdgeName("#4"), g);
  boost::add_edge(H, G, EdgeName("#5"), g);
  boost::add_edge(I, S, EdgeName("#6"), g);
  boost::add_edge(S, J, EdgeName("#7"), g);
  boost::add_edge(L, J, EdgeName("#8"), g);
  boost::add_edge(H, J, EdgeName("#9"), g);

  boost::property_map<UndirectedGraph, boost::edge_myname_t>::type get_name =
      boost::get(boost::edge_myname, g);

  std::cout << num_edges(g) << "\n";  // Outputs: 9

  // loop over vertices, access "name" property
  for (size_t i = 0; i < boost::num_vertices(g); i++) {
    // And add information to the edges
    g[i].name = "foo";
  }

  // We can access the first vertice and print the property
  std::cout << g[0].name << std::endl;  // Outputs: foo

  // Edge iterator for or graph
  using EdgeIterator = boost::graph_traits<UndirectedGraph>::edge_iterator;

  // Iterate through all the edges
  std::pair<EdgeIterator, EdgeIterator> ei = boost::edges(g);
  for (EdgeIterator edge_iter = ei.first; edge_iter != ei.second; ++edge_iter) {
    // How can I access the edge property???
    std::cout << get_name[*edge_iter] << "\n";
  }
}

I just slightly modified some of the code for my own readability issues.

For reference, check this out.