提升BGL Dijkstra最短路径

Question

I'm not familiar with boost libraries and trying to learn. I have used boost graphics library to call dijstra's shortest paths function to find a path to destination in a map. Vertices are intersections and edges are street segments.

I am finding the shortest path by minimum time. For that I have edge weights defined as time, time = st segment length * its speed/limit. This indeed does give me the shortest path (by time). However, I'm to also account for a turn and add 15 seconds to total time for each. How I detect a turn is given two street segments (edges), if the st name of second is not equal to st name of first, it's a turn.

Basically, I want to assign weights dynamically (not just setting them in the beginning like I'm doing here). When the program visits an edge during the search, I'd like it to check the parents (or predecessors here) at this stage. How do I pass in a function or something in the arguments that can do it?

vector<unsigned>  OurGraph::find_awesome_path(unsigned start, unsigned finish)
{

    // start and finish are intersection IDs,
    // Get the corresponding Vertices in the graph. 
    Vertex start_node = vertex_map[start]; 
    Vertex dest_node = vertex_map[finish];   

    std::vector<Vertex> predecessors(boost::num_vertices(my_graph)); // To store parents
    std::vector<float> distances(boost::num_vertices(my_graph)); // To store dijkstra distances

    IndexMap indexMap = boost::get(boost::vertex_index, my_graph);
    PredecessorMap predecessorMap(&predecessors[0], indexMap);
    DistanceMap distanceMap(&distances[0], indexMap);

    boost::dijkstra_shortest_paths(my_graph, start_node, boost::distance_map(distanceMap).predecessor_map(predecessorMap));
vector<Edge> path;

    path = get_edge_path(dest_node, predecessorMap);    // Extracts edges from edge descriptors in predecessor map
                                                    // and piles them in a vector of Edge. 
    return segment_list_from_edges(path);           // Convert edges to street segment IDs and return.
}

Where my_graph is a type Graph and Graph , Vertex, Edge, IndexMap, PredecessorMap and DistanceMap are type defined as following:

typedef boost::property<boost::edge_weight_t, float> WeightProperty;
typedef boost::property<boost::vertex_name_t, unsigned> IntersectionProperty;  
typedef boost::adjacency_list < boost::listS, boost::vecS, boost::directedS,
  IntersectionProperty, WeightProperty > Graph;
typedef boost::graph_traits < Graph >::vertex_descriptor Vertex;
typedef boost::graph_traits < Graph >::edge_descriptor Edge;
typedef boost::property_map < Graph, boost::vertex_index_t >::type IndexMap;
typedef boost::iterator_property_map < Vertex*, IndexMap, Vertex, Vertex& > PredecessorMap;
typedef boost::iterator_property_map < float*, IndexMap, float, float& > DistanceMap;

Answer 1

One way you can do this is to use a differential graph. In that case each vertex in the differential graph would be equivalent to an edge in your current graph. So a vertex would encapsulate a turn for example. Then you can add the turn weights to the edges which involve a change in street name (or whatever mechanism you use to determine turns.)