From e5fe6a50bb5679cd65cfa97f9077fcc2e6cafd92 Mon Sep 17 00:00:00 2001 From: Guillaume Damiand Date: Mon, 20 Apr 2020 14:06:33 +0200 Subject: [PATCH] Rename computeXXX methods --- .../CGAL/Curves_on_surface_topology.h | 8 ++--- .../Surface_mesh_topology.txt | 12 +++---- .../Surface_mesh_topology/edgewidth_lcc.cpp | 4 +-- .../edgewidth_surface_mesh.cpp | 4 +-- .../Surface_mesh_topology/facewidth.cpp | 2 +- .../shortest_noncontractible_cycle.cpp | 4 +-- .../shortest_noncontractible_cycle_2.cpp | 4 +-- .../unsew_edgewidth_repeatedly.cpp | 2 +- .../include/CGAL/Curves_on_surface_topology.h | 36 +++++++++---------- .../internal/Facewidth.h | 6 ++-- .../internal/Shortest_noncontractible_cycle.h | 12 +++---- .../shortest_noncontractible_cycle_tests.cpp | 16 ++++----- .../test_shortest_cycle_non_contractible.cpp | 8 ++--- 13 files changed, 59 insertions(+), 59 deletions(-) diff --git a/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Curves_on_surface_topology.h b/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Curves_on_surface_topology.h index 5894e2e2818..0fc859fd0f2 100644 --- a/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Curves_on_surface_topology.h +++ b/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Curves_on_surface_topology.h @@ -41,21 +41,21 @@ namespace Surface_mesh_topology { /*! returns a non-contractible cycle of type `Path_on_surface` with minimal number of edges. This edge number is the edgewidth of the mesh. */ - Path_on_surface compute_edgewidth() const; + Path_on_surface compute_edge_width() const; /*! returns a non-contractible cycle of type `Path_on_surface` with minimal length, where the length of a cycle is the sum of the weights of its edges computed thanks to the WeightFunctor `wf`. By default, all the edge weights are set to 1 (thanks to the `Unit_weight_functor` functor). */ template - Path_on_surface compute_shortest_noncontractible_cycle(const WeightFunctor& wf=WeightFunctor()) const; + Path_on_surface compute_shortest_non_contractible_cycle(const WeightFunctor& wf=WeightFunctor()) const; /*! returns a non-contractible cycle of type `Path_on_surface` with minimal length going through the source vertex of `dh`, where the length of a cycle is the sum of the weights of its edges computed thanks to the WeightFunctor `wf`. By default, all the edge weights are set to 1 (thanks to the `Unit_weight_functor` functor). */ template - Path_on_surface compute_shortest_noncontractible_cycle_with_basepoint(halfedge_descriptor dh, const WeightFunctor& wf=WeightFunctor()) const; + Path_on_surface compute_shortest_non_contractible_cycle_with_basepoint(halfedge_descriptor dh, const WeightFunctor& wf=WeightFunctor()) const; /*! returns a vector of darts representing a non-contractible curve with a minimal number of intersection with the graph of the mesh. This curve can be decribed by the alternating sequence of faces and vertices it goes through, so that each dart in the returned vector belongs to both a face and the next vertex in the alternating sequence. (Here, faces and vertices are viewed as subsets of darts.) The size of the returned vector is the 'facewidth' of the mesh. */ - std::vector compute_facewidth() const; + std::vector compute_face_width() const; }; /*! diff --git a/Surface_mesh_topology/doc/Surface_mesh_topology/Surface_mesh_topology.txt b/Surface_mesh_topology/doc/Surface_mesh_topology/Surface_mesh_topology.txt index 81d45bd2bb6..c0343899032 100644 --- a/Surface_mesh_topology/doc/Surface_mesh_topology/Surface_mesh_topology.txt +++ b/Surface_mesh_topology/doc/Surface_mesh_topology/Surface_mesh_topology.txt @@ -91,9 +91,9 @@ Since the data structures to represent a surface are edge-centralized, in order The class \link Surface_mesh_topology::Curves_on_surface_topology `Curves_on_surface_topology` \endlink provides the following three functions: -- \link Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_noncontractible_cycle_with_basepoint `compute_shortest_noncontractible_cycle_with_basepoint(dh, weight_functor)` \endlink: Compute a shortest non-contractible cycle going through the source vertex of `dh`, -- \link Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_noncontractible_cycle `compute_shortest_noncontractible_cycle(weight_functor)` \endlink: Very similar to the previous function, except that one does not specify a vertex. It computes a shortest non-contractible cycle through every vertex and returns the shortest cycle among them, -- \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_edgewidth `compute_edgewidth()` \endlink: Compute the edge-width of the mesh, equivalent to \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_noncontractible_cycle `compute_shortest_noncontractible_cycle(`\endlink \link CGAL::Surface_mesh_topology::Unit_weight_functor `Unit_weight_functor())`\endlink. +- \link Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_non_contractible_cycle_with_basepoint `compute_shortest_non_contractible_cycle_with_basepoint(dh, weight_functor)` \endlink: Compute a shortest non-contractible cycle going through the source vertex of `dh`, +- \link Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_non_contractible_cycle `compute_shortest_non_contractible_cycle(weight_functor)` \endlink: Very similar to the previous function, except that one does not specify a vertex. It computes a shortest non-contractible cycle through every vertex and returns the shortest cycle among them, +- \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_edge_width `compute_edge_width()` \endlink: Compute the edge-width of the mesh, equivalent to \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_non_contractible_cycle `compute_shortest_non_contractible_cycle(`\endlink \link CGAL::Surface_mesh_topology::Unit_weight_functor `Unit_weight_functor())`\endlink. The above functions return an instance of \link Surface_mesh_topology::Path_on_surface `Path_on_surface` \endlink. The optional argument `weight_functor` is used to calculate the length of the edges. If not given, all the edge lengths are set to 1, i.e. the mesh is unweighted. @@ -102,7 +102,7 @@ The above functions return an instance of \link Surface_mesh_topology::Path_on_s Facewidth returns a shortest non-contractible topological curve described as a circular sequence of traversed faces alternating with the vertices it passes through. Each face or vertex in this sequence is identified by one of its dart handles. In practice, we choose the same dart handle for a face as for the next vertex it passes through. This way, we only need to return one dart handle for a face and its following vertex in the sequence. -The function \link Surface_mesh_topology::Curves_on_surface_topology::compute_facewidth `compute_facewidth()` \endlink computes the sequence of dart handles as described above and returns an `std::vector` of dart handles, where each dart represents a traversed face followed by an incident vertex. +The function \link Surface_mesh_topology::Curves_on_surface_topology::compute_face_width `compute_face_width()` \endlink computes the sequence of dart handles as described above and returns an `std::vector` of dart handles, where each dart represents a traversed face followed by an incident vertex. \subsection SMTopology_Queries Testing Homotopy @@ -126,11 +126,11 @@ Each time a `Surface_mesh_topology::Path_on_surface` is provided for a homotopy In the next two examples, we present various ways to compute shortest non-contractible cycles. -One can store the original mesh in a `Combinatorial_map` instance and run the algorithm without regarding the geometric distances, i.e. the unweighted case (first call to \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_noncontractible_cycle_with_basepoint `compute_shortest_noncontractible_cycle_with_basepoint`\endlink). Alternatively, one can take the geometric distances into consideration by providing a weight functor to calculate the weight of the edge containing the given dart (second call to \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_noncontractible_cycle_with_basepoint `compute_shortest_noncontractible_cycle_with_basepoint`\endlink). Note that the time complexity is raised by a logarithmic factor. +One can store the original mesh in a `Combinatorial_map` instance and run the algorithm without regarding the geometric distances, i.e. the unweighted case (first call to \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_non_contractible_cycle_with_basepoint `compute_shortest_non_contractible_cycle_with_basepoint`\endlink). Alternatively, one can take the geometric distances into consideration by providing a weight functor to calculate the weight of the edge containing the given dart (second call to \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_non_contractible_cycle_with_basepoint `compute_shortest_non_contractible_cycle_with_basepoint`\endlink). Note that the time complexity is raised by a logarithmic factor. \cgalExample{Surface_mesh_topology/shortest_noncontractible_cycle.cpp} -In order to find the edge-width of the surface, one can make use of the routine \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_edgewidth `compute_edgewidth`\endlink as in the following example. The weighted shortest non contractible cycle is also computed (calling \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_noncontractible_cycle `compute_shortest_noncontractible_cycle`\endlink). In this example, a `Surface_mesh` is used to store the mesh. +In order to find the edge-width of the surface, one can make use of the routine \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_edge_width `compute_edge_width`\endlink as in the following example. The weighted shortest non contractible cycle is also computed (calling \link CGAL::Surface_mesh_topology::Curves_on_surface_topology::compute_shortest_non_contractible_cycle `compute_shortest_non_contractible_cycle`\endlink). In this example, a `Surface_mesh` is used to store the mesh. \cgalExample{Surface_mesh_topology/edgewidth_surface_mesh.cpp} diff --git a/Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_lcc.cpp b/Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_lcc.cpp index b38e4c5e812..3c8d6f59b17 100644 --- a/Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_lcc.cpp +++ b/Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_lcc.cpp @@ -40,10 +40,10 @@ int main(int argc, char* argv[]) CGAL::Surface_mesh_topology::Curves_on_surface_topology cst(lcc, true); - Path_on_surface cycle1=cst.compute_edgewidth(true); + Path_on_surface cycle1=cst.compute_edge_width(true); CGAL::Surface_mesh_topology::Euclidean_length_weight_functor wf(lcc); - Path_on_surface cycle2=cst.compute_shortest_noncontractible_cycle(wf, true); + Path_on_surface cycle2=cst.compute_shortest_non_contractible_cycle(wf, true); std::cout<<"Cycle 1 (pink): "; display_cycle_info(lcc, cycle1); std::cout<<"Cycle 2 (green): "; display_cycle_info(lcc, cycle2); diff --git a/Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_surface_mesh.cpp b/Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_surface_mesh.cpp index 00ee08c7cd6..0bc0e4a7924 100644 --- a/Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_surface_mesh.cpp +++ b/Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_surface_mesh.cpp @@ -43,10 +43,10 @@ int main(int argc, char* argv[]) CGAL::Surface_mesh_topology::Curves_on_surface_topology cst(sm, true); - Path_on_surface cycle1=cst.compute_edgewidth(true); + Path_on_surface cycle1=cst.compute_edge_width(true); CGAL::Surface_mesh_topology::Euclidean_length_weight_functor wf(sm); - Path_on_surface cycle2=cst.compute_shortest_noncontractible_cycle(wf, true); + Path_on_surface cycle2=cst.compute_shortest_non_contractible_cycle(wf, true); std::cout<<"Cycle 1 (pink): "; display_cycle_info(sm, cycle1); std::cout<<"Cycle 2 (green): "; display_cycle_info(sm, cycle2); diff --git a/Surface_mesh_topology/examples/Surface_mesh_topology/facewidth.cpp b/Surface_mesh_topology/examples/Surface_mesh_topology/facewidth.cpp index 4a595ff67c3..e7466fe848d 100644 --- a/Surface_mesh_topology/examples/Surface_mesh_topology/facewidth.cpp +++ b/Surface_mesh_topology/examples/Surface_mesh_topology/facewidth.cpp @@ -27,7 +27,7 @@ int main(int argc, char* argv[]) std::cout<<"File '"< cycle=cst.compute_facewidth(true); + std::vector cycle=cst.compute_face_width(true); if (cycle.size()==0) { std::cout<<" Cannot find such cycle."< wf(lcc); Path_on_surface cycle2= - cst.compute_shortest_noncontractible_cycle_with_basepoint(root, wf); + cst.compute_shortest_non_contractible_cycle_with_basepoint(root, wf); std::cout<<"Cycle 1 (pink): "; display_cycle_info(lcc, cycle1); std::cout<<"Cycle 2 (green): "; display_cycle_info(lcc, cycle2); diff --git a/Surface_mesh_topology/examples/Surface_mesh_topology/shortest_noncontractible_cycle_2.cpp b/Surface_mesh_topology/examples/Surface_mesh_topology/shortest_noncontractible_cycle_2.cpp index 28033427c97..9de47b9d357 100644 --- a/Surface_mesh_topology/examples/Surface_mesh_topology/shortest_noncontractible_cycle_2.cpp +++ b/Surface_mesh_topology/examples/Surface_mesh_topology/shortest_noncontractible_cycle_2.cpp @@ -101,9 +101,9 @@ int main(int argc, char* argv[]) std::cout<<"Finding the shortest noncontractible cycle..."< - Path_on_surface compute_shortest_noncontractible_cycle_with_basepoint + Path_on_surface compute_shortest_non_contractible_cycle_with_basepoint (Dart_const_handle dh, const WeightFunctor& wf, bool display_time=false) const { - compute_shortest_noncontractible_cycle_representation(display_time); + compute_shortest_non_contractible_cycle_representation(display_time); return m_shortest_noncontractible_cycle->compute_cycle(dh, NULL, wf, display_time); } - Path_on_surface compute_shortest_noncontractible_cycle_with_basepoint + Path_on_surface compute_shortest_non_contractible_cycle_with_basepoint (Dart_const_handle dh, bool display_time=false) const { - compute_shortest_noncontractible_cycle_representation(display_time); + compute_shortest_non_contractible_cycle_representation(display_time); return m_shortest_noncontractible_cycle->compute_cycle(dh, display_time); } - Path_on_surface compute_shortest_noncontractible_cycle + Path_on_surface compute_shortest_non_contractible_cycle (bool display_time=false) const { - compute_shortest_noncontractible_cycle_representation(display_time); + compute_shortest_non_contractible_cycle_representation(display_time); return m_shortest_noncontractible_cycle-> - compute_shortest_noncontractible_cycle(nullptr, display_time); + compute_shortest_non_contractible_cycle(nullptr, display_time); } template - Path_on_surface compute_shortest_noncontractible_cycle + Path_on_surface compute_shortest_non_contractible_cycle (const WeightFunctor& wf, bool display_time=false) const { - compute_shortest_noncontractible_cycle_representation(display_time); + compute_shortest_non_contractible_cycle_representation(display_time); return m_shortest_noncontractible_cycle-> - compute_shortest_noncontractible_cycle(nullptr, wf, display_time); + compute_shortest_non_contractible_cycle(nullptr, wf, display_time); } - Path_on_surface compute_edgewidth(bool display_time=false) const + Path_on_surface compute_edge_width(bool display_time=false) const { - compute_shortest_noncontractible_cycle_representation(display_time); - return m_shortest_noncontractible_cycle->compute_edgewidth(display_time); + compute_shortest_non_contractible_cycle_representation(display_time); + return m_shortest_noncontractible_cycle->compute_edge_width(display_time); } bool is_facewidth_representation_computed() const { return m_facewidth!=nullptr; } - void compute_facewidth_representation(bool display_time=false) const + void compute_face_width_representation(bool display_time=false) const { if (m_facewidth==nullptr) { m_facewidth=std::make_unique(m_original_mesh, display_time); } } - std::vector compute_facewidth(bool display_time=false) const + std::vector compute_face_width(bool display_time=false) const { - compute_facewidth_representation(display_time); - return m_facewidth->compute_facewidth(display_time); + compute_face_width_representation(display_time); + return m_facewidth->compute_face_width(display_time); } protected: diff --git a/Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Facewidth.h b/Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Facewidth.h index 9fac4ccec72..2b0bf343888 100644 --- a/Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Facewidth.h +++ b/Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Facewidth.h @@ -112,7 +112,7 @@ public: } } - std::vector compute_facewidth(bool display_time=false) + std::vector compute_face_width(bool display_time=false) { CGAL::Timer t; if (display_time) @@ -120,7 +120,7 @@ public: // Find edgewidth of the radial map Path_on_surface edgewidth_of_radial_map= - m_snc_to_find_facewidth->compute_edgewidth(); + m_snc_to_find_facewidth->compute_edge_width(); std::vector cycle; cycle.reserve(edgewidth_of_radial_map.length()); @@ -135,7 +135,7 @@ public: if (display_time) { t.stop(); - std::cout<<"[TIME] compute_facewidth: "< - Path compute_shortest_noncontractible_cycle(typename WeightFunctor::Weight_t* length, + Path compute_shortest_non_contractible_cycle(typename WeightFunctor::Weight_t* length, const WeightFunctor& wf, bool display_time=false) { @@ -192,19 +192,19 @@ public: if (display_time) { t.stop(); - std::cout<<"[TIME] compute_shortest_noncontractible_cycle: "< - Path compute_shortest_noncontractible_cycle(typename WeightFunctor::Weight_t* length, + Path compute_shortest_non_contractible_cycle(typename WeightFunctor::Weight_t* length, bool display_time=false) - { return compute_shortest_noncontractible_cycle(length, WeightFunctor(), display_time); } + { return compute_shortest_non_contractible_cycle(length, WeightFunctor(), display_time); } - Path compute_edgewidth(bool display_time=false) - { return compute_shortest_noncontractible_cycle(nullptr, display_time); } + Path compute_edge_width(bool display_time=false) + { return compute_shortest_non_contractible_cycle(nullptr, display_time); } protected: int vertex_info(Dart_handle dh) const diff --git a/Surface_mesh_topology/test/Surface_mesh_topology/shortest_noncontractible_cycle_tests.cpp b/Surface_mesh_topology/test/Surface_mesh_topology/shortest_noncontractible_cycle_tests.cpp index 7233902ff26..9f871ca4109 100644 --- a/Surface_mesh_topology/test/Surface_mesh_topology/shortest_noncontractible_cycle_tests.cpp +++ b/Surface_mesh_topology/test/Surface_mesh_topology/shortest_noncontractible_cycle_tests.cpp @@ -95,7 +95,7 @@ bool find_cycle_in_unweighted_cmap_and_polyhedron() { CGAL::Surface_mesh_topology::Curves_on_surface_topology cst1(lcc); LCC_for_CMap_2::Dart_handle root1 = lcc.darts().begin(); Point R = lcc.point_of_vertex_attribute(lcc.vertex_attribute(root1)); - CGAL::Surface_mesh_topology::Path_on_surface cycle1 = cst1.compute_shortest_noncontractible_cycle_with_basepoint(root1); + CGAL::Surface_mesh_topology::Path_on_surface cycle1 = cst1.compute_shortest_non_contractible_cycle_with_basepoint(root1); for (int i = 0; i < cycle1.length(); ++i) { auto e = cycle1[i]; if (e == NULL) { @@ -117,7 +117,7 @@ bool find_cycle_in_unweighted_cmap_and_polyhedron() { std::cerr << "Fail find_cycle_in_unweighted_cmap_and_polyhedron: Cannot find CMap's root in the Polyhedron\n"; return false; } - CGAL::Surface_mesh_topology::Path_on_surface cycle2 = cst2.compute_shortest_noncontractible_cycle_with_basepoint(*root2); + CGAL::Surface_mesh_topology::Path_on_surface cycle2 = cst2.compute_shortest_non_contractible_cycle_with_basepoint(*root2); for (int i = 0; i < cycle2.length(); ++i) { auto e = cycle2[i]; if (e == NULL) { @@ -139,7 +139,7 @@ bool edge_width_in_unweighted_polyhedron() { return false; } CGAL::Surface_mesh_topology::Curves_on_surface_topology cst(p); - CGAL::Surface_mesh_topology::Path_on_surface cycle = cst.compute_edgewidth(); + CGAL::Surface_mesh_topology::Path_on_surface cycle = cst.compute_edge_width(); for (int i = 0; i < cycle.length(); ++i) { auto e = cycle[i]; if (e == NULL) { @@ -180,7 +180,7 @@ bool find_cycle_in_nonorientable_gmap() { // Make a non-oriented case here Weight_functor_for_GM wf (gm, smallest_edge); CGAL::Surface_mesh_topology::Curves_on_surface_topology cst(gm); - CGAL::Surface_mesh_topology::Path_on_surface cycle = cst.compute_shortest_noncontractible_cycle_with_basepoint(faces[0]); + CGAL::Surface_mesh_topology::Path_on_surface cycle = cst.compute_shortest_non_contractible_cycle_with_basepoint(faces[0]); gm.mark_cell<1>(gm.alpha<1>(faces[1]), chosen_cycle); // 1-6 gm.mark_cell<1>(gm.alpha<1,0,1>(faces[1]), chosen_cycle); // 6-9 @@ -221,9 +221,9 @@ bool edge_width_in_weighted_cmap_gmap_mesh() { CGAL::Surface_mesh_topology::Curves_on_surface_topology cst1(lcc_cm); CGAL::Surface_mesh_topology::Curves_on_surface_topology cst2(lcc_gm); CGAL::Surface_mesh_topology::Curves_on_surface_topology cst3(sm); - CGAL::Surface_mesh_topology::Path_on_surface cycle1 = cst1.compute_shortest_noncontractible_cycle(wf_cm); - CGAL::Surface_mesh_topology::Path_on_surface cycle2 = cst2.compute_shortest_noncontractible_cycle(wf_gm); - CGAL::Surface_mesh_topology::Path_on_surface cycle3 = cst3.compute_shortest_noncontractible_cycle(wf_sm); + CGAL::Surface_mesh_topology::Path_on_surface cycle1 = cst1.compute_shortest_non_contractible_cycle(wf_cm); + CGAL::Surface_mesh_topology::Path_on_surface cycle2 = cst2.compute_shortest_non_contractible_cycle(wf_gm); + CGAL::Surface_mesh_topology::Path_on_surface cycle3 = cst3.compute_shortest_non_contractible_cycle(wf_sm); if (cycle1.length()!=cycle2.length() || cycle1.length()!=cycle3.length()) { @@ -359,7 +359,7 @@ bool unsew_edge_width_repeatedly_in_unweighted_gmap() { unsigned int length; do { CGAL::Surface_mesh_topology::Curves_on_surface_topology cst(lcc_gm); - CGAL::Surface_mesh_topology::Path_on_surface cycle = cst.compute_edgewidth(); + CGAL::Surface_mesh_topology::Path_on_surface cycle = cst.compute_edge_width(); length = cycle.length(); LCC_for_GMap_2::size_type belong_to_cycle = lcc_gm.get_new_mark(); for (int i = 0; i < cycle.length(); ++i) { diff --git a/Surface_mesh_topology/test/Surface_mesh_topology/test_shortest_cycle_non_contractible.cpp b/Surface_mesh_topology/test/Surface_mesh_topology/test_shortest_cycle_non_contractible.cpp index 3f7735d416b..065ed7f6e78 100644 --- a/Surface_mesh_topology/test/Surface_mesh_topology/test_shortest_cycle_non_contractible.cpp +++ b/Surface_mesh_topology/test/Surface_mesh_topology/test_shortest_cycle_non_contractible.cpp @@ -116,7 +116,7 @@ bool test_weighted(const LCC_CM& map, Marked_weight_functor wf(map, mark); CGAL::Surface_mesh_topology::Curves_on_surface_topology cst(map); - auto cycle2=cst.compute_shortest_noncontractible_cycle(wf); + auto cycle2=cst.compute_shortest_non_contractible_cycle(wf); if (cycle2.length()!=nbedges) { std::cout<<"[ERROR] in test_weighted for double-torus-2-d.off: the length" @@ -149,7 +149,7 @@ bool test_one_data_structure(const Mesh& mesh, std::size_t nbedges, double lengt CGAL::Surface_mesh_topology::Curves_on_surface_topology cst(mesh); std::cout<<"."< cycle=cst.compute_edgewidth(); + CGAL::Surface_mesh_topology::Path_on_surface cycle=cst.compute_edge_width(); if (cycle.length()!=nbedges) { std::cout<<"[ERROR]: number of edges for the cycle is not correct (" @@ -164,7 +164,7 @@ bool test_one_data_structure(const Mesh& mesh, std::size_t nbedges, double lengt } std::cout<<"."<length) @@ -174,7 +174,7 @@ bool test_one_data_structure(const Mesh& mesh, std::size_t nbedges, double lengt res=false; } - auto facewidth=cst.compute_facewidth(); + auto facewidth=cst.compute_face_width(); if (facewidth.size()!=nbfaces) { std::cout<<"[ERROR] number of faces for the face width is not correct ("