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

Rename computeXXX methods

This commit is contained in:
Guillaume Damiand 2020-04-20 14:06:33 +02:00
parent ec15dbfa9e
commit e5fe6a50bb
13 changed files with 59 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Curves_on_surface_topology.h
View File

@ -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<Mesh> compute_edgewidth() const;
Path_on_surface<Mesh> 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 <class WeightFunctor=Unit_weight_functor>
Path_on_surface<Mesh> compute_shortest_noncontractible_cycle(const WeightFunctor& wf=WeightFunctor()) const;
Path_on_surface<Mesh> 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 <class WeightFunctor=Unit_weight_functor>
Path_on_surface<Mesh> compute_shortest_noncontractible_cycle_with_basepoint(halfedge_descriptor dh, const WeightFunctor& wf=WeightFunctor()) const;
Path_on_surface<Mesh> 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<halfedge_descriptor> compute_facewidth() const;
std::vector<halfedge_descriptor> compute_face_width() const;
};
/*!

12
Surface_mesh_topology/doc/Surface_mesh_topology/Surface_mesh_topology.txt
View File

@ -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}

4
Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_lcc.cpp
View File

@ -40,10 +40,10 @@ int main(int argc, char* argv[])
CGAL::Surface_mesh_topology::Curves_on_surface_topology<LCC_3> 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<LCC_3> 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);

4
Surface_mesh_topology/examples/Surface_mesh_topology/edgewidth_surface_mesh.cpp
View File

@ -43,10 +43,10 @@ int main(int argc, char* argv[])
CGAL::Surface_mesh_topology::Curves_on_surface_topology<Mesh> 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<Mesh> 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);

2
Surface_mesh_topology/examples/Surface_mesh_topology/facewidth.cpp
View File

@ -27,7 +27,7 @@ int main(int argc, char* argv[])
std::cout<<"File '"<<filename<<"' loaded. Finding the facewidth..."<<std::endl;
CST cst(lcc, true);
std::vector<Dart_const_handle> cycle=cst.compute_facewidth(true);
std::vector<Dart_const_handle> cycle=cst.compute_face_width(true);
if (cycle.size()==0)
{ std::cout<<" Cannot find such cycle."<<std::endl; }

4
Surface_mesh_topology/examples/Surface_mesh_topology/shortest_noncontractible_cycle.cpp
View File

@ -45,11 +45,11 @@ int main(int argc, char* argv[])
(CGAL::get_default_random().get_int(0, lcc.number_of_darts())); // One dart of the mesh
Path_on_surface cycle1=
cst.compute_shortest_noncontractible_cycle_with_basepoint(root);
cst.compute_shortest_non_contractible_cycle_with_basepoint(root);
CGAL::Surface_mesh_topology::Euclidean_length_weight_functor<LCC_3> 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);

4
Surface_mesh_topology/examples/Surface_mesh_topology/shortest_noncontractible_cycle_2.cpp
View File

@ -101,9 +101,9 @@ int main(int argc, char* argv[])
std::cout<<"Finding the shortest noncontractible cycle..."<<std::endl;
Path_on_surface cycle(lcc);
if (dist)
{ cycle=cst.compute_shortest_noncontractible_cycle_with_basepoint(root, wf, time); }
{ cycle=cst.compute_shortest_non_contractible_cycle_with_basepoint(root, wf, time); }
else
{ cycle=cst.compute_shortest_noncontractible_cycle_with_basepoint(root, time); }
{ cycle=cst.compute_shortest_non_contractible_cycle_with_basepoint(root, time); }
if (cycle.length()==0)
{ std::cout<<" Cannot find such cycle. Stop."<<std::endl; }

2
Surface_mesh_topology/examples/Surface_mesh_topology/unsew_edgewidth_repeatedly.cpp
View File

@ -106,7 +106,7 @@ int main(int argc, char* argv[])
std::cout<<"Finding #"<<loop++<<" edge-width:"<<std::endl;
{
CST cst(lcccopy);
cycle=cst.compute_shortest_noncontractible_cycle(wf);
cycle=cst.compute_shortest_non_contractible_cycle(wf);
}
if (cycle.length()==0)
{ std::cout << " Cannot find edge-width. Stop.\n"; cycle_exist=false; }

36
Surface_mesh_topology/include/CGAL/Curves_on_surface_topology.h
View File

@ -104,7 +104,7 @@ public:
bool is_shortest_noncontractible_cycle_representation_computed() const
{ return m_shortest_noncontractible_cycle!=nullptr; }
void compute_shortest_noncontractible_cycle_representation(bool display_time=false) const
void compute_shortest_non_contractible_cycle_representation(bool display_time=false) const
{
if (m_shortest_noncontractible_cycle==nullptr)
{
@ -114,56 +114,56 @@ public:
}
template <class WeightFunctor>
Path_on_surface<Mesh> compute_shortest_noncontractible_cycle_with_basepoint
Path_on_surface<Mesh> 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<Mesh> compute_shortest_noncontractible_cycle_with_basepoint
Path_on_surface<Mesh> 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<Mesh> compute_shortest_noncontractible_cycle
Path_on_surface<Mesh> 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 <class WeightFunctor>
Path_on_surface<Mesh> compute_shortest_noncontractible_cycle
Path_on_surface<Mesh> 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<Mesh> compute_edgewidth(bool display_time=false) const
Path_on_surface<Mesh> 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<Facewidth>(m_original_mesh, display_time); }
}
std::vector<Dart_const_handle> compute_facewidth(bool display_time=false) const
std::vector<Dart_const_handle> 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:

6
Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Facewidth.h
View File

@ -112,7 +112,7 @@ public:
}
}
std::vector<Original_dart_const_handle> compute_facewidth(bool display_time=false)
std::vector<Original_dart_const_handle> 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<Local_map> edgewidth_of_radial_map=
m_snc_to_find_facewidth->compute_edgewidth();
m_snc_to_find_facewidth->compute_edge_width();
std::vector<Original_dart_const_handle> cycle;
cycle.reserve(edgewidth_of_radial_map.length());
@ -135,7 +135,7 @@ public:
if (display_time)
{
t.stop();
std::cout<<"[TIME] compute_facewidth: "<<t.time()<<" seconds."<<std::endl;
std::cout<<"[TIME] compute_face_width: "<<t.time()<<" seconds."<<std::endl;
}
return cycle;

12
Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Shortest_noncontractible_cycle.h
View File

@ -157,7 +157,7 @@ public:
{ return compute_cycle(root_vertex, nullptr, display_time); }
template <class WeightFunctor>
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: "<<t.time()<<" seconds."<<std::endl;
std::cout<<"[TIME] compute_shortest_non_contractible_cycle: "<<t.time()<<" seconds."<<std::endl;
}
return m_cycle;
}
template <class WeightFunctor=Unit_weight_functor>
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

16
Surface_mesh_topology/test/Surface_mesh_topology/shortest_noncontractible_cycle_tests.cpp
View File

@ -95,7 +95,7 @@ bool find_cycle_in_unweighted_cmap_and_polyhedron() {
CGAL::Surface_mesh_topology::Curves_on_surface_topology<LCC_for_CMap_2> 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<LCC_for_CMap_2> cycle1 = cst1.compute_shortest_noncontractible_cycle_with_basepoint(root1);
CGAL::Surface_mesh_topology::Path_on_surface<LCC_for_CMap_2> 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<Polyhedron> cycle2 = cst2.compute_shortest_noncontractible_cycle_with_basepoint(*root2);
CGAL::Surface_mesh_topology::Path_on_surface<Polyhedron> 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<Polyhedron> cst(p);
CGAL::Surface_mesh_topology::Path_on_surface<Polyhedron> cycle = cst.compute_edgewidth();
CGAL::Surface_mesh_topology::Path_on_surface<Polyhedron> 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<GMap_2> cst(gm);
CGAL::Surface_mesh_topology::Path_on_surface<GMap_2> cycle = cst.compute_shortest_noncontractible_cycle_with_basepoint(faces[0]);
CGAL::Surface_mesh_topology::Path_on_surface<GMap_2> 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<LCC_for_CMap_2> cst1(lcc_cm);
CGAL::Surface_mesh_topology::Curves_on_surface_topology<LCC_for_GMap_2> cst2(lcc_gm);
CGAL::Surface_mesh_topology::Curves_on_surface_topology<Surface_mesh> cst3(sm);
CGAL::Surface_mesh_topology::Path_on_surface<LCC_for_CMap_2> cycle1 = cst1.compute_shortest_noncontractible_cycle(wf_cm);
CGAL::Surface_mesh_topology::Path_on_surface<LCC_for_GMap_2> cycle2 = cst2.compute_shortest_noncontractible_cycle(wf_gm);
CGAL::Surface_mesh_topology::Path_on_surface<Surface_mesh> cycle3 = cst3.compute_shortest_noncontractible_cycle(wf_sm);
CGAL::Surface_mesh_topology::Path_on_surface<LCC_for_CMap_2> cycle1 = cst1.compute_shortest_non_contractible_cycle(wf_cm);
CGAL::Surface_mesh_topology::Path_on_surface<LCC_for_GMap_2> cycle2 = cst2.compute_shortest_non_contractible_cycle(wf_gm);
CGAL::Surface_mesh_topology::Path_on_surface<Surface_mesh> 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<LCC_for_GMap_2> cst(lcc_gm);
CGAL::Surface_mesh_topology::Path_on_surface<LCC_for_GMap_2> cycle = cst.compute_edgewidth();
CGAL::Surface_mesh_topology::Path_on_surface<LCC_for_GMap_2> 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) {

8
Surface_mesh_topology/test/Surface_mesh_topology/test_shortest_cycle_non_contractible.cpp
View File

@ -116,7 +116,7 @@ bool test_weighted<LCC_CM>(const LCC_CM& map,
Marked_weight_functor<LCC_CM> wf(map, mark);
CGAL::Surface_mesh_topology::Curves_on_surface_topology<LCC_CM> 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<Mesh> cst(mesh);
std::cout<<"."<<std::flush;
CGAL::Surface_mesh_topology::Path_on_surface<Mesh> cycle=cst.compute_edgewidth();
CGAL::Surface_mesh_topology::Path_on_surface<Mesh> 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<<"."<<std::flush;
cycle=cst.compute_shortest_noncontractible_cycle(wf);
cycle=cst.compute_shortest_non_contractible_cycle(wf);
double l=0.;
for (int i=0; i<cycle.length(); ++i) { l+=wf(cycle[i]); }
if (l>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 ("