typename property_traits<CapacityEdgeMap>::value_type edmunds_karp_max_flow (Graph& g, typename graph_traits<Graph>::vertex_descriptor src, typename graph_traits<Graph>::vertex_descriptor sink, CapacityEdgeMap cap, ResidualCapacityEdgeMap res, ReverseEdgeMap rev, ColorMap color, PredEdgeMap pred) { typedef typename graph_traits<Graph>::vertex_descriptor vertex_t; typedef typename property_traits<ColorMap>::value_type ColorValue; typedef color_traits<ColorValue> Color; typename graph_traits<Graph>::vertex_iterator u_iter, u_end; typename graph_traits<Graph>::out_edge_iterator ei, e_end; for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei) res[*ei] = cap[*ei]; color[sink] = Color::gray(); while (color[sink] != Color::white()) { boost::queue<vertex_t> Q; breadth_first_search (detail::residual_graph(g, res), src, Q, make_bfs_visitor(record_edge_predecessors(pred, on_tree_edge())), color); if (color[sink] != Color::white()) detail::augment(g, src, sink, pred, res, rev); } // while typename property_traits<CapacityEdgeMap>::value_type flow = 0; for (tie(ei, e_end) = out_edges(src, g); ei != e_end; ++ei) flow += (cap[*ei] - res[*ei]); return flow; } // edmunds_karp_max_flow()
OutputIterator sloan_ordering(Graph& g, typename graph_traits<Graph>::vertex_descriptor s, typename graph_traits<Graph>::vertex_descriptor e, OutputIterator permutation, ColorMap color, DegreeMap degree, PriorityMap priority, Weight W1, Weight W2) { //typedef typename property_traits<DegreeMap>::value_type Degree; typedef typename property_traits<PriorityMap>::value_type Degree; typedef typename property_traits<ColorMap>::value_type ColorValue; typedef color_traits<ColorValue> Color; typedef typename graph_traits<Graph>::vertex_descriptor Vertex; typedef typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter; typedef typename graph_traits<Graph>::vertices_size_type size_type; typedef typename property_map<Graph, vertex_index_t>::const_type VertexID; //Creating a std-vector for storing the distance from the end vertex in it typename std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(g), 0); //Wrap a property_map_iterator around the std::iterator boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, g)); breadth_first_search (g, e, visitor ( make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) ) ); //Creating a property_map for the indices of a vertex typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, g); //Sets the color and priority to their initial status unsigned cdeg; typename graph_traits<Graph>::vertex_iterator ui, ui_end; for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) { put(color, *ui, Color::white()); cdeg=get(degree, *ui)+1; put(priority, *ui, W1*dist[index_map[*ui]]-W2*cdeg ); } //Priority list typedef indirect_cmp<PriorityMap, std::greater<Degree> > Compare; Compare comp(priority); std::list<Vertex> priority_list; //Some more declarations typename graph_traits<Graph>::out_edge_iterator ei, ei_end, ei2, ei2_end; Vertex u, v, w; put(color, s, Color::green()); //Sets the color of the starting vertex to gray priority_list.push_front(s); //Puts s into the priority_list while ( !priority_list.empty() ) { priority_list.sort(comp); //Orders the elements in the priority list in an ascending manner u = priority_list.front(); //Accesses the last element in the priority list priority_list.pop_front(); //Removes the last element in the priority list if(get(color, u) == Color::green() ) { //for-loop over all out-edges of vertex u for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { v = target(*ei, g); put( priority, v, get(priority, v) + W2 ); //updates the priority if (get(color, v) == Color::white() ) //test if the vertex is inactive { put(color, v, Color::green() ); //giving the vertex a preactive status priority_list.push_front(v); //writing the vertex in the priority_queue } } } //Here starts step 8 *permutation++ = u; //Puts u to the first position in the permutation-vector put(color, u, Color::black() ); //Gives u an inactive status //for loop over all the adjacent vertices of u for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) { v = target(*ei, g); if (get(color, v) == Color::green() ) { //tests if the vertex is inactive put(color, v, Color::red() ); //giving the vertex an active status put(priority, v, get(priority, v)+W2); //updates the priority //for loop over alll adjacent vertices of v for (boost::tie(ei2, ei2_end) = out_edges(v, g); ei2 != ei2_end; ++ei2) { w = target(*ei2, g); if(get(color, w) != Color::black() ) { //tests if vertex is postactive put(priority, w, get(priority, w)+W2); //updates the priority if(get(color, w) == Color::white() ){ put(color, w, Color::green() ); // gives the vertex a preactive status priority_list.push_front(w); // puts the vertex into the priority queue } //end if } //end if } //end for } //end if } //end for } //end while return permutation; }
typename graph_traits<Graph>::vertex_descriptor sloan_start_end_vertices(Graph& G, typename graph_traits<Graph>::vertex_descriptor &s, ColorMap color, DegreeMap degree) { typedef typename property_traits<DegreeMap>::value_type Degree; typedef typename graph_traits<Graph>::vertex_descriptor Vertex; typedef typename std::vector< typename graph_traits<Graph>::vertices_size_type>::iterator vec_iter; typedef typename graph_traits<Graph>::vertices_size_type size_type; typedef typename property_map<Graph, vertex_index_t>::const_type VertexID; s = *(vertices(G).first); Vertex e = s; Vertex i; unsigned my_degree = get(degree, s ); unsigned dummy, h_i, h_s, w_i, w_e; bool new_start = true; unsigned maximum_degree = 0; //Creating a std-vector for storing the distance from the start vertex in dist std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(G), 0); //Wrap a property_map_iterator around the std::iterator boost::iterator_property_map<vec_iter, VertexID, size_type, size_type&> dist_pmap(dist.begin(), get(vertex_index, G)); //Creating a property_map for the indices of a vertex typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, G); //Creating a priority queue typedef indirect_cmp<DegreeMap, std::greater<Degree> > Compare; Compare comp(degree); std::priority_queue<Vertex, std::vector<Vertex>, Compare> degree_queue(comp); //step 1 //Scan for the vertex with the smallest degree and the maximum degree typename graph_traits<Graph>::vertex_iterator ui, ui_end; for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui) { dummy = get(degree, *ui); if(dummy < my_degree) { my_degree = dummy; s = *ui; } if(dummy > maximum_degree) { maximum_degree = dummy; } } //end 1 do{ new_start = false; //Setting the loop repetition status to false //step 2 //initialize the the disance std-vector with 0 for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0; //generating the RLS (rooted level structure) breadth_first_search (G, s, visitor ( make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) ) ); //end 2 //step 3 //calculating the depth of the RLS h_s = RLS_depth(dist); //step 4 //pushing one node of each degree in an ascending manner into degree_queue std::vector<bool> shrink_trace(maximum_degree, false); for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui) { dummy = get(degree, *ui); if( (dist[index_map[*ui]] == h_s ) && ( !shrink_trace[ dummy ] ) ) { degree_queue.push(*ui); shrink_trace[ dummy ] = true; } } //end 3 & 4 // step 5 // Initializing w w_e = (std::numeric_limits<unsigned>::max)(); //end 5 //step 6 //Testing for termination while( !degree_queue.empty() ) { i = degree_queue.top(); //getting the node with the lowest degree from the degree queue degree_queue.pop(); //ereasing the node with the lowest degree from the degree queue //generating a RLS for(typename std::vector<typename graph_traits<Graph>::vertices_size_type>::iterator iter = dist.begin(); iter != dist.end(); ++iter) *iter = 0; breadth_first_search (G, i, boost::visitor ( make_bfs_visitor(record_distances(dist_pmap, on_tree_edge() ) ) ) ); //Calculating depth and width of the rooted level h_i = RLS_depth(dist); w_i = RLS_max_width(dist, h_i); //Testing for termination if( (h_i > h_s) && (w_i < w_e) ) { h_s = h_i; s = i; while(!degree_queue.empty()) degree_queue.pop(); new_start = true; } else if(w_i < w_e) { w_e = w_i; e = i; } } //end 6 }while(new_start); return e; }
void tree_edge(Edge e, Graph& g) { invoke_visitors(m_vis, e, g, on_tree_edge()); }
void evaluateGeodesicDist(GridSpecs grid_specs, std::vector<Polygon_2> polygons, std::vector<Point> ref_points, IOSpecs io_specs) { // -- grid definition -- // no. of rows and columns int no_rows, no_cols; no_rows = (int)grid_specs.getGridSpecs().at(0); no_cols = (int)grid_specs.getGridSpecs().at(1); // grid points int no_gpoints; no_gpoints = (no_rows*no_cols); // spatial locations of the grid points std::vector<Point_2> grid_points; // evaluating the spatial locations of the grid points initGrid(grid_specs, grid_points); //-- // -- graph definition -- // // note that two different graphs need to be considered: // // 1) effective graph - // graph associated with the complementary domain; // the nodes of this graph do not include the grid points // associated with the polygon(s); // // 2) BGL graph - // graph processed by the BGL library; // this graph coincides with the grid; // the nodes of this graph coincide the grid points; // the nodes associated with the polygon(s) are nodes // with no edges, i.e. they are nodes of degree zero; // // // no. of nodes (effective graph) < no. of nodes (BGL graph) // no. of edges (effective graph) = no. of edges (BGL graph) // // grid points IDs associated with the polygon(s) std::vector<Polygon_gp_id> gpoints_id_pgn; // grid points IDs associated with the graph std::vector<int> gpoints_id_graph; // project the data to the grid; // evaluate the grid points IDs associated with the polygon(s) and // those associated with the complementary domain (graph) projectDataToGrid(grid_points, polygons, gpoints_id_pgn, gpoints_id_graph); // no. of grid points associated with the polygon int no_gpoints_png = gpoints_id_pgn.at(0).size(); // no. of grid points associated with the graph int no_gpoints_graph = gpoints_id_graph.size(); // writing output file `Dreses.dat' std::string outfile_name_1("Dreses.dat"); OutputProcess_Dreses out1(io_specs.getAbsolutePathName(outfile_name_1)); out1.toOutput(ref_points, polygons, grid_specs, no_gpoints_png, no_gpoints_graph); grid_points.clear(); polygons.clear(); // names of the nodes (vertices) std::vector<std::string> node_names; // edges std::vector<Edge> edges; // evaluating the node names and the edges of the `effective graph' initGraph(grid_specs, gpoints_id_pgn, gpoints_id_graph, node_names, edges); gpoints_id_pgn.clear(); gpoints_id_graph.clear(); // number of edges int no_edges; no_edges = edges.size(); // weights float* weights = new float[no_edges]; for (int i=0; i<no_edges; i++) { weights[i] = grid_specs.getGridSpecs().at(2); } // BGL graph GridGraph g(edges.begin(), edges.end(), weights, no_gpoints); GridGraph g_copy(edges.begin(), edges.end(), weights, no_gpoints); //-- #ifdef DEBUG_GRAPH std::cout << "\n>> debug - graph" << std::endl; std::cout << "no. of nodes (effective graph): " << node_names.size() << std::endl; std::cout << "no. of nodes (BGL graph): " << no_gpoints << std::endl; std::cout << "no. of edges: " << edges.size() << std::endl; write_graphviz(std::cout, g); #endif // DEBUG_GRAPH //-- // parents of the nodes std::vector<vertex_descriptor> parents(num_vertices(g)); // source node ID // note that node ID = (grid point ID - 1) int s_node_id; s_node_id = (getGridPointID(ref_points.at(0).first, ref_points.at(0).second, grid_specs) - 1); // source node vertex_descriptor s_node = vertex(s_node_id, g); // the parent of `s_node' is `s_node' (distance = 0) parents[s_node] = s_node; // distances from the source to each node // (including the null distances - i.e. the distance from the source to itself // and the distances from the source to the nodes of degree zero) vertices_size_type distances[no_gpoints]; std::fill_n(distances, no_gpoints, 0); // evaluating the distances by using the Breadth-First Search (BFS) algorithm breadth_first_search(g, s_node, visitor(make_bfs_visitor(std::make_pair(record_distances(distances, on_tree_edge()), std::make_pair(record_predecessors(&parents[0], on_tree_edge()), copy_graph(g_copy, on_examine_edge()) ) ) ) ) ); // writing output file `distances.dat' std::string outfile_name_2("distances.dat"); OutputProcess_Distances out2(io_specs.getAbsolutePathName(outfile_name_2)); out2.toOutput(grid_specs, no_gpoints, s_node_id, node_names, distances); delete [] weights; }