void breadth_first_visit
(const IncidenceGraph& g,
typename graph_traits<IncidenceGraph>::vertex_descriptor s,
const bgl_named_params<P, T, R>& params)
{
// The graph is passed by *const* reference so that graph adaptors
// (temporaries) can be passed into this function. However, the
// graph is not really const since we may write to property maps
// of the graph.
IncidenceGraph& ng = const_cast<IncidenceGraph&>(g);
typedef graph_traits<IncidenceGraph> Traits;
// Buffer default
typedef typename Traits::vertex_descriptor vertex_descriptor;
typedef boost::queue<vertex_descriptor> queue_t;
queue_t Q;
detail::wrap_ref<queue_t> Qref(Q);
breadth_first_visit
(ng, s,
choose_param(get_param(params, buffer_param_t()), Qref).ref,
choose_param(get_param(params, graph_visitor),
make_bfs_visitor(null_visitor())),
choose_pmap(get_param(params, vertex_color), ng, vertex_color)
);
}
static void apply
(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
const bgl_named_params<P, T, R>& params,
ColorMap color)
{
bfs_helper
(g, s, color,
choose_param(get_param(params, graph_visitor),
make_bfs_visitor(null_visitor())),
params);
}
static void apply
(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
EdgeType e,
const bgl_named_params<P, T, R>& params,
ColorMap color)
{
bfs_helper
(g, s, e, color,
choose_param(get_param(params, graph_visitor),
make_bfs_visitor(null_visitor())),
params,
boost::mpl::bool_<
boost::is_base_and_derived<
distributed_graph_tag,
typename graph_traits<VertexListGraph>::traversal_category>::value>());
}
static void apply
(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
const bgl_named_params<P, T, R>& params,
detail::error_property_not_found)
{
std::vector<default_color_type> color_vec(num_vertices(g));
default_color_type c = white_color;
null_visitor null_vis;
bfs_helper
(g, s,
make_iterator_property_map
(color_vec.begin(),
choose_const_pmap(get_param(params, vertex_index),
g, vertex_index), c),
choose_param(get_param(params, graph_visitor),
make_bfs_visitor(null_vis)),
params);
}
static
depth findMinWidth(const NGHolder &h, const SpecialEdgeFilter &filter,
NFAVertex src) {
if (isLeafNode(src, h)) {
return depth::unreachable();
}
boost::filtered_graph<NFAGraph, SpecialEdgeFilter> g(h.g, filter);
assert(hasCorrectlyNumberedVertices(h));
const size_t num = num_vertices(h);
vector<depth> distance(num, depth::unreachable());
distance.at(g[src].index) = depth(0);
auto index_map = get(&NFAGraphVertexProps::index, g);
// Since we are interested in the single-source shortest paths on a graph
// with the same weight on every edge, using BFS will be faster than
// Dijkstra here.
breadth_first_search(
g, src,
visitor(make_bfs_visitor(record_distances(
make_iterator_property_map(distance.begin(), index_map),
boost::on_tree_edge()))).vertex_index_map(index_map));
DEBUG_PRINTF("d[accept]=%s, d[acceptEod]=%s\n",
distance.at(NODE_ACCEPT).str().c_str(),
distance.at(NODE_ACCEPT_EOD).str().c_str());
depth d = min(distance.at(NODE_ACCEPT), distance.at(NODE_ACCEPT_EOD));
if (d.is_unreachable()) {
return d;
}
assert(d.is_finite());
assert(d > depth(0));
return d - depth(1);
}
static void apply
(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor s,
EdgeType e,
const bgl_named_params<P, T, R>& params,
param_not_found)
{
null_visitor null_vis;
bfs_helper
(g, s, e,
make_two_bit_color_map
(num_vertices(g),
choose_const_pmap(get_param(params, vertex_index),
g, vertex_index)),
choose_param(get_param(params, graph_visitor),
make_bfs_visitor(null_vis)),
params,
boost::mpl::bool_<
boost::is_base_and_derived<
distributed_graph_tag,
typename graph_traits<VertexListGraph>::traversal_category>::value>());
}
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 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;
}