inline OutputIterator kruskal_minimum_spanning_tree(const Graph& g, OutputIterator spanning_tree_edges, const bgl_named_params<P, T, R>& params) { typedef typename graph_traits<Graph>::vertices_size_type size_type; typedef typename graph_traits<Graph>::vertex_descriptor vertex_t; if (num_vertices(g) == 0) return spanning_tree_edges; // Nothing to do in this case typename graph_traits<Graph>::vertices_size_type n; n = is_default_param(get_param(params, vertex_rank)) ? num_vertices(g) : 1; std::vector<size_type> rank_map(n); n = is_default_param(get_param(params, vertex_predecessor)) ? num_vertices(g) : 1; std::vector<vertex_t> pred_map(n); return detail::kruskal_mst_impl (g, spanning_tree_edges, choose_param (get_param(params, vertex_rank), make_iterator_property_map (rank_map.begin(), choose_pmap(get_param(params, vertex_index), g, vertex_index), rank_map[0])), choose_param (get_param(params, vertex_predecessor), make_iterator_property_map (pred_map.begin(), choose_const_pmap(get_param(params, vertex_index), g, vertex_index), pred_map[0])), choose_const_pmap(get_param(params, edge_weight), g, edge_weight)); }
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) ); }
inline void dag_sp_dispatch1 (const VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, DistanceMap distance, WeightMap weight, ColorMap color, IndexMap id, DijkstraVisitor vis, const Params& params) { typedef typename property_traits<WeightMap>::value_type T; typename std::vector<T>::size_type n; n = is_default_param(distance) ? num_vertices(g) : 1; std::vector<T> distance_map(n); n = is_default_param(color) ? num_vertices(g) : 1; std::vector<default_color_type> color_map(n); dag_sp_dispatch2 (g, s, choose_param(distance, make_iterator_property_map(distance_map.begin(), id, distance_map[0])), weight, choose_param(color, make_iterator_property_map(color_map.begin(), id, color_map[0])), id, vis, params); }
bool bellman_dispatch2 (VertexAndEdgeListGraph& g, typename graph_traits<VertexAndEdgeListGraph>::vertex_descriptor s, Size N, WeightMap weight, PredecessorMap pred, DistanceMap distance, const bgl_named_params<P, T, R>& params) { typedef typename property_traits<DistanceMap>::value_type D; bellman_visitor<> null_vis; typedef typename property_traits<WeightMap>::value_type weight_type; weight_type inf = choose_param(get_param(params, distance_inf_t()), std::numeric_limits<weight_type>::max BOOST_PREVENT_MACRO_SUBSTITUTION()); typename graph_traits<VertexAndEdgeListGraph>::vertex_iterator v, v_end; for (tie(v, v_end) = vertices(g); v != v_end; ++v) { put(distance, *v, inf); put(pred, *v, *v); } put(distance, s, weight_type(0)); return bellman_ford_shortest_paths (g, N, weight, pred, distance, choose_param(get_param(params, distance_combine_t()), closed_plus<D>()), choose_param(get_param(params, distance_compare_t()), std::less<D>()), choose_param(get_param(params, graph_visitor), null_vis) ); }
void undirected_dfs(const Graph& g, const bgl_named_params<P, T, R>& params) { typedef typename get_param_type< vertex_color_t, bgl_named_params<P, T, R> >::type C; detail::udfs_dispatch<C>::apply (g, choose_param(get_param(params, graph_visitor), make_dfs_visitor(null_visitor())), choose_param(get_param(params, root_vertex_t()), *vertices(g).first), params, get_param(params, edge_color), get_param(params, vertex_color) ); }
bool floyd_warshall_noninit_dispatch(const VertexAndEdgeListGraph& g, DistanceMatrix& d, WeightMap w, const bgl_named_params<P, T, R>& params) { typedef typename property_traits<WeightMap>::value_type WM; return floyd_warshall_all_pairs_shortest_paths(g, d, w, choose_param(get_param(params, distance_compare_t()), std::less<WM>()), choose_param(get_param(params, distance_combine_t()), closed_plus<WM>()), choose_param(get_param(params, distance_inf_t()), std::numeric_limits<WM>::max BOOST_PREVENT_MACRO_SUBSTITUTION()), choose_param(get_param(params, distance_zero_t()), WM())); }
bool bellman_dispatch(EdgeListGraph& g, Size N, WeightMap weight, DistanceMap distance, const bgl_named_params<P, T, R>& params) { typedef typename property_traits<DistanceMap>::value_type D; bellman_visitor<> null_vis; dummy_property_map dummy_pred; return bellman_ford_impl (g, N, weight, choose_param(get_param(params, vertex_predecessor), dummy_pred), distance, choose_param(get_param(params, distance_combine_t()), std::plus<D>()), choose_param(get_param(params, distance_compare_t()), std::less<D>()), choose_param(get_param(params, graph_visitor), null_vis) ); }
bool johnson_dispatch(VertexAndEdgeListGraph& g, DistanceMatrix& D, const bgl_named_params<P, T, R>& params, Weight w, VertexID id) { typedef typename property_traits<Weight>::value_type WT; return johnson_all_pairs_shortest_paths (g, D, id, w, choose_param(get_param(params, distance_compare_t()), std::less<WT>()), choose_param(get_param(params, distance_combine_t()), closed_plus<WT>()), choose_param(get_param(params, distance_inf_t()), std::numeric_limits<WT>::max BOOST_PREVENT_MACRO_SUBSTITUTION()), choose_param(get_param(params, distance_zero_t()), WT()) ); }
bool bellman_dispatch2 (VertexAndEdgeListGraph& g, detail::error_property_not_found, Size N, WeightMap weight, PredecessorMap pred, DistanceMap distance, const bgl_named_params<P, T, R>& params) { typedef typename property_traits<DistanceMap>::value_type D; bellman_visitor<> null_vis; return bellman_ford_shortest_paths (g, N, weight, pred, distance, choose_param(get_param(params, distance_combine_t()), closed_plus<D>()), choose_param(get_param(params, distance_compare_t()), std::less<D>()), choose_param(get_param(params, graph_visitor), null_vis) ); }
inline void dag_sp_dispatch2 (const VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, DistanceMap distance, WeightMap weight, ColorMap color, IndexMap /*id*/, DijkstraVisitor vis, const Params& params) { typedef typename property_traits<DistanceMap>::value_type D; dummy_property_map p_map; dag_shortest_paths (g, s, distance, weight, color, choose_param(get_param(params, vertex_predecessor), p_map), vis, choose_param(get_param(params, distance_compare_t()), std::less<D>()), choose_param(get_param(params, distance_combine_t()), closed_plus<D>()), choose_param(get_param(params, distance_inf_t()), (std::numeric_limits<D>::max)()), choose_param(get_param(params, distance_zero_t()), D())); }
inline void prim_minimum_spanning_tree (const VertexListGraph& g, PredecessorMap p_map, const bgl_named_params<P,T,R>& params) { detail::prim_mst_impl (g, choose_param(get_param(params, root_vertex_t()), *vertices(g).first), params.predecessor_map(p_map), choose_const_pmap(get_param(params, edge_weight), g, edge_weight)); }
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); }
inline void astar_dispatch1 (VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, AStarHeuristic h, CostMap cost, DistanceMap distance, WeightMap weight, IndexMap index_map, ColorMap color, const Params& params) { typedef typename property_traits<WeightMap>::value_type D; std::vector<D> distance_map; std::vector<D> cost_map; std::vector<default_color_type> color_map; detail::astar_dispatch2 (g, s, h, choose_param(cost, vector_property_map<D, IndexMap>(index_map)), choose_param(distance, vector_property_map<D, IndexMap>(index_map)), weight, index_map, choose_param(color, vector_property_map<default_color_type, IndexMap>(index_map)), params); }
inline void astar_dispatch2 (VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, AStarHeuristic h, CostMap cost, DistanceMap distance, WeightMap weight, IndexMap index_map, ColorMap color, const Params& params) { dummy_property_map p_map; typedef typename property_traits<CostMap>::value_type C; astar_search (g, s, h, choose_param(get_param(params, graph_visitor), make_astar_visitor(null_visitor())), choose_param(get_param(params, vertex_predecessor), p_map), cost, distance, weight, index_map, color, choose_param(get_param(params, distance_compare_t()), std::less<C>()), choose_param(get_param(params, distance_combine_t()), closed_plus<C>()), choose_param(get_param(params, distance_inf_t()), std::numeric_limits<C>::max BOOST_PREVENT_MACRO_SUBSTITUTION ()), choose_param(get_param(params, distance_zero_t()), C())); }
inline void dijkstra_dispatch2 (const VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, DistanceMap distance, WeightMap weight, IndexMap index_map, const Params& params) { // Default for predecessor map dummy_property_map p_map; typedef typename property_traits<DistanceMap>::value_type D; dijkstra_shortest_paths (g, s, choose_param(get_param(params, vertex_predecessor), p_map), distance, weight, index_map, choose_param(get_param(params, distance_compare_t()), std::less<D>()), choose_param(get_param(params, distance_combine_t()), closed_plus<D>()), choose_param(get_param(params, distance_inf_t()), std::numeric_limits<D>::max()), choose_param(get_param(params, distance_zero_t()), D()), choose_param(get_param(params, graph_visitor), make_dijkstra_visitor(null_visitor()))); }
bool bellman_dispatch(EdgeListGraph& g, Size N, WeightMap weight, DistanceMap distance, const bgl_named_params<P, T, R>& params) { dummy_property_map dummy_pred; return detail::bellman_dispatch2 (g, get_param(params, root_vertex_t()), N, weight, choose_param(get_param(params, vertex_predecessor), dummy_pred), distance, params); }
void transitive_closure_dispatch (const Graph & g, GraphTC & tc, G_to_TC_VertexMap g_to_tc_map, VertexIndexMap index_map) { typedef typename graph_traits < GraphTC >::vertex_descriptor tc_vertex; typename std::vector < tc_vertex >::size_type n = is_default_param(g_to_tc_map) ? num_vertices(g) : 1; std::vector < tc_vertex > to_tc_vec(n); transitive_closure (g, tc, choose_param(g_to_tc_map, make_iterator_property_map (to_tc_vec.begin(), index_map, to_tc_vec[0])), index_map); }
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>()); }
inline void dag_shortest_paths (const VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, const bgl_named_params<Param,Tag,Rest>& params) { // assert that the graph is directed... null_visitor null_vis; detail::dag_sp_dispatch1 (g, s, get_param(params, vertex_distance), choose_const_pmap(get_param(params, edge_weight), g, edge_weight), get_param(params, vertex_color), choose_const_pmap(get_param(params, vertex_index), g, vertex_index), choose_param(get_param(params, graph_visitor), make_dijkstra_visitor(null_vis)), params); }
void bfs_helper (VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, ColorMap color, BFSVisitor vis, const bgl_named_params<P, T, R>& params) { typedef graph_traits<VertexListGraph> Traits; // Buffer default typedef typename Traits::vertex_descriptor Vertex; typedef boost::queue<Vertex> queue_t; queue_t Q; detail::wrap_ref<queue_t> Qref(Q); breadth_first_search (g, s, choose_param(get_param(params, buffer_param_t()), Qref).ref, vis, color); }
void bfs_helper (VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, EdgeType e, ColorMap color, BFSVisitor vis, const bgl_named_params<P, T, R>& params, boost::mpl::false_) { typedef graph_traits<VertexListGraph> Traits; // Buffer default typedef typename Traits::vertex_descriptor Vertex; typedef boost::queue<Vertex> queue_t; queue_t Q; breadth_first_search (g, s, e, choose_param(get_param(params, buffer_param_t()), boost::ref(Q)).get(), vis, color); }
inline void dijkstra_dispatch1 (const VertexListGraph& g, typename graph_traits<VertexListGraph>::vertex_descriptor s, DistanceMap distance, WeightMap weight, IndexMap index_map, const Params& params) { // Default for distance map typedef typename property_traits<WeightMap>::value_type D; typename std::vector<D>::size_type n = is_default_param(distance) ? num_vertices(g) : 1; std::vector<D> distance_map(n); detail::dijkstra_dispatch2 (g, s, choose_param(distance, make_iterator_property_map (distance_map.begin(), index_map, distance_map[0])), weight, index_map, params); }
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 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>()); }
bool read_off_binary(Surface_mesh& mesh, FILE* in, const bool has_normals, const bool has_texcoords, const bool has_colors, NamedParameters& np) { unsigned int i, j, idx; unsigned int nV, nF, nE; Vec3f p, n, c; Vec2f t; Surface_mesh::Vertex v; // binary cannot (yet) read colors if (has_colors) return false; // properties Surface_mesh::Vertex_property<Normal> normals; Surface_mesh::Vertex_property<Texture_coordinate> texcoords; if (has_normals) normals = mesh.vertex_property<Normal>("v:normal"); if (has_texcoords) texcoords = mesh.vertex_property<Texture_coordinate>("v:texcoord"); typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Surface_mesh, NamedParameters>::const_type vpm = choose_param(get_param(np, CGAL::boost::internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, mesh)); // #Vertice, #Faces, #Edges read(in, nV); read(in, nF); read(in, nE); mesh.clear(); mesh.reserve(nV, std::max(3*nV, nE), nF); // read vertices: pos [normal] [color] [texcoord] for (i=0; i<nV && !feof(in); ++i) { // position read(in, p); Surface_mesh::Vertex v = mesh.add_vertex(); put(vpm, v, (Point)p); // normal if (has_normals) { read(in, n); normals[v] = n; } // tex coord if (has_texcoords) { read(in, t); texcoords[v][0] = t[0]; texcoords[v][1] = t[1]; } } // read faces: #N v[1] v[2] ... v[n-1] std::vector<Surface_mesh::Vertex> vertices; for (i=0; i<nF; ++i) { read(in, nV); vertices.resize(nV); for (j=0; j<nV; ++j) { read(in, idx); vertices[j] = Surface_mesh::Vertex(idx); } mesh.add_face(vertices); } return true; }
bool read_off_ascii(Surface_mesh& mesh, FILE* in, const bool has_normals, const bool has_texcoords, const bool has_colors, NamedParameters& np) { char line[100], *lp; unsigned int i, j, items, idx, nc; unsigned int nV, nF, nE; Vec3f p, n, c; Vec2f t; Surface_mesh::Vertex v; typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Surface_mesh, NamedParameters>::const_type vpm = choose_param(get_param(np, CGAL::boost::internal_np::vertex_point), get_const_property_map(CGAL::vertex_point, mesh)); // properties Surface_mesh::Vertex_property<Normal> normals; Surface_mesh::Vertex_property<Texture_coordinate> texcoords; Surface_mesh::Vertex_property<Color> colors; if (has_normals) normals = mesh.vertex_property<Normal>("v:normal"); if (has_texcoords) texcoords = mesh.vertex_property<Texture_coordinate>("v:texcoord"); if (has_colors) colors = mesh.vertex_property<Color>("v:color"); // #Vertice, #Faces, #Edges items = fscanf(in, "%d %d %d\n", (int*)&nV, (int*)&nF, (int*)&nE); mesh.clear(); mesh.reserve(nV, std::max(3*nV, nE), nF); // read vertices: pos [normal] [color] [texcoord] for (i=0; i<nV && !feof(in); ++i) { // read line lp = fgets(line, 100, in); // position items = sscanf(lp, "%f %f %f%n", &p[0], &p[1], &p[2], &nc); assert(items==3); Surface_mesh::Vertex v = mesh.add_vertex(); put(vpm, v, (Point)p); lp += nc; // normal if (has_normals) { if (sscanf(lp, "%f %f %f%n", &n[0], &n[1], &n[2], &nc) == 3) { normals[v] = n; } lp += nc; } // color if (has_colors) { if (sscanf(lp, "%f %f %f%n", &c[0], &c[1], &c[2], &nc) == 3) { if (c[0]>1.0f || c[1]>1.0f || c[2]>1.0f) c *= (1.0/255.0); colors[v] = c; } lp += nc; } // tex coord if (has_texcoords) { items = sscanf(lp, "%f %f%n", &t[0], &t[1], &nc); assert(items == 2); texcoords[v][0] = t[0]; texcoords[v][1] = t[1]; lp += nc; } } // read faces: #N v[1] v[2] ... v[n-1] std::vector<Surface_mesh::Vertex> vertices; for (i=0; i<nF; ++i) { // read line lp = fgets(line, 100, in); // #vertices items = sscanf(lp, "%d%n", (int*)&nV, &nc); assert(items == 1); vertices.resize(nV); lp += nc; // indices for (j=0; j<nV; ++j) { items = sscanf(lp, "%d%n", (int*)&idx, &nc); assert(items == 1); vertices[j] = Surface_mesh::Vertex(idx); lp += nc; } mesh.add_face(vertices); } return true; }