int
main(int argc,char* argv[])
{
const char* filename = (argc > 1) ? argv[1] : "data/points.xy";
std::ifstream input(filename);
Triangulation t;
Filter is_finite(t);
Finite_triangulation ft(t, is_finite, is_finite);
Point p ;
while(input >> p){
t.insert(p);
}
vertex_iterator vit, ve;
// Associate indices to the vertices
int index = 0;
// boost::tie assigns the first and second element of the std::pair
// returned by boost::vertices to the variables vit and ve
for(boost::tie(vit,ve)=boost::vertices(ft); vit!=ve; ++vit ){
vertex_descriptor vd = *vit;
vertex_id_map[vd]= index++;
}
// Dijkstra's shortest path needs property maps for the predecessor and distance
// We first declare a vector
std::vector<vertex_descriptor> predecessor(boost::num_vertices(ft));
// and then turn it into a property map
boost::iterator_property_map<std::vector<vertex_descriptor>::iterator,
VertexIdPropertyMap>
predecessor_pmap(predecessor.begin(), vertex_index_pmap);
std::vector<double> distance(boost::num_vertices(ft));
boost::iterator_property_map<std::vector<double>::iterator,
VertexIdPropertyMap>
distance_pmap(distance.begin(), vertex_index_pmap);
// start at an arbitrary vertex
vertex_descriptor source = *boost::vertices(ft).first;
std::cout << "\nStart dijkstra_shortest_paths at " << source->point() <<"\n";
boost::dijkstra_shortest_paths(ft, source,
distance_map(distance_pmap)
.predecessor_map(predecessor_pmap)
.vertex_index_map(vertex_index_pmap));
for(boost::tie(vit,ve)=boost::vertices(ft); vit!=ve; ++vit ){
vertex_descriptor vd = *vit;
std::cout << vd->point() << " [" << vertex_id_map[vd] << "] ";
std::cout << " has distance = " << boost::get(distance_pmap,vd)
<< " and predecessor ";
vd = boost::get(predecessor_pmap,vd);
std::cout << vd->point() << " [" << vertex_id_map[vd] << "]\n ";
}
return 0;
}
DijkstraResult dijkstra (const Graph& g, const GraphVertex& src)
{
// Define some additional map types to store the weights and indices
// used within Dijkstra's algorithm
typedef map<GraphEdge, double> WeightMap;
typedef map<GraphVertex, unsigned> IndexMap;
// dijkstra_shortest_paths further requires std::map to be
// wrapped in a "Property Map"
typedef boost::associative_property_map<DistanceMap> DistancePMap;
typedef boost::associative_property_map<PredecessorMap> PredecessorPMap;
typedef boost::associative_property_map<WeightMap> WeightPMap;
typedef boost::associative_property_map<IndexMap> IndexPMap;
// OK, step 1: set the indices arbitrarily, because bgl won't do this for you
IndexMap imap;
IndexPMap index_pmap(imap);
{
unsigned ind=0;
BOOST_FOREACH (const GraphVertex& v, vertices(g))
imap[v] = ind++;
}
// Step 2: set the weights, using the edge lengths
WeightMap wmap;
WeightPMap weight_pmap(wmap);
BOOST_FOREACH (const GraphEdge& e, edges(g))
{
const double l = util::length(g[e].constraint.constraint.pose.position);
wmap[e] = l;
}
// Step 3: set up output maps
DistanceMap dmap;
DistancePMap distance_pmap(dmap);
PredecessorMap pmap;
PredecessorPMap predecessor_pmap(pmap);
// Step 4: make the call
boost::dijkstra_shortest_paths(g, src, weight_map(weight_pmap).vertex_index_map(index_pmap).
distance_map(distance_pmap).predecessor_map(predecessor_pmap));
// Step 5: Return
return DijkstraResult(dmap, pmap);
}
