[Boost-users] [BGL]Using a function for weightmap to dijkstra_shortest_path

23 Nov 2015

      Hi,

I am trying to write use BGL.dijkstra to calculate a shortest path in a
time dependent network where edge.cost C(u, v) is a function of
distance@edge.source and a variable wait time dependent on Edge.departure
i.e.

Cost(Edge(u,v), D(u)) = Wait(Edge(u, v).departure, D(u)) + Edge(u, v).delay

The cost function ( and edge property is defined as):

struct Eonnection {
    Eonnection(const Vertex source, const Vertex destination, const
double departure, const double duration, const double cost) {
        this->source = source;
        this->destination = destination;
        this->departure = departure;
        this->duration = duration;
        this->cost = cost;
    };

    Vertex source;
    Vertex destination;
    double departure; // Time of departure
    double duration;  // Duration of traversing edge
    double cost;      // Actual cost of traversing Edge

    std::pair dyn_cost(std::vector > distances, double t_max) {
        std::pair d_parent = distances[this->source];
        double t_parent = d_parent.first;
        double c_parent = d_parent.second;

        double t_time_of_day = fmod(t_parent, 24 * 3600);
        double t_delay = t_time_of_day <= this->departure ?
this->departure - t_time_of_day: this->departure + (24 * 3600 -
t_time_of_day);
        double t_total = t_parent + t_delay + this->duration;

        if(t_total < t_max) {
            std::cout << "Edge usable with cost " << c_parent +
this->cost << ", " << t_total << std::endl;
            return std::pair(c_parent + this->cost, t_total);
        } else {
            std::cout << "Edge unusable" << std::endl;
            return std::pair(std::numeric_limits<double>::infinity(),
std::numeric_limits<double>::infinity());
        }
    };

};

I'm trying to call dijkstra as

    dijkstra_shortest_paths_no_color_map(
        g, source,
        boost::make_iterator_property_map(pred.begin(),
get(boost::vertex_index, g)),
        boost::make_iterator_property_map(distances.begin(),
get(boost::vertex_index, g)),
        boost::make_transform_value_property_map(
            boost::bind
...
(&Eonnection::dyn_cost, _1, _2, distances, 24 * 3600 * 3),
            get(boost::edge_bundle, g)
        ),
        get(vertex_index, g), smaller, combiner,
        std::pair(std::numeric_limits<double>::infinity(),
std::numeric_limits<double>::infinity()),
        std::pair(0, 0), vis
    );
However, this does not seem to work. How can I pass the weights as a
dynamic function to dijkstra_shortest_paths?

[Boost-users] [BGL]Using a function for weightmap to dijkstra_shortest_path

Amit Prakash Ambasta