Update licences; move undocumented files to internal (both directory and namespace)

Combinatorial_map/include/CGAL/Face_graph_wrapper.h

@@ -795,7 +795,8 @@ protected:
   };
 
   template <typename Items, typename Alloc, typename Storage, class Map>
-  struct Get_map<CGAL::Polygonal_schema_with_combinatorial_map<Items, Alloc, Storage>, Map>
+  struct Get_map<CGAL::Surface_mesh_topology::
+                 Polygonal_schema_with_combinatorial_map<Items, Alloc, Storage>, Map>
   {
     typedef Map type;
     typedef const Map& storage_type;
@@ -814,7 +815,8 @@ protected:
   };
 
   template <typename Items, typename Alloc, typename Storage, class Map>
-  struct Get_map<CGAL::Polygonal_schema_with_generalized_map<Items, Alloc, Storage>, Map>
+  struct Get_map<CGAL::Surface_mesh_topology::
+                 Polygonal_schema_with_generalized_map<Items, Alloc, Storage>, Map>
   {
     typedef Map type;
     typedef const Map& storage_type;

Installation/include/CGAL/license/Surface_mesh_topology.h

@@ -0,0 +1,63 @@
+// Copyright (c) 2016  GeometryFactory SARL (France).
+// All rights reserved.
+//
+// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation; either version 3 of the License,
+// or (at your option) any later version.
+//
+// Licensees holding a valid commercial license may use this file in
+// accordance with the commercial license agreement provided with the software.
+//
+// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// $URL$
+// $Id$
+// SPDX-License-Identifier: LGPL-3.0+
+//
+// Author(s) : Andreas Fabri
+//
+// Warning: this file is generated, see include/CGAL/licence/README.md
+
+#ifndef CGAL_LICENSE_SURFACE_MESH_TOPOLOGY_H
+#define CGAL_LICENSE_SURFACE_MESH_TOPOLOGY_H
+
+#include <CGAL/config.h>
+#include <CGAL/license.h>
+
+#ifdef CGAL_SURFACE_MESH_TOPOLOGY_COMMERCIAL_LICENSE
+
+#  if CGAL_SURFACE_MESH_TOPOLOGY_COMMERCIAL_LICENSE < CGAL_RELEASE_DATE
+
+#    if defined(CGAL_LICENSE_WARNING)
+
+       CGAL_pragma_warning("Your commercial license for CGAL does not cover "
+                           "this release of the Surface Mesh Topology package.")
+#    endif
+
+#    ifdef CGAL_LICENSE_ERROR
+#      error "Your commercial license for CGAL does not cover this release \
+              of the Surface Mesh Topology package. \
+              You get this error, as you defined CGAL_LICENSE_ERROR."
+#    endif // CGAL_LICENSE_ERROR
+
+#  endif // CGAL_SURFACE_MESH_TOPOLOGY_COMMERCIAL_LICENSE < CGAL_RELEASE_DATE
+
+#else // no CGAL_SURFACE_MESH_TOPOLOGY_COMMERCIAL_LICENSE
+
+#  if defined(CGAL_LICENSE_WARNING)
+     CGAL_pragma_warning("\nThe macro CGAL_SURFACE_MESH_TOPOLOGY_COMMERCIAL_LICENSE is not defined."
+                          "\nYou use the CGAL Surface Mesh Topology package under "
+                          "the terms of the GPLv3+.")
+#  endif // CGAL_LICENSE_WARNING
+
+#  ifdef CGAL_LICENSE_ERROR
+#    error "The macro CGAL_SURFACE_MESH_TOPOLOGY_COMMERCIAL_LICENSE is not defined.\
+            You use the CGAL Surface Mesh Topology package under the terms of \
+            the GPLv3+. You get this error, as you defined CGAL_LICENSE_ERROR."
+#  endif // CGAL_LICENSE_ERROR
+
+#endif // no CGAL_SURFACE_MESH_TOPOLOGY_COMMERCIAL_LICENSE
+
+#endif // CGAL_LICENSE_SURFACE_MESH_TOPOLOGY_H

Surface_mesh_topology/examples/Surface_mesh_topology/basic_example_surface_mesh_topology.cpp

@@ -5,9 +5,10 @@
 #include <CGAL/draw_face_graph_with_paths.h>
 
 typedef CGAL::Linear_cell_complex_for_combinatorial_map<2,3> LCC_3_cmap;
+using namespace CGAL::Surface_mesh_topology;
 
 ///////////////////////////////////////////////////////////////////////////////
-void create_path_1(CGAL::Path_on_surface<LCC_3_cmap>& p)
+void create_path_1(Path_on_surface<LCC_3_cmap>& p)
 {
   p.push_back_by_index(14); // Its starting dart
   for (int i=0; i<7; ++i)
@@ -15,11 +16,11 @@ void create_path_1(CGAL::Path_on_surface<LCC_3_cmap>& p)
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-void create_path_2(CGAL::Path_on_surface<LCC_3_cmap>& p)
+void create_path_2(Path_on_surface<LCC_3_cmap>& p)
 { p.push_back_by_index({202, 206, 335, 317, 322, 69, 62, 414}); }
 
 ///////////////////////////////////////////////////////////////////////////////
-void create_path_3(CGAL::Path_on_surface<LCC_3_cmap>& p)
+void create_path_3(Path_on_surface<LCC_3_cmap>& p)
 {
   p.push_back_by_index(470); // Its starting dart
   for (int i=0; i<13; ++i)
@@ -36,8 +37,8 @@ int main()
     exit(EXIT_FAILURE);
   }
 
-  CGAL::Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
+  Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
-  CGAL::Path_on_surface<LCC_3_cmap> p1(lcc), p2(lcc), p3(lcc);
+  Path_on_surface<LCC_3_cmap> p1(lcc), p2(lcc), p3(lcc);
   create_path_1(p1);
   create_path_2(p2);
   create_path_3(p3);
@@ -55,7 +56,7 @@ int main()
            <<" homotopic with path p3 (orange)."<<std::endl;
 
 #ifdef CGAL_USE_BASIC_VIEWER
-  std::vector<CGAL::Path_on_surface<LCC_3_cmap> > paths={p1, p2, p3};
+  std::vector<Path_on_surface<LCC_3_cmap> > paths={p1, p2, p3};
   CGAL::draw(lcc, paths); // Enable only if CGAL was compiled with Qt5
 #endif // CGAL_USE_BASIC_VIEWER
   

Surface_mesh_topology/examples/Surface_mesh_topology/basic_example_torus.cpp

@@ -5,9 +5,10 @@
 #include <CGAL/draw_face_graph_with_paths.h>
 
 typedef CGAL::Linear_cell_complex_for_combinatorial_map<2,3> LCC_3_cmap;
+using namespace CGAL::Surface_mesh_topology;
 
 ///////////////////////////////////////////////////////////////////////////////
-void create_path_1(CGAL::Path_on_surface<LCC_3_cmap>& p)
+void create_path_1(Path_on_surface<LCC_3_cmap>& p)
 {
   p.push_back_by_index(0); // Its starting dart
   for (int i=0; i<4; ++i)
@@ -15,7 +16,7 @@ void create_path_1(CGAL::Path_on_surface<LCC_3_cmap>& p)
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-void create_path_2(CGAL::Path_on_surface<LCC_3_cmap>& p)
+void create_path_2(Path_on_surface<LCC_3_cmap>& p)
 { 
   p.push_back_by_index(1); // Its starting dart
   for (int i=0; i<4; ++i)
@@ -32,8 +33,8 @@ int main()
     exit(EXIT_FAILURE);
   }
 
-  CGAL::Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
+  Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
-  CGAL::Path_on_surface<LCC_3_cmap> p1(lcc), p2(lcc);
+  Path_on_surface<LCC_3_cmap> p1(lcc), p2(lcc);
   create_path_1(p1);
   create_path_2(p2);
   
@@ -46,7 +47,7 @@ int main()
            <<" homotopic with path p2 (green)."<<std::endl;
 
 #ifdef CGAL_USE_BASIC_VIEWER
-  std::vector<CGAL::Path_on_surface<LCC_3_cmap> > paths={p1, p2};
+  std::vector<Path_on_surface<LCC_3_cmap> > paths={p1, p2};
   CGAL::draw(lcc, paths); // Enable only if CGAL was compiled with Qt5
 #endif // CGAL_USE_BASIC_VIEWER
   

Surface_mesh_topology/examples/Surface_mesh_topology/map_2_constructor.cpp

@@ -3,8 +3,10 @@
 #include <iostream>
 #include <cstdlib>
 
-typedef CGAL::Polygonal_schema_with_combinatorial_map<> CMap;
+using namespace CGAL::Surface_mesh_topology;
-typedef CGAL::Polygonal_schema_with_generalized_map<>   GMap;
+
+typedef Polygonal_schema_with_combinatorial_map<> CMap;
+typedef Polygonal_schema_with_generalized_map<>   GMap;
 
 template<typename Map>
 void construct_map_from_edges()
@@ -14,7 +16,7 @@ void construct_map_from_edges()
   cm.add_facet("a b c -a -b");
   cm.add_facet("-c d e -d -e");
 
-  CGAL::Path_on_surface<Map> p(cm); p.push_back_by_label("a b d e");
+  Path_on_surface<Map> p(cm); p.push_back_by_label("a b d e");
 
   std::cout<<"Map valid="<<cm.is_valid()<<std::flush;
   cm.display_characteristics(std::cout);

Surface_mesh_topology/examples/Surface_mesh_topology/open_path_homotopy.cpp

@@ -7,8 +7,10 @@ typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
 typedef Kernel::Point_3                                     Point_3;
 typedef CGAL::Surface_mesh<Point_3>                         SM;
 
+using namespace CGAL::Surface_mesh_topology;
+
 ///////////////////////////////////////////////////////////////////////////////
-void create_path_1(CGAL::Path_on_surface<SM>& p)
+void create_path_1(Path_on_surface<SM>& p)
 {
   p.push_back_by_index(88); // Its starting dart
   for (int i=0; i<3; ++i)
@@ -16,7 +18,7 @@ void create_path_1(CGAL::Path_on_surface<SM>& p)
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-void create_path_2(CGAL::Path_on_surface<SM>& p)
+void create_path_2(Path_on_surface<SM>& p)
 {
   p.push_back_by_index(300);  // Its starting dart
   for (int i=0; i<3; ++i)
@@ -24,7 +26,7 @@ void create_path_2(CGAL::Path_on_surface<SM>& p)
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-void create_path_3(CGAL::Path_on_surface<SM>& p)
+void create_path_3(Path_on_surface<SM>& p)
 {
   p.push_back_by_index(87); // Its starting dart
   p.extend_positive_turn(1); // Extend the path
@@ -45,8 +47,8 @@ int main()
   }
   in>>sm;
 
-  CGAL::Curves_on_surface_topology<SM> cst(sm);
+  Curves_on_surface_topology<SM> cst(sm);
-  CGAL::Path_on_surface<SM> p1(sm), p2(sm), p3(sm);
+  Path_on_surface<SM> p1(sm), p2(sm), p3(sm);
   create_path_1(p1);
   create_path_2(p2);
   create_path_3(p3);
@@ -60,7 +62,7 @@ int main()
            <<" base point homotopic with path p3 (orange)."<<std::endl;
 
 #ifdef CGAL_USE_BASIC_VIEWER
-  std::vector<CGAL::Path_on_surface<SM> > paths={p1, p2, p3};
+  std::vector<Path_on_surface<SM> > paths={p1, p2, p3};
   CGAL::draw(sm, paths); // Enable only if CGAL was compiled with Qt5
 #endif // CGAL_USE_BASIC_VIEWER
   

Surface_mesh_topology/examples/Surface_mesh_topology/path_homotopy.cpp

@@ -1,16 +1,16 @@
 #include <CGAL/Linear_cell_complex_for_combinatorial_map.h>
 #include <CGAL/Linear_cell_complex_constructors.h>
 #include <CGAL/Curves_on_surface_topology.h>
+#include <CGAL/Path_on_surface.h>
 
 /* If you want to use a viewer, you can use qglviewer. */
 #ifdef CGAL_USE_BASIC_VIEWER
 #include <CGAL/draw_face_graph_with_paths.h>
 #endif
 
-#include <CGAL/Path_generators.h>
-#include <CGAL/Path_on_surface.h>
-
 typedef CGAL::Linear_cell_complex_for_combinatorial_map<2,3> LCC_3_cmap;
+using namespace CGAL::Surface_mesh_topology;
+
 ///////////////////////////////////////////////////////////////////////////////
 [[ noreturn ]] void usage(int /*argc*/, char** argv)
 {
@@ -117,7 +117,7 @@ int main(int argc, char** argv)
   lcc.display_characteristics(std::cout) << ", valid="
                                          << lcc.is_valid() << std::endl;
   
-  CGAL::Curves_on_surface_topology<LCC_3_cmap> cst(lcc, time);
+  Curves_on_surface_topology<LCC_3_cmap> cst(lcc, time);
   std::cout<<"Reduced map: ";
   cst.get_map().display_characteristics(std::cout)
     << ", valid="<< cst.get_map().is_valid() << std::endl;
@@ -137,16 +137,16 @@ int main(int argc, char** argv)
     length=static_cast<unsigned int>(random.get_int(l1, l2+1));
     defo=static_cast<unsigned int>(random.get_int(d1, d2+1));
     
-    std::vector<CGAL::Path_on_surface<LCC_3_cmap> > paths;
+    std::vector<Path_on_surface<LCC_3_cmap> > paths;
-    std::vector<CGAL::Path_on_surface<LCC_3_cmap> > transformed_paths;
+    std::vector<Path_on_surface<LCC_3_cmap> > transformed_paths;
 
-    CGAL::Path_on_surface<LCC_3_cmap> path1(lcc);
+    Path_on_surface<LCC_3_cmap> path1(lcc);
     path1.generate_random_closed_path(length, random);
 
     std::cout<<"Path1 size: "<<path1.length()<<" (from "<<length<<" darts); ";
     paths.push_back(path1);
 
-    CGAL::Path_on_surface<LCC_3_cmap> path2(path1);
+    Path_on_surface<LCC_3_cmap> path2(path1);
     path2.update_path_randomly(defo, random);
     std::cout<<"Path2 size: "<<path2.length()<<" (from "<<defo<<" deformations): ";
     paths.push_back(path2);

Surface_mesh_topology/examples/Surface_mesh_topology/path_homotopy_with_symbols.cpp

@@ -4,17 +4,18 @@
 #include <iostream>
 #include <cstdlib>
 
-typedef CGAL::Polygonal_schema_with_combinatorial_map<> PS;
+using namespace CGAL::Surface_mesh_topology;
+typedef Polygonal_schema_with_combinatorial_map<> PS;
 
 int main()
 {
   PS ps;
   ps.add_facet("a b -a -b c d -c -d");
 
-  CGAL::Path_on_surface<PS> p1(ps); p1.push_back_by_label("a");
+  Path_on_surface<PS> p1(ps); p1.push_back_by_label("a");
-  CGAL::Path_on_surface<PS> p2(ps); p2.push_back_by_label("b c a -c -b");
+  Path_on_surface<PS> p2(ps); p2.push_back_by_label("b c a -c -b");
     
-  CGAL::Curves_on_surface_topology<PS> cst(ps);
+  Curves_on_surface_topology<PS> cst(ps);
 
   bool res1=cst.are_freely_homotopic(p1, p2);
   std::cout<<"Paths p1 and p2 "<<(res1?"ARE":"ARE NOT")

Surface_mesh_topology/examples/Surface_mesh_topology/path_homotopy_with_symbols_2.cpp

@@ -4,7 +4,7 @@
 #include <iostream>
 #include <cstdlib>
 
-typedef CGAL::Polygonal_schema_with_combinatorial_map<> PS;
+typedef CGAL::Surface_mesh_topology::Polygonal_schema_with_combinatorial_map<> PS;
 
 int main()
 {
@@ -23,10 +23,10 @@ int main()
   std::cout<<"Number of cells of the combinatorial maps: ";
   ps.display_characteristics(std::cout)<<std::endl;
   
-  CGAL::Path_on_surface<PS> p(ps);
+  CGAL::Surface_mesh_topology::Path_on_surface<PS> p(ps);
   p.push_back_by_label("a b -a e -b d");  
 
-  CGAL::Curves_on_surface_topology<PS> cst(ps);
+  CGAL::Surface_mesh_topology::Curves_on_surface_topology<PS> cst(ps);
   bool res=cst.is_contractible(p);
   std::cout<<"Path "<<(res?"IS":"IS NOT")<<" contractible."<<std::endl;
 

Surface_mesh_topology/examples/Surface_mesh_topology/surface_mesh_topology_with_sm_and_polyhedron.cpp

@@ -5,7 +5,6 @@
 #include <CGAL/Surface_mesh.h>
 
 #include <CGAL/Curves_on_surface_topology.h>
-#include <CGAL/Path_generators.h>
 #include <CGAL/Path_on_surface.h>
 #include <CGAL/boost/graph/io.h>
 #include <CGAL/Face_graph_wrapper.h>
@@ -17,17 +16,20 @@ typedef Kernel::Point_3                                     Point_3;
 typedef CGAL::Surface_mesh<Point_3>                         SM;
 
 static unsigned int seed; // Use the same seed for the two tests
+
+using namespace CGAL::Surface_mesh_topology;
+
 ///////////////////////////////////////////////////////////////////////////////
 template<class FaceGraph>
 void test(const FaceGraph& mesh)
 {
   CGAL::Random random(seed);
-  CGAL::Curves_on_surface_topology<FaceGraph> cst(mesh);
+  Curves_on_surface_topology<FaceGraph> cst(mesh);
 
-  CGAL::Path_on_surface<FaceGraph> p1(mesh); // A first path
+  Path_on_surface<FaceGraph> p1(mesh); // A first path
   p1.generate_random_closed_path(10, random);
 
-  CGAL::Path_on_surface<FaceGraph> p2(mesh); // A second path
+  Path_on_surface<FaceGraph> p2(mesh); // A second path
   p2.generate_random_closed_path(10, random);
 
   bool res1=cst.is_contractible(p1);
@@ -37,7 +39,7 @@ void test(const FaceGraph& mesh)
   std::cout<<"Path p1 "<<(res2?"IS":"IS NOT")<<" homotopic with path p2."<<std::endl;
 
 #ifdef CGAL_USE_BASIC_VIEWER
-  std::vector<CGAL::Path_on_surface<FaceGraph> > paths={p1, p2};
+  std::vector<Path_on_surface<FaceGraph> > paths={p1, p2};
   CGAL::draw(mesh, paths); // Enable only if CGAL was compiled with Qt5 */
 #endif // CGAL_USE_BASIC_VIEWER
 }

Surface_mesh_topology/include/CGAL/Curves_on_surface_topology.h

@@ -1,10 +1,10 @@
 // Copyright (c) 2019 CNRS and LIRIS' Establishments (France).
 // All rights reserved.
 //
-// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// This file is part of CGAL (www.cgal.org).
-// modify it under the terms of the GNU Lesser General Public License as
+// You can redistribute it and/or modify it under the terms of the GNU
-// published by the Free Software Foundation; either version 3 of the License,
+// General Public License as published by the Free Software Foundation,
-// or (at your option) any later version.
+// either version 3 of the License, or (at your option) any later version.
 //
 // Licensees holding a valid commercial license may use this file in
 // accordance with the commercial license agreement provided with the software.
@@ -14,12 +14,12 @@
 //
 // $URL$
 // $Id$
-// SPDX-License-Identifier: LGPL-3.0+
+// SPDX-License-Identifier: GPL-3.0+
 //
 // Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
 //
-#ifndef CGAL_HOMOTOPY_TESTER_H
+#ifndef CGAL_CURVES_ON_SURFACE_TOPOLOGY_H
-#define CGAL_HOMOTOPY_TESTER_H 1
+#define CGAL_CURVES_ON_SURFACE_TOPOLOGY_H 1
 
 // Should be defined before to include Path_on_surface_with_rle.h
 // If nothing is defined, use V1
@@ -27,11 +27,13 @@
 // #define CGAL_PWRLE_TURN_V2  // Compute turns by using an id of darts, given by an hash-table (built and given by Curves_on_surface_topology)
 #define CGAL_PWRLE_TURN_V3  // Compute turns by using an id of darts, associated in Info of Darts (build by Curves_on_surface_topology)
 
+#include <CGAL/license/Surface_mesh_topology.h>
+
 #include <CGAL/Union_find.h>
 #include <CGAL/Random.h>
 #include <CGAL/Path_on_surface.h>
-#include <CGAL/Path_on_surface_with_rle.h>
+#include <CGAL/Surface_mesh_topology/internal/Path_on_surface_with_rle.h>
-#include <CGAL/Path_generators.h>
+#include <CGAL/Surface_mesh_topology/internal/Path_generators.h>
 #include <CGAL/Combinatorial_map_operations.h>
 #include <CGAL/Timer.h>
 #include <CGAL/Face_graph_wrapper.h>
@@ -40,6 +42,7 @@
 #include <iostream>
 
 namespace CGAL {
+namespace Surface_mesh_topology {
 
 struct CMap_for_homotopy_tester_items
 {
@@ -324,7 +327,7 @@ CMap_for_homotopy_tester;
       }
       else
       {
-        Path_on_surface_with_rle<CMap_for_homotopy_tester>
+        internal::Path_on_surface_with_rle<CMap_for_homotopy_tester>
             pt=transform_original_path_into_quad_surface_with_rle(p);
 
         pt.canonize();
@@ -379,9 +382,9 @@ CMap_for_homotopy_tester;
       }
       else
       {
-        Path_on_surface_with_rle<CMap_for_homotopy_tester>
+        internal::Path_on_surface_with_rle<CMap_for_homotopy_tester>
           pt1=transform_original_path_into_quad_surface_with_rle(p1);
-        Path_on_surface_with_rle<CMap_for_homotopy_tester>
+        internal::Path_on_surface_with_rle<CMap_for_homotopy_tester>
           pt2=transform_original_path_into_quad_surface_with_rle(p2);
         pt1.canonize();
         pt2.canonize();
@@ -501,11 +504,11 @@ CMap_for_homotopy_tester;
       return res;
     }
 
-    Path_on_surface_with_rle<CMap_for_homotopy_tester>
+    internal::Path_on_surface_with_rle<CMap_for_homotopy_tester>
     transform_original_path_into_quad_surface_with_rle
     (const Path_on_surface<Mesh>& path) const
     {
-      Path_on_surface_with_rle<CMap_for_homotopy_tester>
+      internal::Path_on_surface_with_rle<CMap_for_homotopy_tester>
           res(m_map
         #ifdef CGAL_PWRLE_TURN_V2
               , m_dart_ids
@@ -1158,7 +1161,8 @@ CMap_for_homotopy_tester;
 #endif // CGAL_PWRLE_TURN_V2
   };
   
+} // namespace Surface_mesh_topology
 } // namespace CGAL
 
-#endif // CGAL_HOMOTOPY_TESTER_H //
+#endif // CGAL_CURVES_ON_SURFACE_TOPOLOGY_H //
 // EOF //

Surface_mesh_topology/include/CGAL/Path_on_surface.h

@@ -1,10 +1,10 @@
 // Copyright (c) 2019 CNRS and LIRIS' Establishments (France).
 // All rights reserved.
 //
-// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// This file is part of CGAL (www.cgal.org).
-// modify it under the terms of the GNU Lesser General Public License as
+// You can redistribute it and/or modify it under the terms of the GNU
-// published by the Free Software Foundation; either version 3 of the License,
+// General Public License as published by the Free Software Foundation,
-// or (at your option) any later version.
+// either version 3 of the License, or (at your option) any later version.
 //
 // Licensees holding a valid commercial license may use this file in
 // accordance with the commercial license agreement provided with the software.
@@ -14,17 +14,20 @@
 //
 // $URL$
 // $Id$
-// SPDX-License-Identifier: LGPL-3.0+
+// SPDX-License-Identifier: GPL-3.0+
 //
 // Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
 //
 #ifndef CGAL_PATH_ON_SURFACE_H
 #define CGAL_PATH_ON_SURFACE_H 1
 
+#include <CGAL/license/Surface_mesh_topology.h>
+
 #include <CGAL/Combinatorial_map_operations.h>
 #include <CGAL/Combinatorial_map.h>
 #include <CGAL/Random.h>
 #include <CGAL/Face_graph_wrapper.h>
+#include <CGAL/Surface_mesh_topology/internal/Path_on_surface_with_rle.h>
 #include <boost/algorithm/searching/knuth_morris_pratt.hpp>
 #include <utility>
 #include <string>
@@ -34,14 +37,12 @@
 #include <initializer_list>
 
 namespace CGAL {
-
+namespace Surface_mesh_topology {
-template<typename Mesh>
-class Path_on_surface_with_rle;
 
 template<typename Mesh>
 class Path_on_surface
 {
-  friend class Path_on_surface_with_rle<Mesh>;
+  friend class internal::Path_on_surface_with_rle<Mesh>;
 
 public:
   typedef Path_on_surface<Mesh>           Self;
@@ -51,7 +52,7 @@ public:
   Path_on_surface(const Mesh& amap) : m_map(amap), m_is_closed(false)
   {}
 
-  Path_on_surface(const Path_on_surface_with_rle<Mesh>& apath) :
+  Path_on_surface(const internal::Path_on_surface_with_rle<Mesh>& apath) :
     m_map(apath.get_map()),
     m_is_closed(apath.is_closed())
   {
@@ -937,6 +938,7 @@ protected:
   bool m_is_closed;                      /// True iff the path is a cycle
 };
 
+} // namespace Surface_mesh_topology
 } // namespace CGAL
 
 #endif // CGAL_PATH_ON_SURFACE_H //

Surface_mesh_topology/include/CGAL/Polygonal_schema.h

@@ -1,10 +1,10 @@
 // Copyright (c) 2019 CNRS and LIRIS' Establishments (France).
 // All rights reserved.
 //
-// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// This file is part of CGAL (www.cgal.org).
-// modify it under the terms of the GNU Lesser General Public License as
+// You can redistribute it and/or modify it under the terms of the GNU
-// published by the Free Software Foundation; either version 3 of the License,
+// General Public License as published by the Free Software Foundation,
-// or (at your option) any later version.
+// either version 3 of the License, or (at your option) any later version.
 //
 // Licensees holding a valid commercial license may use this file in
 // accordance with the commercial license agreement provided with the software.
@@ -14,25 +14,28 @@
 //
 // $URL$
 // $Id$
-// SPDX-License-Identifier: LGPL-3.0+
+// SPDX-License-Identifier: GPL-3.0+
 //
 // Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
 //
 #ifndef CGAL_POLYGONAL_SCHEMA_H
 #define CGAL_POLYGONAL_SCHEMA_H 1
 
+#include <CGAL/license/Surface_mesh_topology.h>
+
 #include <vector>
 #include <unordered_map>
 #include <cstddef>
 #include <string>
+#include <initializer_list>
 #include <CGAL/assertions.h>
 #include <CGAL/memory.h>
 #include <CGAL/Polygonal_schema_min_items.h>
 #include <CGAL/Combinatorial_map.h>
 #include <CGAL/Generalized_map.h>
-#include <initializer_list>
 
 namespace CGAL {
+namespace Surface_mesh_topology {
 
   namespace internal 
   {
@@ -46,141 +49,143 @@ namespace CGAL {
       
       return std::string("-")+s;
     }
+
+    template<class Map, class Combinatorial_data_structure=
+             typename Map::Combinatorial_data_structure>
+    struct Polygonal_schema_tools
+    {};
+    template<class CMap>
+    struct Polygonal_schema_tools<CMap, Combinatorial_map_tag>
+    {
+      typedef typename CMap::Dart_handle Dart_handle;
+      
+      static Dart_handle
+      add_edge_to_face(CMap& cmap, const std::string& s,
+                       Dart_handle prev_dart,
+                       Dart_handle dart_same_label,
+                       Dart_handle dart_opposite_label,
+                       std::unordered_map<std::string, Dart_handle>& edge_label_to_dart)
+      {
+        if (dart_same_label!=NULL && dart_opposite_label!=NULL)
+        {
+          std::cerr<<"Polygonal_schema ERROR: "<<"both labels "<<s
+                   <<" and "<<internal::opposite_label(s)<<" are already added in the surface."
+                   <<" This label can not be use anymore."<<std::endl;
+          return NULL;
+        }
+        
+        if (dart_same_label!=NULL)
+        {
+          std::cerr<<"Polygonal_schema ERROR: "<<"label "<<s
+                   <<" is already added in the surface."
+                   <<" Since the surface is orientable, this label can not be use anymore."<<std::endl;
+          return NULL;
+        }
+        
+        Dart_handle res=cmap.create_dart();
+        edge_label_to_dart[s]=res;
+        
+        cmap.info(res).m_label=new char[s.size()+1];
+        strncpy(cmap.info(res).m_label, s.c_str(), s.size()+1); // +1 to copy also the \0 char
+        
+        if (prev_dart!=cmap.null_handle)
+        { cmap.template link_beta<1>(prev_dart, res); }
+        
+        if (dart_opposite_label!=NULL)
+        { cmap.template link_beta<2>(res, dart_opposite_label); }
+        
+        return res;
+      }
+      
+      std::string get_label(CMap& cmap, Dart_handle dh) const
+      {
+        CGAL_assertion(cmap.info(dh).m_label!=NULL);
+        return std::string(cmap.info(dh).m_label);
+      }
+    };
+    template<class GMap>
+    struct Polygonal_schema_tools<GMap, Generalized_map_tag>
+    {
+      typedef typename GMap::Dart_handle Dart_handle;
+      
+      // In a GMap, if an edge is 2-free, only one of its two dart has one label.
+      // Otherwise, d has one label and alpha<0,2>(d) the opposite label.
+      static Dart_handle
+      add_edge_to_face(GMap& gmap, const std::string& s,
+                       Dart_handle prev_dart,
+                       Dart_handle dart_same_label,
+                       Dart_handle dart_opposite_label,
+                       std::unordered_map<std::string, Dart_handle>& edge_label_to_dart)
+      {
+        if (dart_same_label!=NULL && dart_opposite_label!=NULL)
+        {
+          std::cerr<<"Polygonal_schema ERROR: "<<"both labels "<<s
+                   <<" and "<<internal::opposite_label(s)<<" are already added in the surface."
+                   <<" This label can not be use anymore."<<std::endl;
+          return NULL;
+        }
+      
+        Dart_handle res=gmap.create_dart();
+        Dart_handle dh2=gmap.create_dart();
+
+        gmap.template link_alpha<0>(res, dh2);
+        if (prev_dart!=gmap.null_handle)
+        { gmap.template link_alpha<1>(res, gmap.template alpha<0>(prev_dart)); }
+
+        if (dart_same_label!=NULL)
+        { // Here dart_same_label!=NULL
+          std::string s2=internal::opposite_label(s);
+          edge_label_to_dart[s2]=dh2;
+          gmap.info(dh2).m_label=new char[s2.size()+1];
+          strncpy(gmap.info(dh2).m_label, s2.c_str(), s2.size()+1); // +1 to copy also the \0 char
+
+          gmap.template sew<2>(res, dart_same_label);
+        }
+        else
+        { // Here either dart_opposite_label!=NULL, or both are NULL
+          edge_label_to_dart[s]=res;
+          gmap.info(res).m_label=new char[s.size()+1];
+          strncpy(gmap.info(res).m_label, s.c_str(), s.size()+1); // +1 to copy also the \0 char
+
+          if (dart_opposite_label!=NULL)
+          {
+            std::string s2=internal::opposite_label(s);
+            edge_label_to_dart[s2]=res;
+            gmap.info(res).m_label=new char[s2.size()+1];
+            strncpy(gmap.info(res).m_label, s2.c_str(), s2.size()+1); // +1 to copy also the \0 char
+          
+            gmap.template sew<2>(dh2, dart_opposite_label);
+          }
+        }
+
+        return res;
+      }
+
+      std::string get_label(GMap& gmap, Dart_handle dh) const
+      {
+        char* label=gmap.info(dh).m_label;
+
+        if (label==NULL)
+        {
+          if (!gmap.is_free<2>(dh))
+          { label=gmap.info(gmap.template alpha<2>(dh)).m_label; }
+          else
+          {
+            return internal::opposite_label
+              (std::string(gmap.info(gmap.template alpha<0>(dh))));
+          }
+        }
+        CGAL_assertion(label!=NULL);
+        return std::string(label);
+      }
+    };
+
   }
+  // end namespace internal
 
   struct Combinatorial_map_tag;
   struct Generalized_map_tag;
   
-  template<class Map, class Combinatorial_data_structure=
-           typename Map::Combinatorial_data_structure>
-  struct Polygonal_schema_tools
-  {};
-  template<class CMap>
-  struct Polygonal_schema_tools<CMap, Combinatorial_map_tag>
-  {
-    typedef typename CMap::Dart_handle Dart_handle;
-    
-    static Dart_handle
-    add_edge_to_face(CMap& cmap, const std::string& s,
-                     Dart_handle prev_dart,
-                     Dart_handle dart_same_label,
-                     Dart_handle dart_opposite_label,
-                     std::unordered_map<std::string, Dart_handle>& edge_label_to_dart)
-    {
-      if (dart_same_label!=NULL && dart_opposite_label!=NULL)
-      {
-        std::cerr<<"Polygonal_schema ERROR: "<<"both labels "<<s
-                 <<" and "<<internal::opposite_label(s)<<" are already added in the surface."
-                 <<" This label can not be use anymore."<<std::endl;
-        return NULL;
-      }
-
-      if (dart_same_label!=NULL)
-      {
-       std::cerr<<"Polygonal_schema ERROR: "<<"label "<<s
-                 <<" is already added in the surface."
-                 <<" Since the surface is orientable, this label can not be use anymore."<<std::endl;
-        return NULL;
-      }
-      
-      Dart_handle res=cmap.create_dart();
-      edge_label_to_dart[s]=res;
-
-      cmap.info(res).m_label=new char[s.size()+1];
-      strncpy(cmap.info(res).m_label, s.c_str(), s.size()+1); // +1 to copy also the \0 char
-
-      if (prev_dart!=cmap.null_handle)
-      { cmap.template link_beta<1>(prev_dart, res); }
-      
-      if (dart_opposite_label!=NULL)
-      { cmap.template link_beta<2>(res, dart_opposite_label); }
-      
-      return res;
-    }
-
-    std::string get_label(CMap& cmap, Dart_handle dh) const
-    {
-      CGAL_assertion(cmap.info(dh).m_label!=NULL);
-      return std::string(cmap.info(dh).m_label);
-    }
-  };
-  template<class GMap>
-  struct Polygonal_schema_tools<GMap, Generalized_map_tag>
-  {
-    typedef typename GMap::Dart_handle Dart_handle;
-
-    // In a GMap, if an edge is 2-free, only one of its two dart has one label.
-    // Otherwise, d has one label and alpha<0,2>(d) the opposite label.
-    static Dart_handle
-    add_edge_to_face(GMap& gmap, const std::string& s,
-                     Dart_handle prev_dart,
-                     Dart_handle dart_same_label,
-                     Dart_handle dart_opposite_label,
-                     std::unordered_map<std::string, Dart_handle>& edge_label_to_dart)
-    {
-       if (dart_same_label!=NULL && dart_opposite_label!=NULL)
-      {
-        std::cerr<<"Polygonal_schema ERROR: "<<"both labels "<<s
-                 <<" and "<<internal::opposite_label(s)<<" are already added in the surface."
-                 <<" This label can not be use anymore."<<std::endl;
-        return NULL;
-      }
-      
-      Dart_handle res=gmap.create_dart();
-      Dart_handle dh2=gmap.create_dart();
-
-      gmap.template link_alpha<0>(res, dh2);
-      if (prev_dart!=gmap.null_handle)
-      { gmap.template link_alpha<1>(res, gmap.template alpha<0>(prev_dart)); }
-
-      if (dart_same_label!=NULL)
-      { // Here dart_same_label!=NULL
-        std::string s2=internal::opposite_label(s);
-        edge_label_to_dart[s2]=dh2;
-        gmap.info(dh2).m_label=new char[s2.size()+1];
-        strncpy(gmap.info(dh2).m_label, s2.c_str(), s2.size()+1); // +1 to copy also the \0 char
-
-        gmap.template sew<2>(res, dart_same_label);
-      }
-      else
-      { // Here either dart_opposite_label!=NULL, or both are NULL
-        edge_label_to_dart[s]=res;
-        gmap.info(res).m_label=new char[s.size()+1];
-        strncpy(gmap.info(res).m_label, s.c_str(), s.size()+1); // +1 to copy also the \0 char
-
-        if (dart_opposite_label!=NULL)
-        {
-          std::string s2=internal::opposite_label(s);
-          edge_label_to_dart[s2]=res;
-          gmap.info(res).m_label=new char[s2.size()+1];
-          strncpy(gmap.info(res).m_label, s2.c_str(), s2.size()+1); // +1 to copy also the \0 char
-          
-          gmap.template sew<2>(dh2, dart_opposite_label);
-        }
-      }
-
-      return res;
-    }
-
-    std::string get_label(GMap& gmap, Dart_handle dh) const
-    {
-      char* label=gmap.info(dh).m_label;
-
-      if (label==NULL)
-      {
-        if (!gmap.is_free<2>(dh))
-        { label=gmap.info(gmap.template alpha<2>(dh)).m_label; }
-        else
-        {
-          return internal::opposite_label
-            (std::string(gmap.info(gmap.template alpha<0>(dh))));
-        }
-      }
-      CGAL_assertion(label!=NULL);
-      return std::string(label);
-    }
-  };
-
   template < class BaseModel >
   class Polygonal_schema_base: public BaseModel
   {
@@ -239,7 +244,7 @@ namespace CGAL {
       Dart_handle dart_same_label=get_dart_labeled(s);
       Dart_handle dart_opposite_label=get_dart_labeled(internal::opposite_label(s));
       
-      Dart_handle cur=Polygonal_schema_tools<Map>::
+      Dart_handle cur=internal::Polygonal_schema_tools<Map>::
         add_edge_to_face(*this, s, prev_dart, dart_same_label, dart_opposite_label,
                          edge_label_to_dart);
 
@@ -335,7 +340,7 @@ namespace CGAL {
     }
 
     std::string get_label(Dart_handle dh) const
-    { return Polygonal_schema_tools<Map>::get_label(dh); }
+    { return internal::Polygonal_schema_tools<Map>::get_label(dh); }
     
   protected:
     // For each edge label, its corresponding dart. Stores both association a -a, to allow
@@ -459,6 +464,7 @@ namespace CGAL {
     {}
   };
   
+} //namespace Surface_mesh_topology
 } //namespace CGAL
 
 #endif // CGAL_POLYGONAL_SCHEMA_H //

Surface_mesh_topology/include/CGAL/Polygonal_schema_min_items.h

@@ -1,10 +1,10 @@
 // Copyright (c) 2019 CNRS and LIRIS' Establishments (France).
 // All rights reserved.
 //
-// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// This file is part of CGAL (www.cgal.org).
-// modify it under the terms of the GNU Lesser General Public License as
+// You can redistribute it and/or modify it under the terms of the GNU
-// published by the Free Software Foundation; either version 3 of the License,
+// General Public License as published by the Free Software Foundation,
-// or (at your option) any later version.
+// either version 3 of the License, or (at your option) any later version.
 //
 // Licensees holding a valid commercial license may use this file in
 // accordance with the commercial license agreement provided with the software.
@@ -14,16 +14,19 @@
 //
 // $URL$
 // $Id$
-// SPDX-License-Identifier: LGPL-3.0+
+// SPDX-License-Identifier: GPL-3.0+
 //
 // Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
 //
 #ifndef CGAL_POLYGONAL_SCHEMA_MIN_ITEMS_H
 #define CGAL_POLYGONAL_SCHEMA_MIN_ITEMS_H 1
 
+#include <CGAL/license/Surface_mesh_topology.h>
+
 #include <cstring>
   
 namespace CGAL {
+namespace Surface_mesh_topology {
 
   /** @file Polygonal_schema_min_items.h
    * Definition of min item class for Polygonal_schema.
@@ -50,6 +53,7 @@ namespace CGAL {
     };
   };
 
+} // namespace Surface_mesh_topology
 } // namespace CGAL
 
 #endif // CGAL_POLYGONAL_SCHEMA_MIN_ITEMS_H

Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Path_generators.h

@@ -1,10 +1,10 @@
-// Copyright (c) 2017 CNRS and LIRIS' Establishments (France).
+// Copyright (c) 2019 CNRS and LIRIS' Establishments (France).
 // All rights reserved.
 //
-// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// This file is part of CGAL (www.cgal.org).
-// modify it under the terms of the GNU Lesser General Public License as
+// You can redistribute it and/or modify it under the terms of the GNU
-// published by the Free Software Foundation; either version 3 of the License,
+// General Public License as published by the Free Software Foundation,
-// or (at your option) any later version.
+// either version 3 of the License, or (at your option) any later version.
 //
 // Licensees holding a valid commercial license may use this file in
 // accordance with the commercial license agreement provided with the software.
@@ -14,20 +14,23 @@
 //
 // $URL$
 // $Id$
-// SPDX-License-Identifier: LGPL-3.0+
+// SPDX-License-Identifier: GPL-3.0+
 //
 // Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
 //
 #ifndef CGAL_PATH_GENERATORS_H
 #define CGAL_PATH_GENERATORS_H 1
 
+#include <CGAL/license/Surface_mesh_topology.h>
+
 #include <CGAL/Random.h>
-#include<unordered_set>
+#include <unordered_set>
-#include<unordered_map>
+#include <unordered_map>
 #include <cstdlib>
 
 namespace CGAL {
-
+namespace Surface_mesh_topology {
+namespace internal {
 
 template<typename Path>
 void create_braket_positive(Path& p, std::size_t length, CGAL::Random& random,
@@ -80,7 +83,7 @@ void generate_random_positive_bracket(Path& path,
   path.clear();
   path.initialize_random_starting_dart(random);
   path.extend_straight_positive(nb1-1);
-  CGAL::create_braket_positive(path, nb2);
+  create_braket_positive(path, nb2);
   path.extend_straight_positive(nb3);
   path.generate_random_path(random.get_int(0, 15), random);
 }
@@ -223,6 +226,8 @@ void generate_random_closed_path(Path& p, std::size_t nb,
   CGAL_assertion(p.is_closed());
 }
 
+} // namespace internal
+} // namespace Surface_mesh_topology
 } // namespace CGAL
 
 #endif // CGAL_PATH_GENERATORS_H //

Surface_mesh_topology/include/CGAL/Surface_mesh_topology/internal/Path_on_surface_with_rle.h

@@ -1,10 +1,10 @@
 // Copyright (c) 2019 CNRS and LIRIS' Establishments (France).
 // All rights reserved.
 //
-// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// This file is part of CGAL (www.cgal.org).
-// modify it under the terms of the GNU Lesser General Public License as
+// You can redistribute it and/or modify it under the terms of the GNU
-// published by the Free Software Foundation; either version 3 of the License,
+// General Public License as published by the Free Software Foundation,
-// or (at your option) any later version.
+// either version 3 of the License, or (at your option) any later version.
 //
 // Licensees holding a valid commercial license may use this file in
 // accordance with the commercial license agreement provided with the software.
@@ -14,13 +14,15 @@
 //
 // $URL$
 // $Id$
-// SPDX-License-Identifier: LGPL-3.0+
+// SPDX-License-Identifier: GPL-3.0+
 //
 // Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
 //
 #ifndef CGAL_PATH_ON_SURFACE_WITH_RLE_H
 #define CGAL_PATH_ON_SURFACE_WITH_RLE_H 1
 
+#include <CGAL/license/Surface_mesh_topology.h>
+
 #include <list>
 #include <utility>
 #include <iostream>
@@ -32,10 +34,13 @@
 #include <boost/unordered_set.hpp>
 
 namespace CGAL {
+namespace Surface_mesh_topology {
 
 template<typename Map_>
 class Path_on_surface;
 
+namespace internal {
+
 // A flat is a sequence of darts given by its two extremities: begin and end,
 // with +2 turns (if length>0) or -2 turns (if length<0).
 // length==0 => begin==end.
@@ -1740,6 +1745,8 @@ protected:
 #endif //CGAL_PWRLE_TURN_V2
 };
 
+} // namespace internal
+} // namespace Surface_mesh_topology
 } // namespace CGAL
 
 #endif // CGAL_PATH_ON_SURFACE_WITH_RLE_H //

Surface_mesh_topology/include/CGAL/draw_face_graph_with_paths.h

@@ -1,10 +1,10 @@
 // Copyright (c) 2019 CNRS and LIRIS' Establishments (France).
 // All rights reserved.
 //
-// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
+// This file is part of CGAL (www.cgal.org).
-// modify it under the terms of the GNU Lesser General Public License as
+// You can redistribute it and/or modify it under the terms of the GNU
-// published by the Free Software Foundation; either version 3 of the License,
+// General Public License as published by the Free Software Foundation,
-// or (at your option) any later version.
+// either version 3 of the License, or (at your option) any later version.
 //
 // Licensees holding a valid commercial license may use this file in
 // accordance with the commercial license agreement provided with the software.
@@ -14,12 +14,15 @@
 //
 // $URL$
 // $Id$
+// SPDX-License-Identifier: GPL-3.0+
 //
 // Author(s)     : Guillaume Damiand <guillaume.damiand@liris.cnrs.fr>
-
+//
 #ifndef CGAL_DRAW_FACE_GRAPH_WITH_PATHS_H
 #define CGAL_DRAW_FACE_GRAPH_WITH_PATHS_H
 
+#include <CGAL/license/Surface_mesh_topology.h>
+
 #include <CGAL/draw_linear_cell_complex.h>
 
 #ifdef CGAL_USE_BASIC_VIEWER
@@ -27,8 +30,8 @@
 #include <CGAL/Random.h>
 #include <CGAL/Path_on_surface.h>
 
-namespace CGAL
+namespace CGAL {
-{
+
 // Specialisation for face graph; otherwise use the LCC_geom_utils of LCC.
 template<class Mesh, class Kernel>
 struct LCC_geom_utils<CGAL::Face_graph_wrapper<Mesh>, Kernel, 3>
@@ -99,7 +102,7 @@ public:
   ///        usefull for very big object where this time could be long)
   Face_graph_with_path_viewer(QWidget* parent,
                               const Mesh& amesh,
-                              const std::vector<Path_on_surface<Mesh> >* paths=NULL,
+                              const std::vector<Surface_mesh_topology::Path_on_surface<Mesh> >* paths=NULL,
                               std::size_t amark=LCC::INVALID_MARK,
                               const char* title="", bool anofaces=false,
                               const DrawingFunctorLCC& drawing_functor=DrawingFunctorLCC()) :
@@ -332,7 +335,7 @@ protected:
   const typename Get_map<Mesh, Mesh>::storage_type lcc;
   bool m_nofaces;
   const DrawingFunctorLCC& m_drawing_functor;
-  const std::vector<Path_on_surface<Mesh> >* m_paths;
+  const std::vector<Surface_mesh_topology::Path_on_surface<Mesh> >* m_paths;
   unsigned int m_current_path;
   unsigned int m_current_dart;
   bool m_draw_marked_darts;
@@ -341,7 +344,7 @@ protected:
   
 template<class Mesh, class DrawingFunctor>
 void draw(const Mesh& alcc,
-          const std::vector<Path_on_surface<Mesh> >& paths,
+          const std::vector<Surface_mesh_topology::Path_on_surface<Mesh> >& paths,
           const char* title="Mesh Viewer",
           std::size_t amark=-1,
           bool nofill=false,
@@ -369,7 +372,7 @@ void draw(const Mesh& alcc,
 
 template<class Mesh>
 void draw(const Mesh& alcc,
-          const std::vector<Path_on_surface<Mesh> >& paths,
+          const std::vector<Surface_mesh_topology::Path_on_surface<Mesh> >& paths,
           const char* title="LCC Viewer",
           std::size_t amark=-1,
           bool nofill=false)

Surface_mesh_topology/test/Surface_mesh_topology/Creation_of_test_cases_for_paths.h

@@ -1,4 +1,4 @@
-// Copyright (c) 2017 CNRS and LIRIS' Establishments (France).
+// Copyright (c) 2019 CNRS and LIRIS' Establishments (France).
 // All rights reserved.
 //
 // This file is part of CGAL (www.cgal.org); you can redistribute it and/or
@@ -21,7 +21,7 @@
 #ifndef CGAL_CREATION_OF_TEST_CASES_FOR_PATHS_H
 #define CGAL_CREATION_OF_TEST_CASES_FOR_PATHS_H 1
 
-#include<CGAL/Path_generators.h>
+#include<CGAL/Surface_mesh_topology/internal/Path_generators.h>
 
 namespace CGAL {
 

Surface_mesh_topology/test/Surface_mesh_topology/path_tests.cpp

@@ -1,13 +1,14 @@
 #include <CGAL/Linear_cell_complex_for_combinatorial_map.h>
 #include <CGAL/Linear_cell_complex_constructors.h>
 #include <CGAL/Path_on_surface.h>
-#include <CGAL/Path_on_surface_with_rle.h>
+#include <CGAL/Surface_mesh_topology/internal/Path_on_surface_with_rle.h>
 
 #include <iostream>
 
 ///////////////////////////////////////////////////////////////////////////////
 typedef CGAL::Combinatorial_map<2> CMap;
 typedef CGAL::Linear_cell_complex_for_combinatorial_map<2,3> LCC_3;
+using namespace CGAL::Surface_mesh_topology;
 ///////////////////////////////////////////////////////////////////////////////
 bool basic_tests()
 {
@@ -15,7 +16,7 @@ bool basic_tests()
   CMap cmap;
   cmap.make_combinatorial_hexahedron();
 
-  CGAL::Path_on_surface<CMap> p1(cmap);
+  Path_on_surface<CMap> p1(cmap);
   p1.initialize_random_starting_dart();
   p1.extend_straight_positive(3);
   if (!p1.is_valid() || p1.length()!=4 || !p1.is_closed() || !p1.is_simple())
@@ -25,14 +26,14 @@ bool basic_tests()
     res=false;
   }
 
-  CGAL::Path_on_surface<CMap> p2(p1);
+  Path_on_surface<CMap> p2(p1);
   if (p1!=p2 || !p1.are_paths_equals(p2))
   {
     std::cerr<<"path_tests ERROR: p1!=p2 || !p1.are_paths_equals(p2)."<<std::endl;
     res=false;
   }
 
-  CGAL::Path_on_surface<CMap> p3(cmap);
+  Path_on_surface<CMap> p3(cmap);
   p3.push_back(cmap.beta<2>(p1.front()));
   p3.extend_straight_negative(3);
   if (p3.length()!=4 || !p3.is_closed())
@@ -58,7 +59,7 @@ bool basic_tests()
     res=false;
   }
 
-  CGAL::Path_on_surface<CMap> p4(p3);
+  Path_on_surface<CMap> p4(p3);
   p4.reverse();
   if (p3!=p4 || !p3.are_paths_equals(p4))
   {
@@ -66,7 +67,7 @@ bool basic_tests()
     res=false;
   }
 
-  CGAL::Path_on_surface<CMap> p5(cmap);
+  Path_on_surface<CMap> p5(cmap);
   p5.push_back(cmap.beta<2>(p1.front()));
   for (int i=0; i<3; ++i)
   { p5.extend_positive_turn(); }
@@ -79,7 +80,7 @@ bool basic_tests()
 
   p1.push_around_face(0);
 
-  CGAL::Path_on_surface<CMap> p6(cmap);
+  Path_on_surface<CMap> p6(cmap);
   p6.push_back(p1.front());
   p6.extend_straight_positive(2);
   p6.extend_positive_turn(1);
@@ -90,21 +91,21 @@ bool basic_tests()
     res=false;
   }
 
-  CGAL::Path_on_surface_with_rle<CMap> p7(p6);
+  internal::Path_on_surface_with_rle<CMap> p7(p6);
   if (!p7.is_valid() || p7.size_of_list()!=2)
   {
     std::cerr<<"path_tests ERROR: !p7.is_valid() || size_of_list()!=2."<<std::endl;
     res=false;
   }
 
-  CGAL::Path_on_surface<CMap> p8(p7);
+  Path_on_surface<CMap> p8(p7);
   if (!p8.is_valid() || p6!=p8 || !p6.are_paths_equals(p8))
   {
     std::cerr<<"path_tests ERROR: !p8.is_valid() || p6!=p8 || !p6.are_paths_equals(p8)."<<std::endl;
     res=false;
   }
 
-  CGAL::Path_on_surface<CMap> p9(cmap);
+  Path_on_surface<CMap> p9(cmap);
   p9.push_back(p1.front());
   if (!p9.can_be_pushed(cmap.beta<1,2,1>(p9.back()))) // 1st
   {

Surface_mesh_topology/test/Surface_mesh_topology/path_with_rle_deformation_tests.cpp

@@ -1,8 +1,8 @@
 #include <CGAL/Linear_cell_complex_for_combinatorial_map.h>
 #include <CGAL/Linear_cell_complex_constructors.h>
-#include <CGAL/Path_generators.h>
 #include <CGAL/Path_on_surface.h>
-#include <CGAL/Path_on_surface_with_rle.h>
+#include <CGAL/Surface_mesh_topology/internal/Path_generators.h>
+#include <CGAL/Surface_mesh_topology/internal/Path_on_surface_with_rle.h>
 #include <vector>
 #include <sstream>
 
@@ -42,15 +42,17 @@ enum Transformation // enum for the type of transformations
   FULL_SIMPLIFICATION
 };
 
+using namespace CGAL::Surface_mesh_topology;
+
 ///////////////////////////////////////////////////////////////////////////////
-void transform_path(CGAL::Path_on_surface<LCC_3_cmap>& path, Transformation t,
+void transform_path(Path_on_surface<LCC_3_cmap>& path, Transformation t,
                     bool use_only_positive,
                     bool use_only_negative,
                     bool draw=false,
                     std::size_t repeat=0) // If 0, repeat as long as there is one modifcation;
                                            // otherwise repeat the given number of times
 {
-  std::vector<CGAL::Path_on_surface<LCC_3_cmap> > v;
+  std::vector<Path_on_surface<LCC_3_cmap> > v;
 #ifdef CGAL_USE_BASIC_VIEWER
   if (draw)
   {
@@ -59,15 +61,15 @@ void transform_path(CGAL::Path_on_surface<LCC_3_cmap>& path, Transformation t,
   }
 #endif // CGAL_USE_BASIC_VIEWER
 
-  CGAL::Path_on_surface<LCC_3_cmap> prevp=path;
+  Path_on_surface<LCC_3_cmap> prevp=path;
-  CGAL::Path_on_surface_with_rle<LCC_3_cmap> curp(path.get_map());
+  internal::Path_on_surface_with_rle<LCC_3_cmap> curp(path.get_map());
   std::size_t nb=0;
   bool modified=false;
   do
   {
-    curp=CGAL::Path_on_surface_with_rle<LCC_3_cmap>(prevp,
+    curp=internal::Path_on_surface_with_rle<LCC_3_cmap>(prevp,
-                                                    use_only_positive,
+                                                        use_only_positive,
-                                                    use_only_negative);
+                                                        use_only_negative);
     modified=false;
     /* curp->display_negative_turns();
     std::cout<<"  "; curp->display_positive_turns();
@@ -87,7 +89,7 @@ void transform_path(CGAL::Path_on_surface<LCC_3_cmap>& path, Transformation t,
 
     if (modified)
     {
-      prevp=CGAL::Path_on_surface<LCC_3_cmap>(curp);
+      prevp=Path_on_surface<LCC_3_cmap>(curp);
 #ifdef CGAL_USE_BASIC_VIEWER
       if (draw) { v.push_back(prevp); }
 #endif // CGAL_USE_BASIC_VIEWER
@@ -115,7 +117,7 @@ void transform_path(CGAL::Path_on_surface<LCC_3_cmap>& path, Transformation t,
   path.swap(prevp);
 }
 ///////////////////////////////////////////////////////////////////////////////
-bool unit_test(CGAL::Path_on_surface<LCC_3_cmap>& path, Transformation t,
+bool unit_test(Path_on_surface<LCC_3_cmap>& path, Transformation t,
                std::size_t repeat,
                const char* msg, const char* expected_result,
                bool draw, int testtorun,
@@ -163,7 +165,7 @@ bool test_all_cases_spurs_and_bracket(bool draw, int testtorun)
     return false;
   }
 
-  CGAL::Path_on_surface<LCC_3_cmap> path(lcc);
+  Path_on_surface<LCC_3_cmap> path(lcc);
 
   generate_one_positive_spur(path); // Test 0
   if (!unit_test(path, REDUCTION, 1, "Positive spur (2^6 1 0 2^4)",
@@ -236,7 +238,7 @@ bool test_all_cases_l_shape(bool draw, int testtorun)
     std::cout<<"PROBLEM reading file ./data/cube-mesh-5-5.off"<<std::endl;
     return false;
   }
-  CGAL::Path_on_surface<LCC_3_cmap> path(lcc);
+  Path_on_surface<LCC_3_cmap> path(lcc);
 
   generate_one_l_shape(path); // Test 9
   if (!unit_test(path, PUSH, 1, "L-shape (-2^2 -3 -2^8 -1 -2^5 -3 -2^3)",
@@ -325,29 +327,29 @@ bool test_some_random_paths_on_cube(bool draw, int testtorun)
     return false;
   }
 
-  CGAL::Path_on_surface<LCC_3_cmap> path(lcc);
+  Path_on_surface<LCC_3_cmap> path(lcc);
   bool res=true;
 
   CGAL::Random random(nbtests); // fix seed
-  generate_random_positive_bracket(path, 2, 6, 3, random); // Test 17
+  internal::generate_random_positive_bracket(path, 2, 6, 3, random); // Test 17
   if (!unit_test(path, FULL_SIMPLIFICATION, 0, "(2^1 1 2^6 1 2^3 ... )",
                  "2 2 2 2 2 2 1", draw, testtorun, true, false))
   { res=false; }
 
   random=CGAL::Random(nbtests);
-  generate_random_positive_bracket(path, 3, 8, 4, random); // Test 18
+  internal::generate_random_positive_bracket(path, 3, 8, 4, random); // Test 18
   if (!unit_test(path, FULL_SIMPLIFICATION, 0, "(2^2 1 2^8 1 2^4 ... )",
                    "2 1 2 2 2 2 2", draw, testtorun, true, false))
   { res=false; }
 
   random=CGAL::Random(nbtests);
-  generate_random_positive_bracket(path, 5, 12, 8, random); // Test 19
+  internal::generate_random_positive_bracket(path, 5, 12, 8, random); // Test 19
   if (!unit_test(path, FULL_SIMPLIFICATION, 0, "(2^4 1 2^12 1 2^8 ...)",
                  "2 1 2", draw, testtorun, true, false))
   { res=false; }
 
   random=CGAL::Random(nbtests);
-  generate_random_positive_bracket(path, 5, 12, 8, random); // Test 20
+  internal::generate_random_positive_bracket(path, 5, 12, 8, random); // Test 20
   if (!unit_test(path, FULL_SIMPLIFICATION, 0, "(2^4 1 2^12 1 2^8 ...)",
                    "1 2 2 2", draw, testtorun, true, false))
   { res=false; }

Surface_mesh_topology/test/Surface_mesh_topology/test_homotopy.cpp

@@ -2,7 +2,7 @@
 #include <CGAL/Linear_cell_complex_for_generalized_map.h>
 #include <CGAL/Linear_cell_complex_constructors.h>
 #include <CGAL/Curves_on_surface_topology.h>
-#include <CGAL/Path_generators.h>
+#include <CGAL/Surface_mesh_topology/internal/Path_generators.h>
 #include <vector>
 #include <sstream>
 
@@ -36,9 +36,11 @@ typedef CGAL::Linear_cell_complex_for_combinatorial_map<2, 3,
 static int nbtests=0;
 static int starting_seed;
 
+using namespace CGAL::Surface_mesh_topology;
+
 ///////////////////////////////////////////////////////////////////////////////
-bool unit_test_canonize(CGAL::Curves_on_surface_topology<LCC_3_cmap>& cst,
+bool unit_test_canonize(Curves_on_surface_topology<LCC_3_cmap>& cst,
-                        std::vector<CGAL::Path_on_surface<LCC_3_cmap> >& paths,
+                        std::vector<Path_on_surface<LCC_3_cmap> >& paths,
                         const char* msg,
                         bool draw, int testtorun)
 {
@@ -82,7 +84,7 @@ bool unit_test_canonize(CGAL::Curves_on_surface_topology<LCC_3_cmap>& cst,
 bool test_double_torus_quad(bool draw, int testtorun)
 {
   bool res=true;
-  std::vector<CGAL::Path_on_surface<LCC_3_cmap> > paths;
+  std::vector<Path_on_surface<LCC_3_cmap> > paths;
 
   // Test 0 (double torus, three G1 cycles)
   {
@@ -92,11 +94,11 @@ bool test_double_torus_quad(bool draw, int testtorun)
       std::cout<<"PROBLEM reading file ./data/double-torus.off"<<std::endl;
       return false;
     }
-    CGAL::Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
+    Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
 
     for (unsigned int i=0; i<3; ++i)
     {
-      CGAL::Path_on_surface<LCC_3_cmap> p(lcc);
+      Path_on_surface<LCC_3_cmap> p(lcc);
       CGAL::generate_g1_double_torus(p, i);
       paths.push_back(p);
     }
@@ -116,14 +118,14 @@ bool test_double_torus_quad(bool draw, int testtorun)
       std::cout<<"PROBLEM reading file ./data/double-torus.off"<<std::endl; // ./data/double-torus-smooth.off"<<std::endl;
       return false;
     }
-    CGAL::Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
+    Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
 
     if (testtorun==-1 || nbtests==testtorun)
     {
       CGAL::Random random(starting_seed+nbtests);
-      CGAL::Path_on_surface<LCC_3_cmap> p(lcc);
+      Path_on_surface<LCC_3_cmap> p(lcc);
 
-      generate_random_closed_path(p, random.get_int(5, 20), random); // random path, length between 30 and 500
+      internal::generate_random_closed_path(p, random.get_int(5, 20), random); // random path, length between 5 and 20
       paths.push_back(p);
 
       p.update_path_randomly(random);
@@ -148,14 +150,14 @@ bool test_double_torus_quad(bool draw, int testtorun)
       std::cout<<"PROBLEM reading file ./data/3torus-smooth.off"<<std::endl; // 3torus.off
       return false;
     }
-    CGAL::Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
+    Curves_on_surface_topology<LCC_3_cmap> cst(lcc);
 
     if (testtorun==-1 || nbtests==testtorun)
     {
       CGAL::Random random(starting_seed+nbtests);
-      CGAL::Path_on_surface<LCC_3_cmap> p(lcc);
+      Path_on_surface<LCC_3_cmap> p(lcc);
 
-      generate_random_closed_path(p, random.get_int(5, 200), random); // random path, length between 30 and 500
+      internal::generate_random_closed_path(p, random.get_int(5, 200), random); // random path, length between 5 and 200
       paths.push_back(p);
 
       p.update_path_randomly(random);