songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

boost::tie -> std::tie (#8715)

This commit is contained in:
Sebastien Loriot 2025-02-12 19:36:19 +01:00 committed by GitHub
parent 3394b6d889 00bf449e04
commit 14b83f0d3e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
136 changed files with 407 additions and 413 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
BGL/examples/BGL_LCC/distance_lcc.cpp
View File

@ -28,7 +28,7 @@ int main(int argc, char** argv)
// Here we start at an arbitrary vertex
// Any other vertex could be the starting point
vertex_iterator vb, ve;
boost::tie(vb,ve)=vertices(lcc);
std::tie(vb,ve)=vertices(lcc);
vertex_descriptor vd = *vb;
std::cout << "We compute distances to " << vd->point() << std::endl;
@ -45,7 +45,7 @@ int main(int argc, char** argv)
boost::on_tree_edge()))));
// Traverse all vertices and show at what distance they are
for(boost::tie(vb,ve)=vertices(lcc); vb!=ve; ++vb)
for(std::tie(vb,ve)=vertices(lcc); vb!=ve; ++vb)
{
vd = *vb;
std::cout<<vd->point()<<" is "<<distance[vd->id()]<<" hops away."<<std::endl;

2
BGL/examples/BGL_LCC/incident_vertices_lcc.cpp
View File

@ -40,7 +40,7 @@ OutputIterator adjacent_vertices_V2(const LCC& g,
OutputIterator out)
{
halfedge_around_target_iterator hi, he;
for(boost::tie(hi, he) = halfedges_around_target(halfedge(vd,g),g); hi != he; ++hi)
for(std::tie(hi, he) = halfedges_around_target(halfedge(vd,g),g); hi != he; ++hi)
{
*out++ = source(*hi,g);
}

2
BGL/examples/BGL_LCC/kruskal_lcc.cpp
View File

@ -41,7 +41,7 @@ void kruskal(const LCC& lcc)
"point [ \n";
vertex_iterator vb, ve;
for(boost::tie(vb,ve) = vertices(lcc); vb!=ve; ++vb){
for(std::tie(vb,ve) = vertices(lcc); vb!=ve; ++vb){
std::cout << (*vb)->point() << "\n";
}

2
BGL/examples/BGL_LCC/normals_lcc.cpp
View File

@ -31,7 +31,7 @@ void calculate_face_normals(const HalfedgeGraph& g,
typedef typename boost::property_traits<NormalMap>::value_type normal;
face_iterator fb, fe;
for(boost::tie(fb, fe) = faces(g); fb != fe; ++fb)
for(std::tie(fb, fe) = faces(g); fb != fe; ++fb)
{
halfedge_descriptor edg = halfedge(*fb, g);
halfedge_descriptor edgb = edg;

4
BGL/examples/BGL_LCC/range_lcc.cpp
View File

@ -42,10 +42,10 @@ void fct(const LCC& lcc)
std::cout << vd->point() << std::endl;
}
std::cout << "boost::tie + std::for_each" << std::endl;
std::cout << "std::tie + std::for_each" << std::endl;
vertex_iterator vb, ve;
boost::tie(vb,ve) = vertices_range(lcc);
std::tie(vb,ve) = vertices_range(lcc);
std::for_each(vb,ve, Fct());
}

2
BGL/examples/BGL_LCC/transform_iterator_lcc.cpp
View File

@ -49,7 +49,7 @@ int main(int argc, char** argv)
typedef boost::transform_iterator<Source<LCC>,halfedge_around_target_iterator> adjacent_vertex_iterator;
halfedge_around_target_iterator hb,he;
boost::tie(hb,he) = halfedges_around_target(halfedge(vd,lcc),lcc);
std::tie(hb,he) = halfedges_around_target(halfedge(vd,lcc),lcc);
adjacent_vertex_iterator avib, avie;
avib = boost::make_transform_iterator(hb, Source<LCC>(lcc));
avie = boost::make_transform_iterator(he, Source<LCC>(lcc));

8
BGL/examples/BGL_polyhedron_3/distance.cpp
View File

@ -24,9 +24,9 @@ int main(int argc, char** argv) {
vertex_iterator vb, ve;
int index = 0;
// boost::tie assigns the first and second element of the std::pair
// std::tie assigns the first and second element of the std::pair
// returned by boost::vertices to the variables vit and ve
for(boost::tie(vb,ve)=vertices(P); vb!=ve; ++vb ){
for(std::tie(vb,ve)=vertices(P); vb!=ve; ++vb ){
vertex_descriptor vd = *vb;
vd->id() = index++;
}
@ -37,7 +37,7 @@ int main(int argc, char** argv) {
// Here we start at an arbitrary vertex
// Any other vertex could be the starting point
boost::tie(vb,ve)=vertices(P);
std::tie(vb,ve)=vertices(P);
vertex_descriptor vd = *vb;
std::cout << "We compute distances to " << vd->point() << std::endl;
@ -54,7 +54,7 @@ int main(int argc, char** argv) {
// Traverse all vertices and show at what distance they are
for(boost::tie(vb,ve)=vertices(P); vb!=ve; ++vb ){
for(std::tie(vb,ve)=vertices(P); vb!=ve; ++vb ){
vd = *vb;
std::cout << vd->point() << " is " << distance[vd->id()] << " hops away" << std::endl;
}

2
BGL/examples/BGL_polyhedron_3/incident_vertices.cpp
View File

@ -36,7 +36,7 @@ adjacent_vertices_V2(const Polyhedron& g,
{
halfedge_around_target_iterator hi, he;
for(boost::tie(hi, he) = halfedges_around_target(halfedge(vd,g),g); hi != he; ++hi)
for(std::tie(hi, he) = halfedges_around_target(halfedge(vd,g),g); hi != he; ++hi)
{
*out++ = source(*hi,g);
}

6
BGL/examples/BGL_polyhedron_3/kruskal.cpp
View File

@ -33,9 +33,9 @@ kruskal(const Polyhedron& P)
vertex_iterator vb, ve;
int index = 0;
// boost::tie assigns the first and second element of the std::pair
// std::tie assigns the first and second element of the std::pair
// returned by boost::vertices to the variables vb and ve
for(boost::tie(vb, ve)=vertices(P); vb!=ve; ++vb){
for(std::tie(vb, ve)=vertices(P); vb!=ve; ++vb){
vertex_index_pmap[*vb]= index++;
}
@ -59,7 +59,7 @@ kruskal(const Polyhedron& P)
" coord Coordinate {\n"
" point [ \n";
for(boost::tie(vb, ve) = vertices(P); vb!=ve; ++vb){
for(std::tie(vb, ve) = vertices(P); vb!=ve; ++vb){
std::cout << " " << (*vb)->point() << "\n";
}

6
BGL/examples/BGL_polyhedron_3/kruskal_with_stored_id.cpp
View File

@ -41,7 +41,7 @@ kruskal( const Polyhedron& P)
"point [ \n";
vertex_iterator vb, ve;
for(boost::tie(vb,ve) = vertices(P); vb!=ve; ++vb){
for(std::tie(vb,ve) = vertices(P); vb!=ve; ++vb){
std::cout << (*vb)->point() << "\n";
}
@ -75,9 +75,9 @@ int main() {
vertex_iterator vb, ve;
int index = 0;
// boost::tie assigns the first and second element of the std::pair
// std::tie assigns the first and second element of the std::pair
// returned by boost::vertices to the variables vit and ve
for(boost::tie(vb,ve)=vertices(P); vb!=ve; ++vb ){
for(std::tie(vb,ve)=vertices(P); vb!=ve; ++vb ){
vertex_descriptor vd = *vb;
vd->id() = index++;
}

2
BGL/examples/BGL_polyhedron_3/normals.cpp
View File

@ -26,7 +26,7 @@ void calculate_face_normals(const HalfedgeGraph& g,
typedef typename boost::property_traits<NormalMap>::value_type normal;
face_iterator fb, fe;
for(boost::tie(fb, fe) = faces(g); fb != fe; ++fb)
for(std::tie(fb, fe) = faces(g); fb != fe; ++fb)
{
halfedge_descriptor edg = halfedge(*fb, g);
halfedge_descriptor edgb = edg;

4
BGL/examples/BGL_polyhedron_3/range.cpp
View File

@ -40,10 +40,10 @@ void fct(const Polyhedron& p)
std::cout << vd->point() << std::endl;
}
std::cout << "boost::tie + std::for_each" << std::endl;
std::cout << "std::tie + std::for_each" << std::endl;
vertex_iterator vb, ve;
boost::tie(vb,ve) = vertices_range(p);
std::tie(vb,ve) = vertices_range(p);
std::for_each(vb,ve, Fct());
}

2
BGL/examples/BGL_polyhedron_3/transform_iterator.cpp
View File

@ -47,7 +47,7 @@ int main(int argc, char** argv)
typedef boost::transform_iterator<Source<Polyhedron>,halfedge_around_target_iterator> adjacent_vertex_iterator;
halfedge_around_target_iterator hb,he;
boost::tie(hb,he) = halfedges_around_target(halfedge(vd,P),P);
std::tie(hb,he) = halfedges_around_target(halfedge(vd,P),P);
adjacent_vertex_iterator avib, avie;
avib = boost::make_transform_iterator(hb, Source<Polyhedron>(P));
avie = boost::make_transform_iterator(he, Source<Polyhedron>(P));

2
BGL/examples/BGL_surface_mesh/surface_mesh_partition.cpp
View File

@ -51,7 +51,7 @@ int main(int argc, char** argv)
std::ofstream outxyz("out.xyz");
outxyz.precision(17);
boost::graph_traits<SM>::vertex_iterator vit, ve;
boost::tie(vit, ve) = vertices(sm);
std::tie(vit, ve) = vertices(sm);
for(; vit!=ve; ++vit)
{
if(get(vertex_pid_map, *vit) == 0)

4
BGL/include/CGAL/boost/graph/Dual.h
View File

@ -306,7 +306,7 @@ edge(typename boost::graph_traits<Dual<P> >::vertex_descriptor u,
const Dual<P>& dual)
{
typename boost::graph_traits<Dual<P> >::out_edge_iterator e, e_end;
for(boost::tie(e, e_end) = out_edges(u, dual); e != e_end; ++e) {
for(std::tie(e, e_end) = out_edges(u, dual); e != e_end; ++e) {
if(target(*e, dual) == v)
return std::make_pair(*e, true);
}
@ -391,7 +391,7 @@ halfedge(typename boost::graph_traits<Dual<P> >::vertex_descriptor u,
const Dual<P>& dual)
{
typename boost::graph_traits<Dual<P> >::out_edge_iterator e, e_end;
for(boost::tie(e, e_end) = out_edges(u, dual); e != e_end; ++e) {
for(std::tie(e, e_end) = out_edges(u, dual); e != e_end; ++e) {
if(target(*e, dual) == v)
return std::make_pair(halfedge(*e, dual), true);
}

14
BGL/include/CGAL/boost/graph/Euler_operations.h
View File

@ -136,7 +136,7 @@ join_vertex(typename boost::graph_traits<Graph>::halfedge_descriptor h,
CGAL_assertion( halfedge(v_to_remove, v, g).first == h );
halfedge_around_vertex_iterator ieb, iee;
for(boost::tie(ieb, iee) = halfedges_around_target(hop, g); ieb != iee; ++ieb) {
for(std::tie(ieb, iee) = halfedges_around_target(hop, g); ieb != iee; ++ieb) {
CGAL_assertion( target(*ieb,g) == v_to_remove);
set_target(*ieb ,v , g);
}
@ -615,7 +615,7 @@ bool can_add_face(const VertexRange& vrange, const PMesh& sm)
for(std::size_t i=0; i < N; ++i){
halfedge_descriptor hd;
bool found;
boost::tie(hd,found) = halfedge(face[i],face[i+1],sm);
std::tie(hd,found) = halfedge(face[i],face[i+1],sm);
if(found && (! is_border(hd,sm))){
return false;
}
@ -1149,7 +1149,7 @@ void make_hole(typename boost::graph_traits<Graph>::halfedge_descriptor h,
face_descriptor fd = face(h, g);
halfedge_around_face_iterator hafib, hafie;
for(boost::tie(hafib, hafie) = halfedges_around_face(h, g);
for(std::tie(hafib, hafie) = halfedges_around_face(h, g);
hafib != hafie;
++hafib){
CGAL_assertion(! is_border(opposite(*hafib,g),g));
@ -1361,7 +1361,7 @@ add_vertex_and_face_to_border(typename boost::graph_traits<Graph>::halfedge_desc
internal::set_border(he2,g);
CGAL::Halfedge_around_face_iterator<Graph> hafib,hafie;
for(boost::tie(hafib, hafie) = halfedges_around_face(ohe1, g);
for(std::tie(hafib, hafie) = halfedges_around_face(ohe1, g);
hafib != hafie;
++hafib){
set_face(*hafib, f, g);
@ -1421,7 +1421,7 @@ add_face_to_border(typename boost::graph_traits<Graph>::halfedge_descriptor h1,
internal::set_border(newhop, g);
CGAL::Halfedge_around_face_iterator<Graph> hafib,hafie;
for(boost::tie(hafib, hafie) = halfedges_around_face(newh, g);
for(std::tie(hafib, hafie) = halfedges_around_face(newh, g);
hafib != hafie;
++hafib){
set_face(*hafib, f, g);
@ -1458,7 +1458,7 @@ does_satisfy_link_condition(typename boost::graph_traits<Graph>::edge_descriptor
// The following loop checks the link condition for v0_v1.
// Specifically, that for every vertex 'k' adjacent to both 'p and 'q', 'pkq' is a face of the mesh.
//
for ( boost::tie(eb1,ee1) = halfedges_around_source(v0,g) ; eb1 != ee1 ; ++ eb1 )
for ( std::tie(eb1,ee1) = halfedges_around_source(v0,g) ; eb1 != ee1 ; ++ eb1 )
{
halfedge_descriptor v0_k = *eb1;
@ -1466,7 +1466,7 @@ does_satisfy_link_condition(typename boost::graph_traits<Graph>::edge_descriptor
{
vertex_descriptor k = target(v0_k,g);
for ( boost::tie(eb2,ee2) = halfedges_around_source(k,g) ; eb2 != ee2 ; ++ eb2 )
for ( std::tie(eb2,ee2) = halfedges_around_source(k,g) ; eb2 != ee2 ; ++ eb2 )
{
halfedge_descriptor k_v1 = *eb2;

8
BGL/include/CGAL/boost/graph/Face_filtered_graph.h
View File

@ -895,7 +895,7 @@ vertices(const Face_filtered_graph<Graph, FIMap, VIMap, HIMap> & w)
typename Face_filtered_graph<Graph, FIMap, VIMap, HIMap> ::Is_simplex_valid predicate(&w);
g_vertex_iterator b,e;
boost::tie(b,e) = vertices(w.graph());
std::tie(b,e) = vertices(w.graph());
return make_range(vertex_iterator(predicate, b, e),
vertex_iterator(predicate, e, e));
}
@ -912,7 +912,7 @@ edges(const Face_filtered_graph<Graph, FIMap, VIMap, HIMap> & w)
typename Face_filtered_graph<Graph, FIMap, VIMap, HIMap> ::Is_simplex_valid predicate(&w);
g_edge_iterator b,e;
boost::tie(b,e) = edges(w.graph());
std::tie(b,e) = edges(w.graph());
return make_range(edge_iterator(predicate, b, e),
edge_iterator(predicate, e, e));
}
@ -931,7 +931,7 @@ out_edges(typename boost::graph_traits<Face_filtered_graph<Graph, FIMap, VIMap,
typename Face_filtered_graph<Graph, FIMap, VIMap, HIMap> ::Is_simplex_valid predicate(&w);
g_out_edge_iterator b,e;
boost::tie(b,e) = out_edges(v, w.graph());
std::tie(b,e) = out_edges(v, w.graph());
return make_range(out_edge_iterator(predicate, b, e),
out_edge_iterator(predicate, e, e));
}
@ -950,7 +950,7 @@ in_edges(typename boost::graph_traits<Face_filtered_graph<Graph, FIMap, VIMap, H
typename Face_filtered_graph<Graph, FIMap, VIMap, HIMap> ::Is_simplex_valid predicate(&w);
g_in_edge_iterator b,e;
boost::tie(b,e) = in_edges(v, w.graph());
std::tie(b,e) = in_edges(v, w.graph());
return make_range(in_edge_iterator(predicate, b, e),
in_edge_iterator(predicate, e, e));
}

16
BGL/include/CGAL/boost/graph/Graph_with_descriptor_with_graph.h
View File

@ -310,7 +310,7 @@ edge(typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::ver
CGAL_assertion(in_same_graph(v,w));
bool b;
g_edge_descriptor ed;
boost::tie(ed,b) = edge(u.descriptor, v.descriptor, *w.graph);
std::tie(ed,b) = edge(u.descriptor, v.descriptor, *w.graph);
return std::make_pair(edge_descriptor(ed,*w.graph),b);
}
@ -320,7 +320,7 @@ CGAL::Iterator_range<typename boost::graph_traits<Graph_with_descriptor_with_gra
vertices(const Graph_with_descriptor_with_graph<Graph> & w)
{
typename boost::graph_traits<Graph>::vertex_iterator b,e;
boost::tie(b,e) = vertices(*w.graph);
std::tie(b,e) = vertices(*w.graph);
return std::make_pair(boost::make_transform_iterator(b,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::V2V(*w.graph)),
boost::make_transform_iterator(e,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::V2V(*w.graph)));
}
@ -330,7 +330,7 @@ CGAL::Iterator_range<typename boost::graph_traits<Graph_with_descriptor_with_gra
edges(const Graph_with_descriptor_with_graph<Graph> & w)
{
typename boost::graph_traits<Graph>::edge_iterator b,e;
boost::tie(b,e) = edges(*w.graph);
std::tie(b,e) = edges(*w.graph);
return std::make_pair(boost::make_transform_iterator(b,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::E2E(*w.graph)),
boost::make_transform_iterator(e,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::E2E(*w.graph)));
}
@ -342,7 +342,7 @@ out_edges(typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >
{
CGAL_assertion(in_same_graph(v,w));
typename boost::graph_traits<Graph>::out_edge_iterator b,e;
boost::tie(b,e) = out_edges(v.descriptor, *w.graph);
std::tie(b,e) = out_edges(v.descriptor, *w.graph);
return std::make_pair(boost::make_transform_iterator(b,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::E2E(*w.graph)),
boost::make_transform_iterator(e,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::E2E(*w.graph)));
}
@ -354,7 +354,7 @@ in_edges(typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >:
{
CGAL_assertion(in_same_graph(v,w));
typename boost::graph_traits<Graph>::in_edge_iterator b,e;
boost::tie(b,e) = in_edges(v.descriptor, *w.graph);
std::tie(b,e) = in_edges(v.descriptor, *w.graph);
return std::make_pair(boost::make_transform_iterator(b,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::E2E(*w.graph)),
boost::make_transform_iterator(e,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::E2E(*w.graph)));
}
@ -557,7 +557,7 @@ halfedge(typename boost::graph_traits< Graph_with_descriptor_with_graph<Graph> >
bool b;
CGAL_assertion(in_same_graph(u,w));
CGAL_assertion(in_same_graph(v,w));
boost::tie(hd,b) = halfedge(u.descriptor, v.descriptor, *w.graph);
std::tie(hd,b) = halfedge(u.descriptor, v.descriptor, *w.graph);
return std::make_pair(halfedge_descriptor(hd,*w.graph),b);
}
@ -621,7 +621,7 @@ CGAL::Iterator_range<typename boost::graph_traits<Graph_with_descriptor_with_gra
halfedges(const Graph_with_descriptor_with_graph<Graph> & w)
{
typename boost::graph_traits<Graph>::halfedge_iterator b,e;
boost::tie(b,e) = halfedges(*w.graph);
std::tie(b,e) = halfedges(*w.graph);
return std::make_pair(boost::make_transform_iterator(b, typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::H2H(*w.graph)),
boost::make_transform_iterator(e, typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::H2H(*w.graph)));
}
@ -661,7 +661,7 @@ CGAL::Iterator_range<typename boost::graph_traits<Graph_with_descriptor_with_gra
faces(const Graph_with_descriptor_with_graph<Graph> & w)
{
typename boost::graph_traits<Graph>::face_iterator b,e;
boost::tie(b,e) = faces(*w.graph);
std::tie(b,e) = faces(*w.graph);
return std::make_pair(boost::make_transform_iterator(b,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::F2F(*w.graph)),
boost::make_transform_iterator(e,typename boost::graph_traits<Graph_with_descriptor_with_graph<Graph> >::F2F(*w.graph)));
}

2
BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h
View File

@ -61,7 +61,7 @@ void partition_dual_graph(const TriangleMesh& tm,
// fill the adjacency info
face_iterator fit, fe;
boost::tie(fit, fe) = faces(tm);
std::tie(fit, fe) = faces(tm);
for(int i=0, j=0; fit!=fe; ++fit, ++i)
{
eptr[i] = j;

6
BGL/include/CGAL/boost/graph/METIS/partition_graph.h
View File

@ -47,7 +47,7 @@ struct Output_vertex_partition_ids
VertexPartitionIDPmap vertex_partition_id_map)
{
typename boost::graph_traits<TriangleMesh>::vertex_iterator vit, ve;
boost::tie(vit, ve) = vertices(tm);
std::tie(vit, ve) = vertices(tm);
for(; vit!=ve; ++vit)
put(vertex_partition_id_map, *vit, npart[get(indices, *vit)]);
}
@ -64,7 +64,7 @@ struct Output_face_partition_ids
FacePartitionIDPmap face_partition_id_map)
{
typename boost::graph_traits<TriangleMesh>::face_iterator fit, fe;
boost::tie(fit, fe) = faces(tm);
std::tie(fit, fe) = faces(tm);
for(int i=0; fit!=fe; ++fit, ++i)
put(face_partition_id_map, *fit, epart[i]);
}
@ -98,7 +98,7 @@ void partition_graph(const TriangleMesh& tm,
// fill the adjacency info
face_iterator fit, fe;
boost::tie(fit, fe) = faces(tm);
std::tie(fit, fe) = faces(tm);
for(int i=0, j=0; fit!=fe; ++fit, ++i)
{
eptr[i] = j;

8
BGL/include/CGAL/boost/graph/alpha_expansion_graphcut.h
View File

@ -238,7 +238,7 @@ public:
// initialize vertex indices, it is necessary since we are using VertexList = listS
Vertex_iterator v_begin, v_end;
Traits::vertices_size_type index = 0;
for(boost::tie(v_begin, v_end) = vertices(graph); v_begin != v_end; ++v_begin) {
for(std::tie(v_begin, v_end) = vertices(graph); v_begin != v_end; ++v_begin) {
boost::put(boost::vertex_index, graph, *v_begin, index++);
}
}
@ -269,8 +269,8 @@ public:
Edge_descriptor v1_v2, v2_v1;
bool v1_v2_added, v2_v1_added;
boost::tie(v1_v2, v1_v2_added) = boost::add_edge(v1, v2, graph);
boost::tie(v2_v1, v2_v1_added) = boost::add_edge(v2, v1, graph);
std::tie(v1_v2, v1_v2_added) = boost::add_edge(v1, v2, graph);
std::tie(v2_v1, v2_v1_added) = boost::add_edge(v2, v1, graph);
CGAL_assertion(v1_v2_added && v2_v1_added);
//put edge capacities
@ -360,7 +360,7 @@ public:
// however from our edge_map, we know that each (2i, 2i + 1) is reverse pairs, how to facilitate that ?
// will look it back
Graph::edge_iterator ei, ee;
for(boost::tie(ei, ee) = boost::edges(graph); ei != ee; ++ei) {
for(std::tie(ei, ee) = boost::edges(graph); ei != ee; ++ei) {
Graph::vertex_descriptor v1 = boost::source(*ei, graph);
Graph::vertex_descriptor v2 = boost::target(*ei, graph);
std::pair<Graph::edge_descriptor, bool> opp_edge = boost::edge(v2, v1, graph);

2
BGL/include/CGAL/boost/graph/helpers.h
View File

@ -65,7 +65,7 @@ is_border(typename boost::graph_traits<FaceGraph>::vertex_descriptor vd,
const FaceGraph& g)
{
CGAL::Halfedge_around_target_iterator<FaceGraph> havib, havie;
for(boost::tie(havib, havie) = halfedges_around_target(halfedge(vd, g), g); havib != havie; ++havib) {
for(std::tie(havib, havie) = halfedges_around_target(halfedge(vd, g), g); havib != havie; ++havib) {
if(is_border(*havib,g)) {
typename boost::graph_traits<FaceGraph>::halfedge_descriptor h = *havib;
return h;

4
BGL/include/CGAL/boost/graph/split_graph_into_polylines.h
View File

@ -147,7 +147,7 @@ void duplicate_terminal_vertices(Graph& graph,
typedef typename boost::graph_traits<Graph>::out_edge_iterator out_edge_iterator;
vertex_iterator b,e;
boost::tie(b,e) = vertices(graph);
std::tie(b,e) = vertices(graph);
std::vector<vertex_descriptor> V(b,e);
for(vertex_descriptor v : V)
{
@ -156,7 +156,7 @@ void duplicate_terminal_vertices(Graph& graph,
if (deg != 2 || is_terminal(orig_v, orig))
{
out_edge_iterator b, e;
boost::tie(b, e) = out_edges(v, graph);
std::tie(b, e) = out_edges(v, graph);
std::vector<edge_descriptor> out_edges_of_v(b, e);
for (unsigned int i = 1; i < out_edges_of_v.size(); ++i)
{

32
BGL/test/BGL/test_Euler_operations.cpp
View File

@ -97,7 +97,7 @@ join_face_test()
bool found;
halfedge_descriptor e;
boost::tie(e, found) = halfedge(f.w, f.v, f.m);
std::tie(e, found) = halfedge(f.w, f.v, f.m);
assert(found);
// manually set the halfedge of f.f1 to the edge that is to be
// removed to provoke a special case
@ -108,7 +108,7 @@ join_face_test()
assert(CGAL::internal::exact_num_edges(f.m) == 6);
CGAL::Halfedge_around_face_iterator<T> begin, end;
boost::tie(begin, end) = CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m);
std::tie(begin, end) = CGAL::halfedges_around_face(halfedge(f.f1, f.m), f.m);
assert(std::distance(begin, end) == 4);
for(; begin != end; ++begin)
{
@ -119,7 +119,7 @@ join_face_test()
}
face_iterator fit, fend;
for(boost::tie(fit, fend) = faces(f.m); fit != fend; ++fit) {
for(std::tie(fit, fend) = faces(f.m); fit != fend; ++fit) {
assert(*fit == f.f1 || *fit == f.f3);
}
@ -141,7 +141,7 @@ remove_face_test_1()
// find the edge between x and y
bool found;
halfedge_descriptor e;
boost::tie(e, found) = halfedge(f.x, f.y, f.m);
std::tie(e, found) = halfedge(f.x, f.y, f.m);
assert(found);
assert(face(e, f.m) == f.f3);
@ -156,7 +156,7 @@ remove_face_test_1()
assert_EQUAL(CGAL::internal::exact_num_vertices(f.m) == 4);
halfedge_iterator eb, ee;
int count = 0;
for(boost::tie(eb, ee) = halfedges(f.m); eb != ee; ++eb) {
for(std::tie(eb, ee) = halfedges(f.m); eb != ee; ++eb) {
if(face(*eb,f.m) == boost::graph_traits<T>::null_face())
++count;
}
@ -177,9 +177,9 @@ remove_face_test_2()
bool found;
halfedge_descriptor e;
boost::tie(e, found) = halfedge(f.x, f.w, f.m);
std::tie(e, found) = halfedge(f.x, f.w, f.m);
assert(found);
boost::tie(e, found) = halfedge(f.x, f.v, f.m);
std::tie(e, found) = halfedge(f.x, f.v, f.m);
assert(found);
assert(face(e, f.m) == f.f1);
CGAL::Euler::remove_face(e,f.m);
@ -189,7 +189,7 @@ remove_face_test_2()
assert(CGAL::internal::exact_num_edges(f.m) == 7);
assert(CGAL::internal::exact_num_vertices(f.m) == 5);
boost::tie(e, found) = halfedge(f.x, f.w, f.m);
std::tie(e, found) = halfedge(f.x, f.w, f.m);
assert(found);
assert(face(e,f.m) == boost::graph_traits<T>::null_face());
@ -266,7 +266,7 @@ join_vertex_interior_test()
halfedge_descriptor e;
bool found;
boost::tie(e, found) = halfedge(f.w, f.x, f.m);
std::tie(e, found) = halfedge(f.w, f.x, f.m);
assert(found);
CGAL::Euler::join_vertex(e,f.m);
assert(CGAL::internal::exact_num_faces(f.m) == 2);
@ -289,7 +289,7 @@ join_vertex_exterior_test()
Surface_fixture_3<T> f;
halfedge_descriptor e;
bool found;
boost::tie(e, found) = halfedge(f.w, f.y, f.m);
std::tie(e, found) = halfedge(f.w, f.y, f.m);
assert(source(e,f.m) == f.w);
assert(target(e,f.m) == f.y);
assert(found);
@ -307,7 +307,7 @@ join_vertex_exterior_test()
Surface_fixture_3<T> f;
halfedge_descriptor e;
bool found;
boost::tie(e, found) = halfedge(f.y, f.w, f.m);
std::tie(e, found) = halfedge(f.y, f.w, f.m);
assert(source(e,f.m) == f.y);
assert(target(e,f.m) == f.w);
@ -335,9 +335,9 @@ split_vertex()
Surface_fixture_3<T> f;
halfedge_descriptor h1, h2;
bool found;
boost::tie(h1, found) = halfedge(f.w, f.y, f.m);
std::tie(h1, found) = halfedge(f.w, f.y, f.m);
assert(found);
boost::tie(h2, found) = halfedge(f.z, f.y, f.m);
std::tie(h2, found) = halfedge(f.z, f.y, f.m);
assert(found);
assert(face(h2, f.m) == Traits::null_face());
@ -358,13 +358,13 @@ split_join_vertex_inverse()
Surface_fixture_3<T> f;
halfedge_descriptor h, h1, h2;
bool found;
boost::tie(h, found) = halfedge(f.w, f.x, f.m);
std::tie(h, found) = halfedge(f.w, f.x, f.m);
assert(found);
CGAL::Euler::join_vertex(h,f.m);
assert(CGAL::is_valid_polygon_mesh(f.m));
boost::tie(h1, found) = halfedge(f.z, f.x, f.m);
std::tie(h1, found) = halfedge(f.z, f.x, f.m);
assert(found);
boost::tie(h2, found) = halfedge(f.v, f.x, f.m);
std::tie(h2, found) = halfedge(f.v, f.x, f.m);
assert(found);
CGAL::Euler::join_vertex(CGAL::Euler::split_vertex(h1, h2,f.m),f.m);
assert(CGAL::is_valid_polygon_mesh(f.m));

38
BGL/test/BGL/test_Face_filtered_graph.cpp
View File

@ -29,9 +29,9 @@ void test_halfedge_around_vertex_iterator(const Graph& g)
Adapter fg(g, 0, boost::make_assoc_property_map(map));
typename boost::graph_traits<Adapter >::vertex_iterator vit, vend;
for(boost::tie(vit, vend) = vertices(fg); vit != vend; ++vit) {
for(std::tie(vit, vend) = vertices(fg); vit != vend; ++vit) {
halfedge_around_target_iterator havit, havend;
for(boost::tie(havit, havend) = CGAL::halfedges_around_target(halfedge(*vit, fg), fg);
for(std::tie(havit, havend) = CGAL::halfedges_around_target(halfedge(*vit, fg), fg);
havit != havend; ++havit) {
assert(target(*havit, fg) == *vit);
@ -56,11 +56,11 @@ void test_halfedge_around_face_iterator(const Graph& g)
Adapter fg(g, 0, boost::make_assoc_property_map(map));
face_iterator fit, fend;
for(boost::tie(fit, fend) = faces(fg); fit != fend; ++fit) {
for(std::tie(fit, fend) = faces(fg); fit != fend; ++fit) {
halfedge_around_face_iterator hafit, hafend;
boost::tie(hafit, hafend) = CGAL::halfedges_around_face(halfedge(*fit, fg), fg);
std::tie(hafit, hafend) = CGAL::halfedges_around_face(halfedge(*fit, fg), fg);
assert(std::distance(hafit, hafend) != 0);
for(boost::tie(hafit, hafend) = CGAL::halfedges_around_face(halfedge(*fit, fg), fg); hafit != hafend; ++hafit) {
for(std::tie(hafit, hafend) = CGAL::halfedges_around_face(halfedge(*fit, fg), fg); hafit != hafend; ++hafit) {
assert(face(*hafit, fg) == *fit);
}
}
@ -78,11 +78,11 @@ void test_edge_iterators(const Graph& g)
// do we iterate as many as that?
edge_iterator eb, ee;
boost::tie(eb, ee) = edges(fg);
std::tie(eb, ee) = edges(fg);
assert(static_cast<edges_size_type>(std::distance(eb, ee)) == num_edges(g));
id_map ids;
unsigned int count = 0;
for(boost::tie(eb, ee) = edges(fg); eb != ee; ++eb) {
for(std::tie(eb, ee) = edges(fg); eb != ee; ++eb) {
edge_descriptor e = *eb;
std::pair<id_map::iterator, bool> r = ids.insert(get(boost::edge_index, g, e));
// unique?
@ -103,7 +103,7 @@ void test_vertex_iterators(Graph& g)
Adapter fg(g, 0, boost::make_assoc_property_map(map));
vertex_iterator vb, ve;
std::size_t count = 0;
for(boost::tie(vb, ve) = vertices(fg); vb != ve; ++vb){
for(std::tie(vb, ve) = vertices(fg); vb != ve; ++vb){
++count;
}
@ -113,7 +113,7 @@ void test_vertex_iterators(Graph& g)
id_map ids;
count = 0;
for(boost::tie(vb, ve) = vertices(fg); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(fg); vb != ve; ++vb) {
std::pair<id_map::iterator, bool> r = ids.insert(get(boost::vertex_index, g, *vb));
assert(r.second);
++count;
@ -133,12 +133,12 @@ void test_out_edges(const Graph& g)
Adapter fg(g, 0, boost::make_assoc_property_map(map));
vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(fg); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(fg); vb != ve; ++vb) {
id_map v_ids;
vertex_descriptor around = *vb;
out_edge_iterator oeb, oee;
for(boost::tie(oeb, oee) = out_edges(*vb, fg); oeb != oee; ++oeb) {
for(std::tie(oeb, oee) = out_edges(*vb, fg); oeb != oee; ++oeb) {
vertex_descriptor t = target(*oeb, fg);
vertex_descriptor s = source(*oeb, fg);
assert(s != t);
@ -162,11 +162,11 @@ void test_in_edges(const Graph& g)
Adapter fg(g, 0, boost::make_assoc_property_map(map));
vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(fg); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(fg); vb != ve; ++vb) {
id_map v_ids;
vertex_descriptor around = *vb;
in_edge_iterator ieb, iee;
for(boost::tie(ieb, iee) = in_edges(*vb, fg); ieb != iee; ++ieb) {
for(std::tie(ieb, iee) = in_edges(*vb, fg); ieb != iee; ++ieb) {
vertex_descriptor t = target(*ieb, fg);
vertex_descriptor s = source(*ieb, fg);
assert(t == around);
@ -190,18 +190,18 @@ void test_in_out_edges(const Graph& g)
// check that the sets of in out edges are the same
vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(fg); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(fg); vb != ve; ++vb) {
id_map v_ids;
std::vector<vertex_descriptor> in, out;
in_edge_iterator ieb, iee;
for(boost::tie(ieb, iee) = in_edges(*vb, fg); ieb != iee; ++ieb) {
for(std::tie(ieb, iee) = in_edges(*vb, fg); ieb != iee; ++ieb) {
std::pair<id_map::iterator, bool> r =
v_ids.insert(get(boost::vertex_index, g, source(*ieb, fg)));
assert(r.second);
in.push_back(source(*ieb, fg));
}
out_edge_iterator oeb, oee;
for(boost::tie(oeb, oee) = out_edges(*vb, fg); oeb != oee; ++oeb) {
for(std::tie(oeb, oee) = out_edges(*vb, fg); oeb != oee; ++oeb) {
std::pair<id_map::iterator, bool> r =
v_ids.insert(get(boost::vertex_index, g, target(*oeb, fg)));
// insertion must fail
@ -232,7 +232,7 @@ void test_edge_find(const Graph& g)
typedef std::pair<edge_descriptor, bool> ret;
edge_iterator eb, ee;
for(boost::tie(eb, ee) = edges(fg); eb != ee; ++eb) {
for(std::tie(eb, ee) = edges(fg); eb != ee; ++eb) {
vertex_descriptor s = source(*eb, fg);
vertex_descriptor t = target(*eb, fg);
ret found = edge(s, t, fg);
@ -256,14 +256,14 @@ void test_faces(const Graph& g)
unsigned int count = 0;
face_iterator fb, fe;
for(boost::tie(fb, fe) = faces(fg); fb != fe; ++fb) {
for(std::tie(fb, fe) = faces(fg); fb != fe; ++fb) {
++count;
// reverse look-up
halfedge_descriptor assoc = halfedge(*fb, fg);
assert(face(assoc, fg) == *fb);
// check the enclosure
halfedge_around_face_iterator encb, ence;
for(boost::tie(encb, ence) = CGAL::halfedges_around_face(halfedge(*fb, fg), fg); encb != ence; ++encb) {
for(std::tie(encb, ence) = CGAL::halfedges_around_face(halfedge(*fb, fg), fg); encb != ence; ++encb) {
assert(face(*encb, fg) == *fb);
}
}

24
BGL/test/BGL/test_Prefix.h
View File

@ -238,7 +238,7 @@ struct Surface_fixture_1 {
pm = get(CGAL::vertex_point, const_cast<const Graph&>(m));
typename boost::graph_traits<Graph>::vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(m); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(m); vb != ve; ++vb) {
if (get(pm, *vb) == Point_3(0, 0, 0))
u = *vb;
else if(get(pm, *vb) == Point_3(1, 0, 0))
@ -259,13 +259,13 @@ struct Surface_fixture_1 {
f1 = CGAL::is_border(halfedge(u, m),m) ? face(opposite(halfedge(u, m), m), m) : face(halfedge(u, m), m);
assert(f1 != boost::graph_traits<Graph>::null_face());
CGAL::Halfedge_around_face_iterator<Graph> hafib, hafie;
for(boost::tie(hafib, hafie) = CGAL::halfedges_around_face(halfedge(f1, m), m); hafib != hafie; ++hafib)
for(std::tie(hafib, hafie) = CGAL::halfedges_around_face(halfedge(f1, m), m); hafib != hafie; ++hafib)
{
if(! CGAL::is_border(opposite(*hafib, m), m))
f2 = face(opposite(*hafib, m), m);
}
typename boost::graph_traits<Graph>::face_iterator fb, fe;
for(boost::tie(fb, fe) = faces(m); fb != fe; ++fb) {
for(std::tie(fb, fe) = faces(m); fb != fe; ++fb) {
if(*fb != f1 && *fb != f2)
f3 = *fb;
}
@ -289,7 +289,7 @@ struct Surface_fixture_2 {
pm = get(CGAL::vertex_point, const_cast<const Graph&>(m));
typename boost::graph_traits<Graph>::vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(m); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(m); vb != ve; ++vb) {
if (get(pm, *vb) == Point_3(0, 2, 0))
u = *vb;
else if(get(pm, *vb) == Point_3(2, 2, 0))
@ -308,25 +308,25 @@ struct Surface_fixture_2 {
assert(y != boost::graph_traits<Graph>::null_vertex());
typename boost::graph_traits<Graph>::halfedge_descriptor h;
bool found;
boost::tie(h, found) = halfedge(x, v, m);
std::tie(h, found) = halfedge(x, v, m);
assert(found);
assert(! CGAL::is_border(h,m));
f1 = face(h, m);
assert(f1 != boost::graph_traits<Graph>::null_face());
boost::tie(h, found) = halfedge(v, u, m);
std::tie(h, found) = halfedge(v, u, m);
assert(found);
assert(!CGAL::is_border(h,m));
f2 = face(h, m);
assert(f2 != boost::graph_traits<Graph>::null_face());
boost::tie(h, found) = halfedge(u, w, m);
std::tie(h, found) = halfedge(u, w, m);
assert(found);
assert(!CGAL::is_border(h,m));
f3 = face(h, m);
assert(f3 != boost::graph_traits<Graph>::null_face());
boost::tie(h, found) = halfedge(w, x, m);
std::tie(h, found) = halfedge(w, x, m);
assert(found);
assert(!CGAL::is_border(h,m));
f4 = face(h, m);
@ -351,7 +351,7 @@ struct Surface_fixture_3 {
pm = get(CGAL::vertex_point, const_cast<const Graph&>(m));
typename boost::graph_traits<Graph>::vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(m); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(m); vb != ve; ++vb) {
if (get(pm, *vb) == Point_3(0, 1, 0))
u = *vb;
else if(get(pm, *vb) == Point_3(0, 0, 0))
@ -399,7 +399,7 @@ struct Surface_fixture_4 {
int found = 0;
typename boost::graph_traits<Graph>::halfedge_iterator hb, he;
for(boost::tie(hb, he) = halfedges(m); hb != he; ++hb) {
for(std::tie(hb, he) = halfedges(m); hb != he; ++hb) {
if(CGAL::is_border(*hb,m)){
if(get(pm, target(*hb,m)) == Point_3(0,0,0)){
if(found == 0){
@ -435,7 +435,7 @@ struct Surface_fixture_5 {
int found = 0;
typename boost::graph_traits<Graph>::halfedge_iterator hb, he;
for(boost::tie(hb, he) = halfedges(m); hb != he; ++hb) {
for(std::tie(hb, he) = halfedges(m); hb != he; ++hb) {
if(CGAL::is_border(*hb,m)){
if(get(pm, target(*hb,m)) == Point_3(2,1,0)){
h1 = *hb;
@ -500,7 +500,7 @@ struct Surface_fixture_8 {
int found = 0;
typename boost::graph_traits<Graph>::halfedge_iterator hb, he;
for(boost::tie(hb, he) = halfedges(m); hb != he; ++hb) {
for(std::tie(hb, he) = halfedges(m); hb != he; ++hb) {
if(get(pm, source(*hb,m)) == Point_3(0,0,0) &&
get(pm, target(*hb,m)) == Point_3(1,0,0)){
h1 = *hb;

4
BGL/test/BGL/test_bgl_dual.cpp
View File

@ -42,13 +42,13 @@ int main()
{
out_edge_iterator b,e;
boost::tie(b,e) = out_edges(vd,dual);
std::tie(b,e) = out_edges(vd,dual);
std::cerr << vd << " " << source(*b,dual) << std::endl;
}
{
in_edge_iterator b,e;
boost::tie(b,e) = in_edges(vd,dual);
std::tie(b,e) = in_edges(vd,dual);
std::cerr << vd << " " << source(*b,dual) << std::endl;
}
std::cerr << "done"<< std::endl;

6
BGL/test/BGL/test_circulator.cpp
View File

@ -102,7 +102,7 @@ int main(int argc, char* argv[])
{
halfedge_around_target_iterator vit, end;
vertex_descriptor vd = target(hd,P);
boost::tie(vit,end) = halfedges_around_target(hd,P);
std::tie(vit,end) = halfedges_around_target(hd,P);
while(vit!= end) {
halfedge_descriptor hd = *vit;
assert(target(hd,P) == vd);
@ -113,7 +113,7 @@ int main(int argc, char* argv[])
{
halfedge_around_face_iterator vit, end;
boost::tie(vit,end) = halfedges_around_face(hd,P);
std::tie(vit,end) = halfedges_around_face(hd,P);
while(vit!= end) {
halfedge_descriptor hd = *vit;
@ -125,7 +125,7 @@ int main(int argc, char* argv[])
{
out_edge_iterator ohi, end;
for(boost::tie(ohi,end) = out_edges(target(hd,P),P); ohi != end; ++ohi){
for(std::tie(ohi,end) = out_edges(target(hd,P),P); ohi != end; ++ohi){
edge_descriptor ed = *ohi;
halfedge_descriptor hd2 = halfedge(ed,P);
std::cout << get(CGAL::vertex_point, P, target(hd2,P)) << std::endl;

48
BGL/test/BGL/test_graph_traits.cpp
View File

@ -26,9 +26,9 @@ void test_halfedge_around_vertex_iterator(const Graph& g)
{
CGAL_GRAPH_TRAITS_MEMBERS(Graph);
vertex_iterator vit, vend;
for(boost::tie(vit, vend) = vertices(g); vit != vend; ++vit) {
for(std::tie(vit, vend) = vertices(g); vit != vend; ++vit) {
halfedge_around_target_iterator havit, havend;
for(boost::tie(havit, havend) = CGAL::halfedges_around_target(halfedge(*vit, g), g);
for(std::tie(havit, havend) = CGAL::halfedges_around_target(halfedge(*vit, g), g);
havit != havend; ++havit) {
assert(target(*havit, g) == *vit);
@ -47,11 +47,11 @@ void test_halfedge_around_face_iterator(const Graph& g)
{
CGAL_GRAPH_TRAITS_MEMBERS(Graph);
face_iterator fit, fend;
for(boost::tie(fit, fend) = faces(g); fit != fend; ++fit) {
for(std::tie(fit, fend) = faces(g); fit != fend; ++fit) {
halfedge_around_face_iterator hafit, hafend;
boost::tie(hafit, hafend) = CGAL::halfedges_around_face(halfedge(*fit, g), g);
std::tie(hafit, hafend) = CGAL::halfedges_around_face(halfedge(*fit, g), g);
assert(std::distance(hafit, hafend) != 0);
for(boost::tie(hafit, hafend) = CGAL::halfedges_around_face(halfedge(*fit, g), g); hafit != hafend; ++hafit) {
for(std::tie(hafit, hafend) = CGAL::halfedges_around_face(halfedge(*fit, g), g); hafit != hafend; ++hafit) {
assert(face(*hafit, g) == *fit);
}
}
@ -66,12 +66,12 @@ void test_halfedge_iterators(const G& g)
// do we iterate as many as that?
halfedge_iterator hb, he;
boost::tie(hb, he) = halfedges(g);
std::tie(hb, he) = halfedges(g);
assert(static_cast<halfedges_size_type>(std::distance(hb, he)) == num_halfedges(g));
id_map ids;
unsigned int count = 0;
for(boost::tie(hb, he) = halfedges(g); hb != he; ++hb) {
for(std::tie(hb, he) = halfedges(g); hb != he; ++hb) {
std::pair<id_map::iterator, bool> r = ids.insert(get(boost::halfedge_index, g, *hb));
// unique?
assert(r.second);
@ -92,12 +92,12 @@ void test_edge_iterators(const G& g)
// do we iterate as many as that?
edge_iterator eb, ee;
boost::tie(eb, ee) = edges(g);
std::tie(eb, ee) = edges(g);
assert(static_cast<edges_size_type>(std::distance(eb, ee)) == num_edges(g));
id_map ids;
unsigned int count = 0;
for(boost::tie(eb, ee) = edges(g); eb != ee; ++eb) {
for(std::tie(eb, ee) = edges(g); eb != ee; ++eb) {
edge_descriptor e = *eb;
std::pair<id_map::iterator, bool> r = ids.insert(get(boost::edge_index, g, e));
// unique?
@ -115,7 +115,7 @@ void test_vertex_iterators(const G& g)
vertex_iterator vb, ve;
std::size_t count = 0;
for(boost::tie(vb, ve) = vertices(g); vb != ve; ++vb){
for(std::tie(vb, ve) = vertices(g); vb != ve; ++vb){
++count;
}
@ -125,7 +125,7 @@ void test_vertex_iterators(const G& g)
id_map ids;
count = 0;
for(boost::tie(vb, ve) = vertices(g); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(g); vb != ve; ++vb) {
std::pair<id_map::iterator, bool> r = ids.insert(get(boost::vertex_index, g, *vb));
assert(r.second);
++count;
@ -142,12 +142,12 @@ void test_out_edges(const G& g)
typedef typename Traits::vertex_descriptor vertex_descriptor;
vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(g); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(g); vb != ve; ++vb) {
id_map v_ids;
vertex_descriptor around = *vb;
out_edge_iterator oeb, oee;
for(boost::tie(oeb, oee) = out_edges(*vb, g); oeb != oee; ++oeb) {
for(std::tie(oeb, oee) = out_edges(*vb, g); oeb != oee; ++oeb) {
vertex_descriptor t = target(*oeb, g);
vertex_descriptor s = source(*oeb, g);
assert(s != t);
@ -169,11 +169,11 @@ void test_in_edges(const G& g)
typedef typename Traits::vertex_descriptor vertex_descriptor;
vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(g); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(g); vb != ve; ++vb) {
id_map v_ids;
vertex_descriptor around = *vb;
in_edge_iterator ieb, iee;
for(boost::tie(ieb, iee) = in_edges(*vb, g); ieb != iee; ++ieb) {
for(std::tie(ieb, iee) = in_edges(*vb, g); ieb != iee; ++ieb) {
vertex_descriptor t = target(*ieb, g);
vertex_descriptor s = source(*ieb, g);
assert(t == around);
@ -196,18 +196,18 @@ void test_in_out_edges(const G& g)
// check that the sets of in out edges are the same
vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(g); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(g); vb != ve; ++vb) {
id_map v_ids;
std::vector<vertex_descriptor> in, out;
in_edge_iterator ieb, iee;
for(boost::tie(ieb, iee) = in_edges(*vb, g); ieb != iee; ++ieb) {
for(std::tie(ieb, iee) = in_edges(*vb, g); ieb != iee; ++ieb) {
std::pair<id_map::iterator, bool> r =
v_ids.insert(get(boost::vertex_index, g, source(*ieb, g)));
assert(r.second);
in.push_back(source(*ieb, g));
}
out_edge_iterator oeb, oee;
for(boost::tie(oeb, oee) = out_edges(*vb, g); oeb != oee; ++oeb) {
for(std::tie(oeb, oee) = out_edges(*vb, g); oeb != oee; ++oeb) {
std::pair<id_map::iterator, bool> r =
v_ids.insert(get(boost::vertex_index, g, target(*oeb, g)));
// insertion must fail
@ -239,13 +239,13 @@ void test_adjacent_vertices(const G& g)
vertex_descriptor v = *(vertices(g).begin());
adjacency_iterator vb, ve;
boost::tie(vb, ve) = adjacent_vertices(v, g);
std::tie(vb, ve) = adjacent_vertices(v, g);
in_edge_iterator ieb, iee;
boost::tie(ieb, iee) = in_edges(v, g);
std::tie(ieb, iee) = in_edges(v, g);
out_edge_iterator oeb, oee;
boost::tie(oeb, oee) = out_edges(v, g);
std::tie(oeb, oee) = out_edges(v, g);
assert(std::distance(vb, ve) == std::distance(ieb, iee));
assert(std::distance(vb, ve) == std::distance(oeb, oee));
@ -271,7 +271,7 @@ void test_edge_find(const G& g)
typedef std::pair<edge_descriptor, bool> ret;
edge_iterator eb, ee;
for(boost::tie(eb, ee) = edges(g); eb != ee; ++eb) {
for(std::tie(eb, ee) = edges(g); eb != ee; ++eb) {
vertex_descriptor s = source(*eb, g);
vertex_descriptor t = target(*eb, g);
ret found = edge(s, t, g);
@ -293,14 +293,14 @@ void test_faces(const G& g)
unsigned int count = 0;
face_iterator fb, fe;
for(boost::tie(fb, fe) = faces(g); fb != fe; ++fb) {
for(std::tie(fb, fe) = faces(g); fb != fe; ++fb) {
++count;
// reverse look-up
halfedge_descriptor assoc = halfedge(*fb, g);
assert(face(assoc, g) == *fb);
// check the enclosure
halfedge_around_face_iterator encb, ence;
for(boost::tie(encb, ence) = CGAL::halfedges_around_face(halfedge(*fb, g), g); encb != ence; ++encb) {
for(std::tie(encb, ence) = CGAL::halfedges_around_face(halfedge(*fb, g), g); encb != ence; ++encb) {
assert(face(*encb, g) == *fb);
}
}

2
Basic_viewer/examples/Basic_viewer/draw_surface_mesh_small_faces.cpp
View File

@ -92,7 +92,7 @@ int main(int argc, char* argv[])
Mesh::Property_map<face_descriptor, FT> faces_size;
bool created;
boost::tie(faces_size, created)=sm.add_property_map<face_descriptor, FT>("f:size",0.);
std::tie(faces_size, created)=sm.add_property_map<face_descriptor, FT>("f:size",0.);
assert(created);
for(face_descriptor fd : sm.faces())

2
CGAL_ipelets/demo/CGAL_ipelets/alpha_shapes.cpp
View File

@ -85,7 +85,7 @@ void ASphapeIpelet::protected_run(int fn)
Alpha_shape_2 A(LWP.begin(),LWP.end());
int alpha=-1;
int nb_ret;
boost::tie(nb_ret,alpha)=request_value_from_user<int>((boost::format("# Spectral critical value (0-%d)") % A.number_of_alphas()).str() );
std::tie(nb_ret,alpha)=request_value_from_user<int>((boost::format("# Spectral critical value (0-%d)") % A.number_of_alphas()).str() );
if (nb_ret == -1) return;
if(alpha<0 || (std::size_t) alpha>A.number_of_alphas()){

4
CGAL_ipelets/demo/CGAL_ipelets/cone_spanners.cpp
View File

@ -86,7 +86,7 @@ void Cone_spanners_ipelet::protected_run(int fn)
}
int ret_val;
boost::tie(ret_val,number_of_cones)=request_value_from_user<int>("Enter the number of cones");
std::tie(ret_val,number_of_cones)=request_value_from_user<int>("Enter the number of cones");
if (ret_val < 0) {
print_error_message("Incorrect value");
return;
@ -129,7 +129,7 @@ void Cone_spanners_ipelet::protected_run(int fn)
}
}
boost::graph_traits<Graph>::edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
for (std::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
boost::graph_traits<Graph>::edge_descriptor e = *ei;
boost::graph_traits<Graph>::vertex_descriptor u = source(e, g);
boost::graph_traits<Graph>::vertex_descriptor v = target(e, g);

4
CGAL_ipelets/demo/CGAL_ipelets/generator.cpp
View File

@ -83,7 +83,7 @@ void generator::protected_run(int fn)
origin= Kernel::Vector_2((bbox.xmin()+bbox.xmax())/2,(bbox.ymin()+bbox.ymax())/2);
if (size<1){
size=200;
//boost::tie(ret_val,size)=request_value_from_user<int>((boost::format("Size (default : %1%)") % size).str());
//std::tie(ret_val,size)=request_value_from_user<int>((boost::format("Size (default : %1%)") % size).str());
//if (ret_val == -1) return;
//if (ret_val == 0) size=200;
origin = Kernel::Vector_2(200,200);
@ -92,7 +92,7 @@ void generator::protected_run(int fn)
int nbelements=30;
boost::tie(ret_val,nbelements)=request_value_from_user<int>((boost::format("Number of elements (default : %1%)") % nbelements).str() );
std::tie(ret_val,nbelements)=request_value_from_user<int>((boost::format("Number of elements (default : %1%)") % nbelements).str() );
if (ret_val == -1) return;
if (ret_val == 0) nbelements=30;

2
CGAL_ipelets/demo/CGAL_ipelets/mesh_2.cpp
View File

@ -94,7 +94,7 @@ void IpeletMesh2::protected_run(int fn)
int y=static_cast<int>( floor((bbox.max)().y()-(bbox.min)().y()) );
int ret_val;
boost::tie(ret_val,alpha)=request_value_from_user<double>((boost::format("Max edge length (BBox %1%x%2%)") % x % y).str() );
std::tie(ret_val,alpha)=request_value_from_user<double>((boost::format("Max edge length (BBox %1%x%2%)") % x % y).str() );
if (ret_val == -1) return;
if(alpha<0){

4
CGAL_ipelets/demo/CGAL_ipelets/mst.cpp
View File

@ -82,9 +82,9 @@ void mstIpelet::protected_run(int /*fn*/)
vertex_iterator vit, ve;
// Associate indices to the vertices
int index = 0;
// boost::tie assigns the first and second element of the std::pair
// std::tie assigns the first and second element of the std::pair
// returned by boost::vertices to the variables vit and ve
for(boost::tie(vit,ve)=boost::vertices(ft); vit!=ve; ++vit ){
for(std::tie(vit,ve)=boost::vertices(ft); vit!=ve; ++vit ){
vertex_descriptor vd = *vit;
vertex_id_map[vd] = index++;
}

2
CGAL_ipelets/demo/CGAL_ipelets/multi_delaunay.cpp
View File

@ -172,7 +172,7 @@ void MdelaunayIpelet::protected_run(int fn)
if(fn==4 ||fn==9){
int order;
int ret_val;
boost::tie(ret_val,order)=request_value_from_user<int>("Enter order");
std::tie(ret_val,order)=request_value_from_user<int>("Enter order");
if (ret_val < 0){
print_error_message("Incorrect value");
return;

2
CGAL_ipelets/demo/CGAL_ipelets/multi_regular.cpp
View File

@ -80,7 +80,7 @@ void MregularIpelet::protected_run(int fn)
if(fn==4 || fn==9){
int ret_val;
boost::tie(ret_val,order)=request_value_from_user<int>("Enter order");
std::tie(ret_val,order)=request_value_from_user<int>("Enter order");
if (ret_val < 0){
print_error_message("Incorrect value");
return;

2
CGAL_ipelets/demo/CGAL_ipelets/nearest_neighbor_graph.cpp
View File

@ -56,7 +56,7 @@ void nngIpelet::protected_run(int fn)
int ret_val;
int kNeighbors=1;
boost::tie(ret_val,kNeighbors)=request_value_from_user<int>((boost::format("Number of nearest neighbors (default : k=%1%)") % kNeighbors).str() );
std::tie(ret_val,kNeighbors)=request_value_from_user<int>((boost::format("Number of nearest neighbors (default : k=%1%)") % kNeighbors).str() );
if (ret_val == -1) return;
if (ret_val == 0) kNeighbors=1;

2
CGAL_ipelets/demo/CGAL_ipelets/skeleton.cpp
View File

@ -124,7 +124,7 @@ void SkeletonIpelet::protected_run(int fn)
if (fn==0 || fn==1)
draw_straight_skeleton(*ss,max_edge);
else{
boost::tie(ret_val,dist)=
std::tie(ret_val,dist)=
request_value_from_user<double>(
(boost::format("Offset value (BBox %1%x%2%)") % (bbox.xmax()-bbox.xmin()) % (bbox.ymax()-bbox.ymin())).str()
);

2
Classification/include/CGAL/Classification/Feature/Vertical_dispersion.h
View File

@ -127,7 +127,7 @@ public:
continue;
std::vector<float>::iterator min_it, max_it;
boost::tie(min_it, max_it)
std::tie(min_it, max_it)
= boost::minmax_element (hori.begin(), hori.end());
std::vector<bool> occupy (1 + (std::size_t)((*max_it - *min_it) / grid.resolution()), false);

5
Classification/include/CGAL/Classification/Point_set_neighborhood.h
View File

@ -317,9 +317,8 @@ private:
Point ref (std::floor(p.x() / voxel_size),
std::floor(p.y() / voxel_size),
std::floor(p.z() / voxel_size));
typename std::map<Point, std::vector<std::uint32_t> >::iterator it;
boost::tie (it, boost::tuples::ignore)
= grid.insert (std::make_pair (ref, std::vector<std::uint32_t>()));
typename std::map<Point, std::vector<std::uint32_t> >::iterator it
= grid.insert (std::make_pair (ref, std::vector<std::uint32_t>())).first;
it->second.push_back (i);
}

4
Classification/test/Classification/test_classification_point_set.cpp
View File

@ -53,9 +53,9 @@ int main (int, char**)
map_added = pts.add_normal_map().second;
assert (map_added);
normal_map = pts.normal_map();
boost::tie (echo_map, map_added) = pts.add_property_map<std::size_t> ("echo");
std::tie (echo_map, map_added) = pts.add_property_map<std::size_t> ("echo");
assert (map_added);
boost::tie (color_map, map_added) = pts.add_property_map<CGAL::IO::Color> ("color");
std::tie (color_map, map_added) = pts.add_property_map<CGAL::IO::Color> ("color");
assert (map_added);
for (std::size_t i = 0; i < 1000; ++ i)

2
Cone_spanners_2/examples/Cone_spanners_2/dijkstra_theta.cpp
View File

@ -72,7 +72,7 @@ int main(int argc, char ** argv)
// calculating edge length in Euclidean distance and store them in the edge property
boost::graph_traits<Graph>::edge_iterator ei, ei_end;
for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
for (std::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
boost::graph_traits<Graph>::edge_descriptor e = *ei;
boost::graph_traits<Graph>::vertex_descriptor u = source(e, g);
boost::graph_traits<Graph>::vertex_descriptor v = target(e, g);

4
Cone_spanners_2/include/CGAL/Construct_theta_graph_2.h
View File

@ -193,7 +193,7 @@ protected:
const Less_by_direction orderMid(g, cw90(bisector_direction));
typename Graph_::vertex_iterator vit, ve;
boost::tie(vit, ve) = boost::vertices(g);
std::tie(vit, ve) = boost::vertices(g);
// Step 1: Sort S according to order induced by D1
std::vector<typename Graph_::vertex_descriptor> S(vit, ve);
@ -218,7 +218,7 @@ protected:
typename Graph_::edge_descriptor existing_e;
bool existing;
// check whether the edge already exists
boost::tie(existing_e, existing)=boost::edge(*it, *ri, g);
std::tie(existing_e, existing)=boost::edge(*it, *ri, g);
if (!existing)
boost::add_edge(*it, *ri, g);
}

4
Cone_spanners_2/include/CGAL/Construct_yao_graph_2.h
View File

@ -179,7 +179,7 @@ protected:
const Less_by_direction orderD2 (g, cwBound);
typename Graph_::vertex_iterator vit, ve;
boost::tie(vit, ve) = boost::vertices(g);
std::tie(vit, ve) = boost::vertices(g);
// Step 1: Sort S according to order induced by D1
std::vector<typename Graph_::vertex_descriptor> S(vit, ve);
@ -205,7 +205,7 @@ protected:
typename Graph_::edge_descriptor existing_e;
bool existing;
// check whether the edge already exists
boost::tie(existing_e, existing)=boost::edge(*it, *min, g);
std::tie(existing_e, existing)=boost::edge(*it, *min, g);
if (!existing)
boost::add_edge(*it, *min, g);
}

4
Cone_spanners_2/include/CGAL/gnuplot_output_2.h
View File

@ -109,7 +109,7 @@ std::string gnuplot_edge_list (const Graph& g)
ss << std::fixed; // Use fixed floating-point notation
typename Graph::edge_iterator eit, ee;
for (boost::tie(eit, ee) = boost::edges(g); eit != ee; ++eit) {
for (std::tie(eit, ee) = boost::edges(g); eit != ee; ++eit) {
typename Graph::vertex_descriptor src = boost::source(*eit, g);
typename Graph::vertex_descriptor end = boost::target(*eit, g);
ss << "set arrow from ";
@ -129,7 +129,7 @@ std::string gnuplot_vertex_list(const Graph& g) {
ss << std::fixed;
typename Graph::vertex_iterator vit, ve;
for (boost::tie(vit, ve) = boost::vertices(g); vit != ve; ++vit) {
for (std::tie(vit, ve) = boost::vertices(g); vit != ve; ++vit) {
ss << to_double(g[*vit].x()) << " " << to_double(g[*vit].y()) << std::endl;
}
return ss.str();

2
Convex_hull_3/include/CGAL/convex_hull_3.h
View File

@ -963,7 +963,7 @@ convex_hull_3(InputIterator first, InputIterator beyond,
}
CGAL_assertion(num_vertices(P)>=3);
typename boost::graph_traits<Polyhedron>::vertex_iterator b,e;
boost::tie(b,e) = vertices(P);
std::tie(b,e) = vertices(P);
if (num_vertices(P) == 3){
typename boost::property_map<Polyhedron, vertex_point_t>::type vpmap = get(CGAL::vertex_point, P);
typedef typename Traits::Triangle_3 Triangle_3;

4
Convex_hull_3/include/CGAL/convexity_check_3.h
View File

@ -83,7 +83,7 @@ bool is_strongly_convex_3(const Polyhedron& P, const Traits& traits)
typename boost::property_map<Polyhedron, vertex_point_t>::const_type vpmap = get(CGAL::vertex_point, P);
vertex_iterator v_it, v_it_e;
boost::tie(v_it, v_it_e) = vertices(P);
std::tie(v_it, v_it_e) = vertices(P);
if (v_it == v_it_e) return false;
@ -97,7 +97,7 @@ bool is_strongly_convex_3(const Polyhedron& P, const Traits& traits)
typename Traits::Coplanar_3 coplanar = traits.coplanar_3_object();
face_iterator f_it, f_it_e;
boost::tie(f_it, f_it_e) = faces(P);
std::tie(f_it, f_it_e) = faces(P);
Point_3 p;
Point_3 q;
Point_3 r;

2
HalfedgeDS/include/CGAL/boost/graph/properties_HalfedgeDS_base.h
View File

@ -70,7 +70,7 @@ public:
{
unsigned int data = 0;
typename boost::graph_traits<Polyhedron>::edge_iterator it, end;
for(boost::tie(it, end) = edges(p); it != end; ++it, ++data)
for(std::tie(it, end) = edges(p); it != end; ++it, ++data)
(*map_)[*it] = data;
}

4
Hash_map/benchmark/Hash_map/hm.cpp
View File

@ -157,11 +157,11 @@ run(const G& g)
#if 0
std::cerr << "boost::tie(vb,ve) = vertices(g);\n";
std::cerr << "std::tie(vb,ve) = vertices(g);\n";
t.reset(); t.start();
for(int i=0; i<100; i++){
typename boost::graph_traits<G>::vertex_iterator vb, ve;
boost::tie(vb,ve) = vertices(g);
std::tie(vb,ve) = vertices(g);
for(; vb != ve; ++vb) {
vertex_descriptor vd = *vb;
#ifdef NOHASH

6
Heat_method_3/include/CGAL/Heat_method_3/Surface_mesh_geodesic_distances_3.h
View File

@ -297,7 +297,7 @@ private:
}
CGAL::Vertex_around_face_iterator<TriangleMesh> vbegin, vend, vmiddle;
for(face_descriptor f : faces(tm)) {
boost::tie(vbegin, vend) = vertices_around_face(halfedge(f,tm),tm);
std::tie(vbegin, vend) = vertices_around_face(halfedge(f,tm),tm);
vertex_descriptor current = *(vbegin);
vertex_descriptor neighbor_one = *(++vbegin);
vertex_descriptor neighbor_two = *(++vbegin);
@ -350,7 +350,7 @@ private:
Matrix indexD(dimension,1);
CGAL::Vertex_around_face_iterator<TriangleMesh> vbegin, vend, vmiddle;
for(face_descriptor f : faces(tm)) {
boost::tie(vbegin, vend) = vertices_around_face(halfedge(f,tm),tm);
std::tie(vbegin, vend) = vertices_around_face(halfedge(f,tm),tm);
vertex_descriptor current = *(vbegin);
vertex_descriptor neighbor_one = *(++vbegin);
vertex_descriptor neighbor_two = *(++vbegin);
@ -514,7 +514,7 @@ private:
CGAL::Vertex_around_face_iterator<TriangleMesh> vbegin, vend, vmiddle;
for(face_descriptor f : faces(tm)) {
boost::tie(vbegin, vend) = vertices_around_face(halfedge(f,tm),tm);
std::tie(vbegin, vend) = vertices_around_face(halfedge(f,tm),tm);
vertex_descriptor current = *(vbegin);
vertex_descriptor neighbor_one = *(++vbegin);
vertex_descriptor neighbor_two = *(++vbegin);

2
Heat_method_3/include/CGAL/Heat_method_3/internal/Intrinsic_Delaunay_triangulation_3.h
View File

@ -446,7 +446,7 @@ private:
for(face_descriptor f : faces(m_intrinsic_tm)) {
CGAL::Vertex_around_face_iterator<TriangleMesh> vbegin, vend, vmiddle;
boost::tie(vbegin, vend) = vertices_around_face(halfedge(f,m_intrinsic_tm),m_intrinsic_tm);
std::tie(vbegin, vend) = vertices_around_face(halfedge(f,m_intrinsic_tm),m_intrinsic_tm);
halfedge_descriptor hd = halfedge(f,m_intrinsic_tm);
if(face(hd,m_intrinsic_tm) != f) {
hd = opposite(hd,m_intrinsic_tm);

4
Lab/demo/Lab/Plugins/Classification/Cluster_classification.cpp
View File

@ -46,9 +46,9 @@ Cluster_classification::Cluster_classification(Scene_points_with_normal_item* po
std::cerr << m_clusters.size() << " cluster(s) found" << std::endl;
bool training_found = false;
boost::tie (m_training, training_found) = m_points->point_set()->add_property_map<int>("training", -1);
std::tie (m_training, training_found) = m_points->point_set()->add_property_map<int>("training", -1);
bool classif_found = false;
boost::tie (m_classif, classif_found) = m_points->point_set()->add_property_map<int>("label", -1);
std::tie (m_classif, classif_found) = m_points->point_set()->add_property_map<int>("label", -1);
training_found = !training_found; // add_property_map returns false if
classif_found = !classif_found; // property was already there

4
Lab/demo/Lab/Plugins/Classification/Point_set_item_classification.cpp
View File

@ -41,9 +41,9 @@ Point_set_item_classification::Point_set_item_classification(Scene_points_with_n
backup_existing_colors_and_add_new();
bool training_found = false;
boost::tie (m_training, training_found) = m_points->point_set()->add_property_map<int>("training", -1);
std::tie (m_training, training_found) = m_points->point_set()->add_property_map<int>("training", -1);
bool classif_found = false;
boost::tie (m_classif, classif_found) = m_points->point_set()->add_property_map<int>("label", -1);
std::tie (m_classif, classif_found) = m_points->point_set()->add_property_map<int>("label", -1);
training_found = !training_found; // add_property_map returns false if
classif_found = !classif_found; // property was already there

2
Lab/demo/Lab/Plugins/Mesh_2/Mesh_2_plugin.cpp
View File

@ -124,7 +124,7 @@ void cdt2_to_face_graph(const CDT& cdt, TriangleMesh& tm, int constant_coordinat
{
typename Map::iterator it;
bool insert_ok;
boost::tie(it,insert_ok) =
std::tie(it,insert_ok) =
descriptors.insert(std::make_pair(fit->vertex(i),vertex_descriptor()));
if (insert_ok){
const Kernel::Point_3& pt=fit->vertex(i)->point();

2
Lab/demo/Lab/Plugins/PMP/Engrave_text_plugin.cpp
View File

@ -897,7 +897,7 @@ private:
{
typename Map::iterator it;
bool insert_ok;
boost::tie(it,insert_ok) =
std::tie(it,insert_ok) =
descriptors.insert(std::make_pair(fit->vertex(i),vertex_descriptor()));
if (insert_ok){
const EPICK::Point_2& pt=fit->vertex(i)->point();

2
Lab/demo/Lab/Plugins/PMP/Interpolated_corrected_principal_curvatures_plugin.cpp
View File

@ -67,7 +67,7 @@ void compute(SMesh* sMesh,
bool created = false;
SMesh::Property_map<Vertex_descriptor, PMP::Principal_curvatures_and_directions<Epic_kernel>> principal_curvatures_and_directions_map;
boost::tie(principal_curvatures_and_directions_map, created) = sMesh->add_property_map<Vertex_descriptor, PMP::Principal_curvatures_and_directions<Epic_kernel>>
std::tie(principal_curvatures_and_directions_map, created) = sMesh->add_property_map<Vertex_descriptor, PMP::Principal_curvatures_and_directions<Epic_kernel>>
("v:principal_curvatures_and_directions_map", { 0, 0,
Vector(0,0,0),
Vector(0,0,0) });

2
Lab/demo/Lab/Plugins/PMP/Mean_curvature_flow_skeleton_plugin.cpp
View File

@ -692,7 +692,7 @@ if(!contracted_item)
item->mcs->poles(pole_points);
vertex_iterator vb, ve;
int id = 0;
for (boost::tie(vb, ve) = vertices(*pMesh); vb != ve; ++vb)
for (std::tie(vb, ve) = vertices(*pMesh); vb != ve; ++vb)
{
std::vector<Point> line;
line.clear();

4
Lab/demo/Lab/Plugins/PMP/Orient_soup_plugin.cpp
View File

@ -116,7 +116,7 @@ void set_vcolors(SMesh* smesh, std::vector<CGAL::IO::Color> colors)
SMesh::Property_map<vertex_descriptor, CGAL::IO::Color> vcolors =
smesh->property_map<vertex_descriptor, CGAL::IO::Color >("v:color").value();
bool created;
boost::tie(vcolors, created) = smesh->add_property_map<SMesh::Vertex_index,CGAL::IO::Color>("v:color",CGAL::IO::Color(0,0,0));
std::tie(vcolors, created) = smesh->add_property_map<SMesh::Vertex_index,CGAL::IO::Color>("v:color",CGAL::IO::Color(0,0,0));
assert(colors.size()==smesh->number_of_vertices());
int color_id = 0;
for(vertex_descriptor vd : vertices(*smesh))
@ -130,7 +130,7 @@ void set_fcolors(SMesh* smesh, std::vector<CGAL::IO::Color> colors)
SMesh::Property_map<face_descriptor, CGAL::IO::Color> fcolors =
smesh->property_map<face_descriptor, CGAL::IO::Color >("f:color").value();
bool created;
boost::tie(fcolors, created) = smesh->add_property_map<SMesh::Face_index,CGAL::IO::Color>("f:color",CGAL::IO::Color(0,0,0));
std::tie(fcolors, created) = smesh->add_property_map<SMesh::Face_index,CGAL::IO::Color>("f:color",CGAL::IO::Color(0,0,0));
assert(colors.size()==smesh->number_of_faces());
int color_id = 0;
for(face_descriptor fd : faces(*smesh))

4
Lab/demo/Lab/Plugins/PMP/Selection_plugin.cpp
View File

@ -701,7 +701,7 @@ public Q_SLOTS:
begin != selection_item->selected_edges.end(); ++begin)
{
fg_vertex_descriptor source = target(opposite(halfedge(*begin,*poly),*poly),*poly);
boost::tie(it_find, insert_OK)
std::tie(it_find, insert_OK)
= p2vd.insert(std::make_pair(source, Edge_graph::vertex_descriptor()));
if (insert_OK)
{
@ -711,7 +711,7 @@ public Q_SLOTS:
Edge_graph::vertex_descriptor src=it_find->second;
fg_vertex_descriptor targ = target(halfedge(*begin,*poly),*poly);
boost::tie(it_find, insert_OK)
std::tie(it_find, insert_OK)
= p2vd.insert(std::make_pair(targ, Edge_graph::vertex_descriptor()));
if (insert_OK)
{

4
Lab/demo/Lab/Plugins/Point_set/Point_set_shape_detection_plugin.cpp
View File

@ -277,7 +277,7 @@ private:
Point_set::Property_map<int> shape_id;
if (dialog.add_property()) {
bool added = false;
boost::tie(shape_id, added) = points->template add_property_map<int> ("shape", -1);
std::tie(shape_id, added) = points->template add_property_map<int> ("shape", -1);
if (!added) {
for (auto it = points->begin(); it != points->end(); ++ it)
shape_id[*it] = -1;
@ -563,7 +563,7 @@ private:
if (dialog.add_property())
{
bool added = false;
boost::tie (shape_id, added) = points->template add_property_map<int> ("shape", -1);
std::tie (shape_id, added) = points->template add_property_map<int> ("shape", -1);
if (!added)
{
for (Point_set::iterator it = points->begin(); it != points->end(); ++ it)

8
Lab/demo/Lab/Plugins/Point_set/Point_set_to_mesh_distance_plugin.cpp
View File

@ -223,10 +223,10 @@ private Q_SLOTS:
bool d, r, g, b;
new_item->point_set()->remove_colors();
//bind pmaps
boost::tie(distance_map , d) = new_item->point_set()->add_property_map<double>("distance",0);
boost::tie(fred_map , r) = new_item->point_set()->add_property_map<double>("red",0);
boost::tie(fgreen_map, g) = new_item->point_set()->add_property_map<double>("green",0);
boost::tie(fblue_map , b) = new_item->point_set()->add_property_map<double>("blue",0);
std::tie(distance_map , d) = new_item->point_set()->add_property_map<double>("distance",0);
std::tie(fred_map , r) = new_item->point_set()->add_property_map<double>("red",0);
std::tie(fgreen_map, g) = new_item->point_set()->add_property_map<double>("green",0);
std::tie(fblue_map , b) = new_item->point_set()->add_property_map<double>("blue",0);
new_item->point_set()->check_colors();
Point_set* points = new_item->point_set();

2
Lab/demo/Lab/Plugins/Surface_mesh/Scene_polyhedron_shortest_path_item.cpp
View File

@ -562,7 +562,7 @@ bool Scene_polyhedron_shortest_path_item::deferred_load(
std::vector<face_descriptor> listOfFaces;
listOfFaces.reserve(CGAL::num_faces(*polyhedron()));
face_iterator current, end;
for (boost::tie(current, end) = CGAL::faces(*polyhedron()); current != end; ++current)
for (std::tie(current, end) = CGAL::faces(*polyhedron()); current != end; ++current)
{
listOfFaces.push_back(*current);
}

4
Lab/demo/Lab/Plugins/Surface_mesh_deformation/Scene_edit_polyhedron_item.cpp
View File

@ -1572,7 +1572,7 @@ void Scene_edit_polyhedron_item_priv::read_roi(const char* file_name, Mesh* mesh
std::vector<mesh_vd> all_vertices;
all_vertices.reserve(num_vertices(fs.get_deform_mesh(mesh)->halfedge_graph()));
mesh_vi vb, ve;
for(boost::tie(vb, ve) = vertices(fs.get_deform_mesh(mesh)->halfedge_graph()); vb != ve; ++vb) {
for(std::tie(vb, ve) = vertices(fs.get_deform_mesh(mesh)->halfedge_graph()); vb != ve; ++vb) {
all_vertices.push_back(*vb);
}
// read roi
@ -1731,7 +1731,7 @@ void Scene_edit_polyhedron_item::update_normals() {
void Scene_edit_polyhedron_item::set_all_vertices_as_roi()
{
boost::graph_traits<SMesh>::vertex_iterator vb, ve;
for(boost::tie(vb, ve) = vertices(*surface_mesh()); vb != ve; ++vb)
for(std::tie(vb, ve) = vertices(*surface_mesh()); vb != ve; ++vb)
{
insert_roi_vertex<SMesh>(*vb, surface_mesh());
}

2
Lab/demo/Lab/Scene_polyhedron_selection_item.h
View File

@ -415,7 +415,7 @@ public:
fg_vertex_descriptor t = all_vertices[id2];
fg_halfedge_descriptor hd;
bool exists;
boost::tie(hd,exists) = halfedge(s,t,*polyhedron());
std::tie(hd,exists) = halfedge(s,t,*polyhedron());
if(! exists) { return false; }
selected_edges.insert(edge(hd,*polyhedron()));
}

20
Lab/demo/Lab/include/Point_set_3.h
View File

@ -135,7 +135,7 @@ public:
bool add_radius()
{
bool out = false;
boost::tie (m_radius, out) = this->template add_property_map<double> ("radius", 0.);
std::tie (m_radius, out) = this->template add_property_map<double> ("radius", 0.);
return out;
}
double& radius (const Index& index) { return m_radius[index]; }
@ -409,21 +409,15 @@ public:
{
if (other.template has_property_map<unsigned char>("red"))
{
boost::tie (m_red, boost::tuples::ignore)
= this->template add_property_map<unsigned char>("red", 0);
boost::tie (m_green, boost::tuples::ignore)
= this->template add_property_map<unsigned char>("green", 0);
boost::tie (m_blue, boost::tuples::ignore)
= this->template add_property_map<unsigned char>("blue", 0);
m_red = this->template add_property_map<unsigned char>("red", 0).first;
m_green = this->template add_property_map<unsigned char>("green", 0).first;
m_blue = this->template add_property_map<unsigned char>("blue", 0).first;
}
else
{
boost::tie (m_red, boost::tuples::ignore)
= this->template add_property_map<unsigned char>("r", 0);
boost::tie (m_green, boost::tuples::ignore)
= this->template add_property_map<unsigned char>("g", 0);
boost::tie (m_blue, boost::tuples::ignore)
= this->template add_property_map<unsigned char>("b", 0);
m_red = this->template add_property_map<unsigned char>("r", 0).first;
m_green = this->template add_property_map<unsigned char>("g", 0).first;
m_blue = this->template add_property_map<unsigned char>("b", 0).first;
}
}

4
Mesh_3/include/CGAL/Mesh_3/internal/Graph_manipulations.h
View File

@ -100,7 +100,7 @@ struct Graph_manipulations
edge_descriptor edge;
bool b;
// test if the edge is already here, using add_edge
boost::tie(edge, b) = add_edge(va, vb, g);
std::tie(edge, b) = add_edge(va, vb, g);
remove_edge(edge, g);
if(!b) {
// The edge was already here.
@ -129,7 +129,7 @@ struct Graph_manipulations
if(v1 != v2) {
edge_descriptor edge;
bool b;
boost::tie(edge, b) = add_edge(v1, v2, g);
std::tie(edge, b) = add_edge(v1, v2, g);
return b;
} else
return false;

2
Mesh_3/include/CGAL/Mesh_3/internal/helpers.h
View File

@ -72,7 +72,7 @@ struct Angle_tester
else
{
out_edge_iterator out_edge_it, out_edges_end;
boost::tie(out_edge_it, out_edges_end) = out_edges(v, g);
std::tie(out_edge_it, out_edges_end) = out_edges(v, g);
vertex_descriptor v1 = target(*out_edge_it++, g);
vertex_descriptor v2 = target(*out_edge_it++, g);

2
Mesh_3/include/CGAL/Mesh_3/polylines_to_protect.h
View File

@ -325,7 +325,7 @@ struct Angle_tester
else
{
out_edge_iterator out_edge_it, out_edges_end;
boost::tie(out_edge_it, out_edges_end) = out_edges(v, g);
std::tie(out_edge_it, out_edges_end) = out_edges(v, g);
vertex_descriptor v1 = target(*out_edge_it++, g);
vertex_descriptor v2 = target(*out_edge_it++, g);

31
Periodic_3_mesh_3/include/CGAL/Periodic_3_mesh_3/Protect_edges_sizing_field.h
View File

@ -52,8 +52,7 @@
#ifndef CGAL_NO_ASSERTIONS
# include <boost/math/special_functions/next.hpp> // for float_prior
#endif
#include <optional>
#include <boost/tuple/tuple.hpp>
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
@ -62,10 +61,12 @@
#include <fstream>
#include <iterator>
#include <list>
#include <optional>
#include <sstream>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
@ -393,7 +394,7 @@ private:
const Curve_index& curve_index, const CGAL::Orientation orientation) const
{
Bare_point pa, pb;
boost::tie(pa, pb) = get_positions(va, vb, curve_index, orientation);
std::tie(pa, pb) = get_positions(va, vb, curve_index, orientation);
return compute_distance(pa, pb);
}
@ -511,7 +512,7 @@ private:
const Vertex_handle v2,
const Curve_index& curve_index) const;
boost::tuple<Bare_point, Bare_point, Bare_point> get_positions(const Vertex_handle v1,
std::tuple<Bare_point, Bare_point, Bare_point> get_positions(const Vertex_handle v1,
const Vertex_handle v2,
const Vertex_handle v3,
const Curve_index& curve_index,
@ -953,7 +954,7 @@ get_positions_with_unknown_orientation(const Vertex_handle v1,
template <typename C3T3, typename MD, typename Sf>
boost::tuple<typename Protect_edges_sizing_field<C3T3, MD, Sf>::Bare_point,
std::tuple<typename Protect_edges_sizing_field<C3T3, MD, Sf>::Bare_point,
typename Protect_edges_sizing_field<C3T3, MD, Sf>::Bare_point,
typename Protect_edges_sizing_field<C3T3, MD, Sf>::Bare_point>
Protect_edges_sizing_field<C3T3, MD, Sf>::
@ -965,11 +966,11 @@ get_positions(const Vertex_handle v1,
{
Bare_point p1, p2_check, p2, p3;
boost::tie(p1, p2) = get_positions(v1, v2, curve_index, orientation);
boost::tie(p2_check, p3) = get_positions(v2, v3, curve_index, orientation);
std::tie(p1, p2) = get_positions(v1, v2, curve_index, orientation);
std::tie(p2_check, p3) = get_positions(v2, v3, curve_index, orientation);
CGAL_assertion(p2_check == p2);
return boost::make_tuple(p1, p2, p3);
return std::make_tuple(p1, p2, p3);
}
@ -1674,7 +1675,7 @@ smart_insert_point(const Bare_point& p, Weight w, int dim, const Index& index,
Vertex_handle nearest_vh;
FT sq_d;
boost::tie(nearest_vh, sq_d) = tr.nearest_power_vertex_with_sq_distance(p, ch);
std::tie(nearest_vh, sq_d) = tr.nearest_power_vertex_with_sq_distance(p, ch);
CGAL_assertion(nearest_vh != Vertex_handle());
CGAL_assertion(tr.point(nearest_vh) != cwp(tr.canonicalize_point(p)));
@ -1710,7 +1711,7 @@ smart_insert_point(const Bare_point& p, Weight w, int dim, const Index& index,
// Iterate
ch = tr.locate(wp0, lt, li, lj, nearest_vh);
boost::tie(nearest_vh, sq_d) = tr.nearest_power_vertex_with_sq_distance(p, ch);
std::tie(nearest_vh, sq_d) = tr.nearest_power_vertex_with_sq_distance(p, ch);
CGAL_assertion(nearest_vh != Vertex_handle());
}
@ -2000,7 +2001,7 @@ insert_balls(const Vertex_handle& vp,
{
// Get size of p & q
Bare_point vpp, vqp;
boost::tie(vpp, vqp) = get_positions(vp, vq, curve_index, orientation);
std::tie(vpp, vqp) = get_positions(vp, vq, curve_index, orientation);
const FT sp = get_radius(vp);
const FT sq = get_radius(vq);
@ -2049,7 +2050,7 @@ insert_balls(const Vertex_handle& vp,
CGAL_precondition(sp <= sq);
Bare_point vpp, vqp;
boost::tie(vpp, vqp) = get_positions(vp, vq, curve_index, d_sign);
std::tie(vpp, vqp) = get_positions(vp, vq, curve_index, d_sign);
#if ! defined(CGAL_NO_PRECONDITIONS)
if(sp <= 0)
@ -2749,7 +2750,7 @@ is_sampling_dense_enough(const Vertex_handle& v1, const Vertex_handle& v2,
curve_index == domain_.curve_index(v2->index()));
Bare_point v1p, v2p;
boost::tie(v1p, v2p) = get_positions(v1, v2, curve_index, orientation);
std::tie(v1p, v2p) = get_positions(v1, v2, curve_index, orientation);
FT arc_length = domain_.curve_segment_length(v1p,
v2p,
@ -2816,7 +2817,7 @@ orientation_of_walk(const Vertex_handle& start,
#endif
Bare_point start_p, next_p;
boost::tie(start_p, next_p) = get_positions_with_unknown_orientation(start, next, curve_index);
std::tie(start_p, next_p) = get_positions_with_unknown_orientation(start, next, curve_index);
#if CGAL_MESH_3_PROTECTION_DEBUG & 4
std::cerr << "positions to determine orientation: " << start_p << " " << next_p << std::endl;
#endif
@ -3091,7 +3092,7 @@ is_sizing_field_correct(const Vertex_handle& v1,
FT s3 = get_radius(v3);
Bare_point p1, p2, p3;
boost::tie(p1, p2, p3) = get_positions(v1, v2, v3, curve_index, orientation);
std::tie(p1, p2, p3) = get_positions(v1, v2, v3, curve_index, orientation);
FT D = domain_.curve_segment_length(p1, p3, curve_index, orientation);
FT d = domain_.curve_segment_length(p1, p2, curve_index, orientation);

2
Periodic_3_triangulation_3/include/CGAL/Periodic_3_triangulation_3.h
View File

@ -4414,7 +4414,7 @@ test_next(const Periodic_3_triangulation_3<GT, TDS1>& t1,
queue.push_back(std::make_pair(c1,c2));
while(! queue.empty()) {
boost::tie(c1,c2) = queue.back();
std::tie(c1,c2) = queue.back();
queue.pop_back();
// Precondition: c1, c2 have been registered as well as their 4 vertices.

4
Point_set_3/examples/Point_set_3/point_set_property.cpp
View File

@ -40,11 +40,11 @@ int main (int, char**)
bool success = false;
Color_map color;
boost::tie (color, success) = point_set.add_property_map<Color> ("color", black);
std::tie (color, success) = point_set.add_property_map<Color> ("color", black);
assert (success);
FT_map intensity;
boost::tie (intensity, success) = point_set.add_property_map<FT> ("intensity", 0.);
std::tie (intensity, success) = point_set.add_property_map<FT> ("intensity", 0.);
assert (success);
point_set.reserve (10); // For memory optimization

36
Point_set_3/include/CGAL/Point_set_3/IO/LAS.h
View File

@ -219,86 +219,86 @@ bool write_LAS(std::ostream& os,
Ushort_map intensity;
bool remove_intensity;
boost::tie(intensity, remove_intensity)
std::tie(intensity, remove_intensity)
= point_set.template add_property_map<unsigned short>("intensity", 0);
Uchar_map return_number;
bool remove_return_number;
boost::tie(return_number, remove_return_number)
std::tie(return_number, remove_return_number)
= point_set.template add_property_map<unsigned char>("return_number", 0);
Uchar_map number_of_returns;
bool remove_number_of_returns;
boost::tie(number_of_returns, remove_number_of_returns)
std::tie(number_of_returns, remove_number_of_returns)
= point_set.template add_property_map<unsigned char>("number_of_returns", 0);
Uchar_map scan_direction_flag;
bool remove_scan_direction_flag;
boost::tie(scan_direction_flag, remove_scan_direction_flag)
std::tie(scan_direction_flag, remove_scan_direction_flag)
= point_set.template add_property_map<unsigned char>("scan_direction_flag", 0);
Uchar_map edge_of_flight_line;
bool remove_edge_of_flight_line;
boost::tie(edge_of_flight_line, remove_edge_of_flight_line)
std::tie(edge_of_flight_line, remove_edge_of_flight_line)
= point_set.template add_property_map<unsigned char>("edge_of_flight_line", 0);
Uchar_map classification;
bool remove_classification;
boost::tie(classification, remove_classification)
std::tie(classification, remove_classification)
= point_set.template add_property_map<unsigned char>("classification", 0);
Uchar_map synthetic_flag;
bool remove_synthetic_flag;
boost::tie(synthetic_flag, remove_synthetic_flag)
std::tie(synthetic_flag, remove_synthetic_flag)
= point_set.template add_property_map<unsigned char>("synthetic_flag", 0);
Uchar_map keypoint_flag;
bool remove_keypoint_flag;
boost::tie(keypoint_flag, remove_keypoint_flag)
std::tie(keypoint_flag, remove_keypoint_flag)
= point_set.template add_property_map<unsigned char>("keypoint_flag", 0);
Uchar_map withheld_flag;
bool remove_withheld_flag;
boost::tie(withheld_flag, remove_withheld_flag)
std::tie(withheld_flag, remove_withheld_flag)
= point_set.template add_property_map<unsigned char>("withheld_flag", 0);
Float_map scan_angle;
bool remove_scan_angle;
boost::tie(scan_angle, remove_scan_angle)
std::tie(scan_angle, remove_scan_angle)
= point_set.template add_property_map<float>("scan_angle", 0.);
Uchar_map user_data;
bool remove_user_data;
boost::tie(user_data, remove_user_data)
std::tie(user_data, remove_user_data)
= point_set.template add_property_map<unsigned char>("user_data", 0);
Ushort_map point_source_ID;
bool remove_point_source_ID;
boost::tie(point_source_ID, remove_point_source_ID)
std::tie(point_source_ID, remove_point_source_ID)
= point_set.template add_property_map<unsigned short>("point_source_ID", 0);
Uint_map deleted_flag;
bool remove_deleted_flag;
boost::tie(deleted_flag, remove_deleted_flag)
std::tie(deleted_flag, remove_deleted_flag)
= point_set.template add_property_map<unsigned int>("deleted_flag", 0);
Double_map gps_time;
bool remove_gps_time;
boost::tie(gps_time, remove_gps_time)
std::tie(gps_time, remove_gps_time)
= point_set.template add_property_map<double>("gps_time", 0);
Ushort_map R;
bool remove_R;
boost::tie(R, remove_R) = point_set.template add_property_map<unsigned short>("R", 0);
std::tie(R, remove_R) = point_set.template add_property_map<unsigned short>("R", 0);
Ushort_map G;
bool remove_G;
boost::tie(G, remove_G) = point_set.template add_property_map<unsigned short>("G", 0);
std::tie(G, remove_G) = point_set.template add_property_map<unsigned short>("G", 0);
Ushort_map B;
bool remove_B;
boost::tie(B, remove_B) = point_set.template add_property_map<unsigned short>("B", 0);
std::tie(B, remove_B) = point_set.template add_property_map<unsigned short>("B", 0);
Ushort_map I;
bool remove_I;
boost::tie(I, remove_I) = point_set.template add_property_map<unsigned short>("I", 0);
std::tie(I, remove_I) = point_set.template add_property_map<unsigned short>("I", 0);
if(remove_R)
{

2
Point_set_3/include/CGAL/Point_set_3/IO/PLY.h
View File

@ -57,7 +57,7 @@ private:
PLY_property_to_point_set_property(Point_set& ps, const std::string& name)
: m_name(name)
{
boost::tie(m_map, boost::tuples::ignore) = ps.add_property_map(name, Type());
m_map = ps.add_property_map(name, Type()).first;
m_pmap = ps.push_property_map(m_map);
}

2
Point_set_3/test/Point_set_3/point_set_test.cpp
View File

@ -103,7 +103,7 @@ int main (int, char**)
test (!(point_set.has_property_map<Color> ("color")), "point set shouldn't have colors.");
Point_set::Property_map<Color> color_prop;
bool garbage;
boost::tie (color_prop, garbage) = point_set.add_property_map ("color", Color());
std::tie (color_prop, garbage) = point_set.add_property_map ("color", Color());
test (point_set.has_property_map<Color> ("color"), "point set should have colors.");
for (Point_set::iterator it = point_set.begin(); it != point_set.end(); ++ it)

2
Point_set_3/test/Point_set_3/point_set_test_join.cpp
View File

@ -72,7 +72,7 @@ int main (int, char**)
Point_set::Property_map<int> intensity;
bool okay;
boost::tie (intensity, okay) = ps3.add_property_map<int>("intensity", 0);
std::tie (intensity, okay) = ps3.add_property_map<int>("intensity", 0);
assert (okay);
Point_set::iterator it = ps3.insert (Point (double(0), double(1), double(2)),

4
Point_set_processing_3/include/CGAL/mst_orient_normals.h
View File

@ -388,7 +388,7 @@ create_riemannian_graph(
// Add edge
typename boost::graph_traits<Riemannian_graph>::edge_descriptor e;
bool inserted;
boost::tie(e, inserted) = add_edge(vertex(it_index, riemannian_graph),
std::tie(e, inserted) = add_edge(vertex(it_index, riemannian_graph),
vertex(neighbor_index, riemannian_graph),
riemannian_graph);
CGAL_assertion(inserted);
@ -410,7 +410,7 @@ create_riemannian_graph(
{
typename boost::graph_traits<Riemannian_graph>::edge_descriptor e;
bool inserted;
boost::tie(e, inserted) = add_edge(vertex(it_index, riemannian_graph),
std::tie(e, inserted) = add_edge(vertex(it_index, riemannian_graph),
vertex(source_point_index, riemannian_graph),
riemannian_graph);
CGAL_assertion(inserted);

6
Poisson_surface_reconstruction_3/include/CGAL/Poisson_reconstruction_function.h
View File

@ -598,20 +598,20 @@ public:
}
#endif
boost::tuple<FT, Cell_handle, bool> special_func(const Point& p) const
std::tuple<FT, Cell_handle, bool> special_func(const Point& p) const
{
Cell_handle& hint = get_hint();
hint = m_tr->locate(p, hint);
if(m_tr->is_infinite(hint)) {
int i = hint->index(m_tr->infinite_vertex());
return boost::make_tuple(hint->vertex((i+1)&3)->f(),
return std::make_tuple(hint->vertex((i+1)&3)->f(),
hint, true);
}
FT a,b,c,d;
barycentric_coordinates(p,hint,a,b,c,d);
return boost::make_tuple(a * hint->vertex(0)->f() +
return std::make_tuple(a * hint->vertex(0)->f() +
b * hint->vertex(1)->f() +
c * hint->vertex(2)->f() +
d * hint->vertex(3)->f(),

18
Poisson_surface_reconstruction_3/include/CGAL/Poisson_surface_reconstruction_3/internal/Poisson_sphere_oracle_3.h
View File

@ -24,7 +24,7 @@
#include <CGAL/number_utils.h>
#include <CGAL/Origin.h>
#include <boost/tuple/tuple.hpp>
#include <tuple>
namespace CGAL {
@ -102,7 +102,7 @@ namespace CGAL {
{
const Self& oracle;
boost::tuple<int, FT, FT>
std::tuple<int, FT, FT>
intersection_line_sphere_lambda(const Surface_3& sphere,
const Point& a,
const Point& b) const
@ -154,18 +154,18 @@ namespace CGAL {
switch( CGAL::sign(deltaprime) )
{
case ZERO:
return boost::make_tuple(1, ab_ac / ab2, 0);
return std::make_tuple(1, ab_ac / ab2, 0);
case POSITIVE:
{
const FT sqrt_deltaprime = CGAL::sqrt(deltaprime);
return boost::make_tuple(2,
return std::make_tuple(2,
(ab_ac - sqrt_deltaprime) / ab2,
(ab_ac + sqrt_deltaprime) / ab2);
}
case NEGATIVE:
break;
}
return boost::make_tuple(0, 0, 0);
return std::make_tuple(0, 0, 0);
} //end intersection_line_sphere_lambda
template <class Assert_on_lambda>
@ -185,7 +185,7 @@ namespace CGAL {
int number_of_roots;
FT root_1, root_2;
boost::tie(number_of_roots, root_1, root_2) =
std::tie(number_of_roots, root_1, root_2) =
intersection_line_sphere_lambda(sphere, a, b);
const Vector ab = vector(a, b);
@ -291,7 +291,7 @@ namespace CGAL {
int number_of_roots;
FT root_1, root_2;
boost::tie(number_of_roots, root_1, root_2) =
std::tie(number_of_roots, root_1, root_2) =
intersection_line_sphere_lambda(sphere, a, b);
#ifdef CGAL_SURFACE_MESHER_DEBUG_IMPLICIT_ORACLE
@ -353,7 +353,7 @@ namespace CGAL {
int number_of_roots;
FT root_1, root_2;
boost::tie(number_of_roots, root_1, root_2) =
std::tie(number_of_roots, root_1, root_2) =
intersection_line_sphere_lambda(sphere, a, b);
if( number_of_roots == 2 && root_2 > FT(0) )
@ -392,7 +392,7 @@ namespace CGAL {
int number_of_roots;
FT root_1, root_2;
boost::tie(number_of_roots, root_1, root_2) =
std::tie(number_of_roots, root_1, root_2) =
intersection_line_sphere_lambda(sphere, a, b);
if( number_of_roots == 2 )

6
Poisson_surface_reconstruction_3/include/CGAL/Surface_mesher/Poisson_implicit_surface_oracle_3.h
View File

@ -286,8 +286,8 @@ namespace CGAL {
Cell_handle c1, c2;
bool c1_is_inf, c2_is_inf;
boost::tie(value_at_p1, c1, c1_is_inf) = surface.function().special_func(p1);
boost::tie(value_at_p2, c2, c2_is_inf) = surface.function().special_func(p2);
std::tie(value_at_p1, c1, c1_is_inf) = surface.function().special_func(p1);
std::tie(value_at_p2, c2, c2_is_inf) = surface.function().special_func(p2);
// If both extremities are in the same volume component, returns
// no intersection.
@ -320,7 +320,7 @@ namespace CGAL {
Cell_handle c_at_mid;
FT value_at_mid;
bool c_is_inf;
boost::tie(value_at_mid, c_at_mid, c_is_inf) = surface.function().special_func(mid);
std::tie(value_at_mid, c_at_mid, c_is_inf) = surface.function().special_func(mid);
if ( squared_distance(p1, p2) < squared_distance_bound )
// If the two points are close, then we must decide

6
Polygon_mesh_processing/examples/Polygon_mesh_processing/interpolated_corrected_curvatures_SM.cpp
View File

@ -32,11 +32,11 @@ int main(int argc, char* argv[])
Mesh::Property_map<vertex_descriptor, Epic_kernel::FT>
mean_curvature_map, Gaussian_curvature_map;
boost::tie(mean_curvature_map, created) =
std::tie(mean_curvature_map, created) =
smesh.add_property_map<vertex_descriptor, Epic_kernel::FT>("v:mean_curvature_map", 0);
assert(created);
boost::tie(Gaussian_curvature_map, created) =
std::tie(Gaussian_curvature_map, created) =
smesh.add_property_map<vertex_descriptor, Epic_kernel::FT>("v:Gaussian_curvature_map", 0);
assert(created);
@ -44,7 +44,7 @@ int main(int argc, char* argv[])
Mesh::Property_map<vertex_descriptor, PMP::Principal_curvatures_and_directions<Epic_kernel>>
principal_curvatures_and_directions_map;
boost::tie(principal_curvatures_and_directions_map, created) =
std::tie(principal_curvatures_and_directions_map, created) =
smesh.add_property_map<vertex_descriptor, PMP::Principal_curvatures_and_directions<Epic_kernel>>
("v:principal_curvatures_and_directions_map", { 0, 0,
Epic_kernel::Vector_3(0,0,0),

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/Face_graph_output_builder.h
View File

@ -2515,7 +2515,7 @@ public:
typedef std::pair<halfedge_descriptor, halfedge_descriptor> Hedge_pair;
std::vector< Hedge_pair> hedges_to_link;
typename CGAL::Halfedge_around_target_iterator<TriangleMesh> hit, end;
boost::tie(hit,end) = halfedges_around_target(vd, tm1);
std::tie(hit,end) = halfedges_around_target(vd, tm1);
for(; hit!=end; ++hit)
{
// look for a border halfedge incident to the non-manifold vertex that will not be

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/helper.h
View File

@ -67,7 +67,7 @@ void assign_tolerance_with_local_edge_length_bound(const HalfedgeRange& halfedge
{
const vertex_descriptor vd = target(hd, mesh);
CGAL::Halfedge_around_target_iterator<PolygonMesh> hit, hend;
boost::tie(hit, hend) = CGAL::halfedges_around_target(vd, mesh);
std::tie(hit, hend) = CGAL::halfedges_around_target(vd, mesh);
CGAL_assertion(hit != hend);
FT sq_length = gt.compute_squared_distance_3_object()(get(vpm, source(*hit, mesh)),

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/locate.h
View File

@ -1450,7 +1450,7 @@ void build_AABB_tree(const TriangleMesh& tm,
>::value>* = 0)
{
typename boost::graph_traits<TriangleMesh>::face_iterator ffirst, fbeyond;
boost::tie(ffirst, fbeyond) = faces(tm);
std::tie(ffirst, fbeyond) = faces(tm);
outTree.rebuild(ffirst, fbeyond, tm, wrapped_vpm);
outTree.build();
}

2
Polygon_mesh_processing/test/Polygon_mesh_processing/test_pmp_locate.cpp
View File

@ -378,7 +378,7 @@ void test_predicates(const G& g, CGAL::Random& rnd)
// ---------------------------------------------------------------------------
int max = 1000, counter = 0;
typename boost::graph_traits<G>::halfedge_iterator hit, hend;
boost::tie(hit, hend) = halfedges(g);
std::tie(hit, hend) = halfedges(g);
for(; hit!=hend; ++hit)
{
const halfedge_descriptor h = *hit;

2
Polygon_mesh_processing/test/Polygon_mesh_processing/test_shape_predicates.cpp
View File

@ -78,7 +78,7 @@ void test_needles_and_caps(const std::string fname)
const FT eps = std::numeric_limits<FT>::epsilon();
face_iterator fit, fend;
boost::tie(fit, fend) = faces(mesh);
std::tie(fit, fend) = faces(mesh);
// (0 0 0) -- (1 0 0) -- (1 1 0) (90° cap angle)
face_descriptor f = *fit;

2
Ridges_3/examples/Ridges_3/PolyhedralSurf_rings.h
View File

@ -64,7 +64,7 @@ T_PolyhedralSurf_rings(const TPoly& P)
{
//init the ring_index_map
Vertex_const_iterator itb, ite;
boost::tie(itb,ite) = vertices(P);
std::tie(itb,ite) = vertices(P);
for(;itb!=ite;itb++) ring_index_map[*itb] = -1;
}

2
Ridges_3/include/CGAL/PolyhedralSurf_neighbors.h
View File

@ -158,7 +158,7 @@ T_PolyhedralSurf_neighbors(const TriangleMesh& P)
{
//init the is_visited_map
Vertex_const_iterator itb, ite;
boost::tie(itb,ite) = vertices(P);
std::tie(itb,ite) = vertices(P);
for(;itb!=ite;itb++) is_visited_map[*itb] = false;
}

6
Ridges_3/include/CGAL/Ridges.h
View File

@ -336,7 +336,7 @@ Ridge_approximation(const TriangleMesh &p,
{
//init the is_visited_map and check that the mesh is a triangular one.
face_iterator itb,ite;
boost::tie(itb,ite) = faces(P);
std::tie(itb,ite) = faces(P);
for(;itb!=ite;itb++) {
is_visited_map[*itb] = false;
}
@ -411,10 +411,10 @@ compute_ridges(Ridge_interrogation_type r_type, OutputIterator ridge_lines_it, R
//reinit the is_visited_map
face_iterator itb,ite;
boost::tie(itb,ite) = faces(P);
std::tie(itb,ite) = faces(P);
for(;itb!=ite;itb++) is_visited_map[*itb] = false;
boost::tie(itb,ite) = faces(P);
std::tie(itb,ite) = faces(P);
for(;itb!=ite;itb++)
{
face_descriptor f = *itb;

2
Ridges_3/include/CGAL/Umbilics.h
View File

@ -184,7 +184,7 @@ compute(OutputIterator umbilics_it, FT size)
//MAIN loop on P vertices
Vertex_const_iterator itb, ite;
boost::tie(itb,ite) = vertices(P);
std::tie(itb,ite) = vertices(P);
for (;itb != ite; itb++) {
vertex_descriptor vh = *itb;
umbilicEstimatorVertex = cgal_abs(get(k1,vh)-get(k2,vh));

2
Ridges_3/test/Ridges_3/PolyhedralSurf_rings.h
View File

@ -64,7 +64,7 @@ T_PolyhedralSurf_rings(const TPoly& P)
{
//init the ring_index_map
Vertex_const_iterator itb, ite;
boost::tie(itb,ite) = vertices(P);
std::tie(itb,ite) = vertices(P);
for(;itb!=ite;itb++) ring_index_map[*itb] = -1;
}

2
STL_Extension/doc/STL_Extension/CGAL/Iterator_range.h
View File

@ -21,7 +21,7 @@ namespace CGAL {
\ingroup PkgSTLExtensionRef
`CGAL::Iterator_range` encapsulates two iterators so they fulfill the `ForwardRange` concept.
The class is essentially a clone of <A href="https://www.boost.org/doc/libs/1_55_0/libs/range/doc/html/range/reference/utilities/iterator_range.html">`boost::iterator_range`</A>,
and it additionally is derived from `std::pair`, so that one can apply `boost::tie`.
and it additionally is derived from `std::pair`, so that one can apply `std::tie`.
*/
template <typename I>
class Iterator_range

2
Scale_space_reconstruction_3/examples/Scale_space_reconstruction_3/scale_space_sm.cpp
View File

@ -58,7 +58,7 @@ int main(int argc, char* argv[]) {
// Also store the input points as vertex property
Surface_mesh::Property_map<vertex_descriptor, Point> original;
bool created;
boost::tie(original, created) = mesh.add_property_map<vertex_descriptor,Point>("v:original");
std::tie(original, created) = mesh.add_property_map<vertex_descriptor,Point>("v:original");
assert(created);
int i = 0;

2
Surface_mesh/examples/Surface_mesh/sm_circulators.cpp
View File

@ -42,7 +42,7 @@ int main()
{
std::cout << "vertices around face " << f << std::endl;
CGAL::Vertex_around_face_iterator<Mesh> vbegin, vend;
for(boost::tie(vbegin, vend) = vertices_around_face(m.halfedge(f), m);
for(std::tie(vbegin, vend) = vertices_around_face(m.halfedge(f), m);
vbegin != vend;
++vbegin){
std::cout << *vbegin << std::endl;

4
Surface_mesh/examples/Surface_mesh/sm_iterators.cpp
View File

@ -44,8 +44,8 @@ int main()
vb = std::begin(r);
ve = std::end(r);
// or with boost::tie, as the CGAL range derives from std::pair
for(boost::tie(vb, ve) = m.vertices(); vb != ve; ++vb){
// or with std::tie, as the CGAL range derives from std::pair
for(std::tie(vb, ve) = m.vertices(); vb != ve; ++vb){
// Print vertex index and vertex coordinates
std::cout << *vb << " " << m.point(*vb) << std::endl;
}

4
Surface_mesh/examples/Surface_mesh/sm_join.cpp
View File

@ -25,8 +25,8 @@ int main(int argc, char* argv[])
Mesh::Property_map<vertex_descriptor,std::string> name1, name2;
bool created;
sm1.add_property_map<vertex_descriptor,int>("v:weight",7812);
boost::tie(name1, created) = sm1.add_property_map<vertex_descriptor,std::string>("v:name","hello");
boost::tie(name2, created) = sm2.add_property_map<vertex_descriptor,std::string>("v:name","world");
std::tie(name1, created) = sm1.add_property_map<vertex_descriptor,std::string>("v:name","hello");
std::tie(name2, created) = sm2.add_property_map<vertex_descriptor,std::string>("v:name","world");
sm1 += sm2;

2
Surface_mesh/examples/Surface_mesh/sm_kruskal.cpp
View File

@ -34,7 +34,7 @@ void kruskal(const Mesh& sm)
" point [ \n";
vertex_iterator vb,ve;
for(boost::tie(vb, ve) = vertices(sm); vb!=ve; ++vb){
for(std::tie(vb, ve) = vertices(sm); vb!=ve; ++vb){
std::cout << " " << sm.point(*vb) << "\n";
}

4
Surface_mesh/examples/Surface_mesh/sm_properties.cpp
View File

@ -26,7 +26,7 @@ int main()
// give each vertex a name, the default is empty
Mesh::Property_map<vertex_descriptor,std::string> name;
bool created;
boost::tie(name, created) = m.add_property_map<vertex_descriptor,std::string>("v:name","m1");
std::tie(name, created) = m.add_property_map<vertex_descriptor,std::string>("v:name","m1");
assert(created);
// add some names to the vertices
name[v0] = "hello";
@ -36,7 +36,7 @@ int main()
// You get an existing property, and created will be false
Mesh::Property_map<vertex_descriptor,std::string> name;
bool created;
boost::tie(name, created) = m.add_property_map<vertex_descriptor,std::string>("v:name", "");
std::tie(name, created) = m.add_property_map<vertex_descriptor,std::string>("v:name", "");
assert(! created);
}

2
Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h
View File

@ -598,7 +598,7 @@ public:
/// \name Range Types
///
/// Each range `R` in this section has a nested type `R::iterator`,
/// is convertible to `std::pair<R::iterator,R::iterator>`, so that one can use `boost::tie()`,
/// is convertible to `std::pair<R::iterator,R::iterator>`, so that one can use `std::tie()`,
/// and can be used with `BOOST_FOREACH()`, as well as with the C++11 range based for-loop.
///@{

2
Surface_mesh/test/Surface_mesh/sm_circulator_test.cpp
View File

@ -75,7 +75,7 @@ struct test_emptiness : public Surface_fixture
m.remove_vertex(iv);
assert(m.is_removed(iv));
Sm::Vertex_iterator vb, ve;
for(boost::tie(vb, ve) = m.vertices(); vb != ve; ++vb) {
for(std::tie(vb, ve) = m.vertices(); vb != ve; ++vb) {
Sm::Vertex_around_target_range vr = m.vertices_around_target(m.halfedge(*vb));
assert(!is_empty_range(std::begin(vr), std::end(vr)));
}

Some files were not shown because too many files have changed in this diff Show More