IO doc fixes

BGL/doc/BGL/PackageDescription.txt

@@ -495,7 +495,7 @@ the requirement for traversal of all faces in a graph.
 /// I/O Functions for \ref IOStreamWRL
 /// \ingroup PkgBGLIOFct
 
-/// \defgroup PkgBGLIOFuncs3MF 3MF I/O Functions
+/// \defgroup PkgBGLIoFuncs3MF 3MF I/O Functions
 /// I/O Functions for \ref IOStream3MF
 /// \ingroup PkgBGLIOFct
 

BGL/include/CGAL/boost/graph/IO/3MF.h

@@ -13,10 +13,12 @@
 #define CGAL_BGL_IO_3MF_H
 
 #include <CGAL/IO/3MF.h>
+#include <CGAL/IO/helpers.h>
 
 #include <CGAL/boost/graph/iterator.h>
 
 #include <boost/property_map/property_map.hpp>
+#include <boost/utility/enable_if.hpp>
 
 #include <string>
 #include <unordered_map>
@@ -31,7 +33,7 @@ namespace CGAL {
 // Write
 
 /*!
- * \ingroup PkgBGLIOFuncs3MF
+ * \ingroup PkgBGLIoFuncs3MF
  *
  * \brief writes the triangle meshes contained in `gs` into the 3mf file `filename`.
  *
@@ -53,9 +55,15 @@ namespace CGAL {
 template<typename GraphRange>
 bool write_3MF(const std::string& filename,
                const GraphRange& gs,
-               const std::vector<std::string>& names)
+               const std::vector<std::string>& names
+#ifndef DOXYGEN_RUNNING
+               , typename boost::disable_if<
+                   IO::internal::is_Point_set_or_Range_or_Iterator<
+                     typename boost::range_value<GraphRange>::type> >::type* = nullptr
+#endif
+               )
 {
-  typedef typename GraphRange::value_type                                       FaceGraph;
+  typedef typename boost::range_value<GraphRange>::type                         FaceGraph;
   typedef typename boost::property_map<FaceGraph, boost::vertex_point_t>::type  VPM;
   typedef typename boost::property_traits<VPM>::value_type                      Point;
 
@@ -99,7 +107,7 @@ bool write_3MF(const std::string& filename,
     all_polygons.push_back(triangles);
   }
 
-  return write_triangle_soups_to_3mf(filename, all_points, all_polygons, names);
+  return write_3MF(filename, all_points, all_polygons, names);
 }
 
 } // namespace CGAL

BGL/include/CGAL/boost/graph/IO/GOCAD.h

@@ -131,6 +131,8 @@ bool read_GOCAD(std::istream& is,
   return true;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_GOCAD(std::istream& is, Graph& g, const CGAL_BGL_NP_CLASS& np, bool verbose = true)
 {
@@ -144,6 +146,8 @@ bool read_GOCAD(std::istream& is, std::pair<std::string, std::string>& name_and_
   return read_GOCAD(is, name_and_color, g, parameters::all_default());
 }
 
+/// \endcond
+
 /// \ingroup PkgBGLIoFuncsGOCAD
 ///
 /// \brief reads the graph `g` from the file `fname`, using the \ref IOStreamGocad.
@@ -186,6 +190,8 @@ bool read_GOCAD(const char* fname,
   return read_GOCAD(is, name_and_color, g, np, verbose);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_GOCAD(const char* fname, Graph& g, const CGAL_BGL_NP_CLASS& np, bool verbose = true)
 {
@@ -206,6 +212,8 @@ bool read_GOCAD(const char* fname, Graph& g) { return read_GOCAD(fname, g, param
 template <typename Graph>
 bool read_GOCAD(const std::string& fname, Graph& g) { return read_GOCAD(fname, g, parameters::all_default()); }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -349,12 +357,16 @@ bool write_GOCAD(const char* fname,
   return write_GOCAD(os, fname, g, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_GOCAD(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np)
 {
   return write_GOCAD(fname.c_str(), g, np);
 }
 
+/// \endcond
+
 /// \ingroup PkgBGLIoFuncsGOCAD
 ///
 /// \brief writes the graph `g` in the  \ref IOStreamGocad into `os`.
@@ -393,6 +405,9 @@ bool write_GOCAD(std::ostream& os,
 {
   return write_GOCAD(os, "anonymous", g, np);
 }
+
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool write_GOCAD(std::ostream& os, const Graph& g)
 {
@@ -404,6 +419,8 @@ bool write_GOCAD(const char* fname, const Graph& g) { return write_GOCAD(fname,
 template <typename Graph>
 bool write_GOCAD(const std::string& fname, const Graph& g) { return write_GOCAD(fname, g, parameters::all_default()); }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_BGL_IO_GOCAD_H

BGL/include/CGAL/boost/graph/IO/INP.h

@@ -23,6 +23,8 @@
 
 namespace CGAL {
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_INP(std::ostream& os,
                const std::string& name,
@@ -94,6 +96,8 @@ bool write_INP(const char* fname, const std::string& type, const Graph& g)
   return write_INP(fname, type, g, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_BGL_IO_INP_H

BGL/include/CGAL/boost/graph/IO/OBJ.h

@@ -164,11 +164,10 @@ bool read_OBJ(const char* fname,
   return read_OBJ(in, g, np, verbose);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_OBJ(const std::string& fname,
+bool read_OBJ(const std::string& fname, Graph& g, const CGAL_BGL_NP_CLASS& np, bool verbose = true)
-              Graph& g,
-              const CGAL_BGL_NP_CLASS& np,
-              bool verbose = true)
 {
   return read_OBJ(fname.c_str(), g, np, verbose);
 }
@@ -180,6 +179,8 @@ bool read_OBJ(const char* fname, Graph& g) { return read_OBJ(fname, g, parameter
 template <typename Graph>
 bool read_OBJ(const std::string& fname, Graph& g) { return read_OBJ(fname, g, parameters::all_default()); }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -264,6 +265,8 @@ bool write_OBJ(const char* fname,
   return write_OBJ(os, g, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_OBJ(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np)
 {
@@ -277,6 +280,8 @@ bool write_OBJ(const char* fname, const Graph& g) { return write_OBJ(fname, g, p
 template <typename Graph>
 bool write_OBJ(const std::string& fname, const Graph& g) { return write_OBJ(fname, g, parameters::all_default()); }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_BGL_IO_OBJ_H

BGL/include/CGAL/boost/graph/IO/OFF.h

@@ -161,6 +161,8 @@ bool read_OFF(std::istream& is,
   return IO::internal::read_OFF_BGL(is, g, np, verbose);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool read_OFF(std::istream& is, Graph& g,
               typename boost::disable_if<IO::internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
@@ -168,6 +170,8 @@ bool read_OFF(std::istream& is, Graph& g,
   return read_OFF(is, g, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
   \ingroup PkgBGLIoFuncsOFF
 
@@ -245,6 +249,8 @@ bool read_OFF(const char* fname,
   return read_OFF(is, g, np, verbose);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool read_OFF(const char* fname, Graph& g,
               typename boost::disable_if<IO::internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
@@ -266,6 +272,8 @@ bool read_OFF(const std::string& fname, Graph& g,
   return read_OFF(fname, g, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!
@@ -385,6 +393,8 @@ bool write_OFF(std::ostream& os,
   return IO::internal::write_OFF_BGL(os, g, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool write_OFF(std::ostream& os, const Graph& g,
                typename boost::disable_if<IO::internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
@@ -392,6 +402,8 @@ bool write_OFF(std::ostream& os, const Graph& g,
   return write_OFF(os, g, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
   \ingroup PkgBGLIoFuncsOFF
 
@@ -472,6 +484,8 @@ bool write_OFF(const char* fname,
   return write_OFF(os, g, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool write_OFF(const char* fname, const Graph& g,
                typename boost::disable_if<IO::internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
@@ -493,6 +507,8 @@ bool write_OFF(const std::string& fname, const Graph& g,
   return write_OFF(fname.c_str(), g, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!

BGL/include/CGAL/boost/graph/IO/PLY.h

@@ -145,6 +145,8 @@ bool read_PLY(std::istream& is,
   return IO::internal::read_PLY_BGL(is, g, np, verbose);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool read_PLY(std::istream& is, Graph& g,
               typename boost::disable_if<IO::internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
@@ -152,6 +154,8 @@ bool read_PLY(std::istream& is, Graph& g,
   return IO::internal::read_PLY_BGL(is, g, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
   \ingroup PkgBGLIoFuncsPLY
 
@@ -233,6 +237,8 @@ bool read_PLY(const char* fname,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool read_PLY(const char* fname, Graph& g,
               typename boost::disable_if<IO::internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
@@ -254,6 +260,8 @@ bool read_PLY(const std::string& fname, Graph& g,
   return read_PLY(fname.c_str(), g, parameters::all_default());
 }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -437,6 +445,8 @@ bool write_PLY(std::ostream& os,
   return os.good();
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool write_PLY(std::ostream& os, const Graph& g, const std::string& comments,
                typename boost::disable_if<IO::internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
@@ -458,6 +468,8 @@ bool write_PLY(std::ostream& os, const Graph& g,
   return write_PLY(os, g, std::string(), parameters::all_default());
 }
 
+/// \endcond
+
 /*!
  \ingroup PkgBGLIoFuncsPLY
 
@@ -542,6 +554,8 @@ bool write_PLY(const char* fname,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool write_PLY(const char* fname, const Graph& g, const std::string comments,
                typename boost::disable_if<IO::internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
@@ -591,6 +605,8 @@ bool write_PLY(const std::string& fname, const Graph& g,
   return write_PLY(fname.c_str(), g, std::string(), parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_BGL_IO_PLY_H

BGL/include/CGAL/boost/graph/IO/STL.h

@@ -151,6 +151,8 @@ bool read_STL(const char* fname, Graph& g, const CGAL_BGL_NP_CLASS& np,
   return read_STL(is, g, np, verbose);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_STL(const std::string& fname, Graph& g, const CGAL_BGL_NP_CLASS& np,
               bool verbose = true)
@@ -165,6 +167,8 @@ bool read_STL(const char* fname, Graph& g) { return read_STL(fname, g, parameter
 template <typename Graph>
 bool read_STL(const std::string& fname, Graph& g) { return read_STL(fname, g, parameters::all_default()); }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -327,6 +331,8 @@ bool write_STL(const char* fname, const Graph& g, const CGAL_BGL_NP_CLASS& np)
   return write_STL(os, g, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_STL(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np)
 {
@@ -340,6 +346,8 @@ bool write_STL(const char* fname, const Graph& g) { return write_STL(fname, g, p
 template <typename Graph>
 bool write_STL(const std::string& fname, const Graph& g) { return write_STL(fname, g, parameters::all_default()); }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_BGL_IO_STL_H

BGL/include/CGAL/boost/graph/IO/VTK.h

@@ -164,6 +164,8 @@ bool read_VTP(const char* fname,
   return IO::internal::vtkPointSet_to_polygon_mesh(data, g, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template<typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_VTP(const std::string& fname, Graph& g, const CGAL_BGL_NP_CLASS& np)
 {
@@ -174,6 +176,8 @@ bool read_VTP(const char* fname, Graph& g) { return read_VTP(fname, g, parameter
 template<typename Graph>
 bool read_VTP(const std::string& fname, Graph& g) { return read_VTP(fname, g, parameters::all_default()); }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -529,6 +533,8 @@ bool write_VTP(const char* fname, const Graph& g, const CGAL_BGL_NP_CLASS& np)
   return write_VTP(os, g, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template<typename Graph>
 bool write_VTP(std::ostream& os, const Graph& g) { return write_VTP(os, g, CGAL::parameters::all_default()); }
 template<typename Graph>
@@ -538,6 +544,8 @@ bool write_VTP(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS
 template<typename Graph>
 bool write_VTP(const std::string& fname, const Graph& g) { return write_VTP(fname, g, parameters::all_default()); }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!

BGL/include/CGAL/boost/graph/IO/polygon_mesh_io.h

@@ -160,6 +160,8 @@ bool read_polygon_mesh(const std::string& fname,
   return false;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <class Graph>
 bool read_polygon_mesh(const std::string& fname, Graph& g)
 {
@@ -178,6 +180,8 @@ bool read_polygon_mesh(const char* fname, Graph& g)
   return read_polygon_mesh(fname, g, parameters::all_default());
 }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -269,6 +273,8 @@ bool write_polygon_mesh(const std::string& fname,
   return false;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <class Graph>
 bool write_polygon_mesh(const std::string& fname, Graph& g)
 {
@@ -287,6 +293,8 @@ bool write_polygon_mesh(const char* fname, Graph& g)
   return write_polygon_mesh(fname, g, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_BOOST_GRAPH_POLYGON_MESH_IO_H

BGL/test/BGL/test_3mf_to_sm.cpp

@@ -38,7 +38,7 @@ int main(int argc, char** argv)
   std::vector<Mesh> meshes;
 
   //testing reading functions.
-  int nb_meshes = CGAL::read_3mf(filename, meshes);
+  int nb_meshes = CGAL::read_3MF(filename, meshes);
 
   if(nb_meshes <0)
     return 1;

Mesh_3/doc/Mesh_3/Mesh_3.txt

@@ -550,11 +550,9 @@ for more details.
 \section Mesh_3_section_io Input/Output
 Several formats are supported for writing a mesh:
  - VTU, with `CGAL::output_to_vtu()`
- - Avizo with `CGAL::output_to_avizo()`
+ - Avizo, with `CGAL::output_to_avizo()`
- - Medit with `CGAL::output_to_medit()`
+ - Medit, with `CGAL::output_to_medit()`
- - Tetgen with `CGAL::output_to_tetgen()`
+ - Tetgen, with `CGAL::output_to_tetgen()`
-
-
 
 \section Mesh_3_section_examples Examples
 

Point_set_3/include/CGAL/Point_set_3/IO.h

@@ -124,12 +124,16 @@ bool read_point_set(const std::string& filename,
   return false;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool read_point_set(const char* filename, CGAL::Point_set_3<Point, Vector>& ps)
 {
   return read_point_set(std::string(filename), ps);
 }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -209,6 +213,8 @@ bool write_point_set(const std::string& filename,
   return false;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_point_set(const char* filename,
                      CGAL::Point_set_3<Point, Vector>& ps,
@@ -229,6 +235,8 @@ bool write_point_set(const std::string& filename, CGAL::Point_set_3<Point, Vecto
   return write_point_set(filename.c_str(), ps, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_POINT_SET_3_IO

Point_set_3/include/CGAL/Point_set_3/IO/LAS.h

@@ -171,12 +171,16 @@ bool read_LAS(const char* fname, CGAL::Point_set_3<Point, Vector>& point_set)
   return read_LAS(is, point_set);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool read_LAS(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point_set)
 {
   return read_LAS(fname.c_str(), point_set);
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!
@@ -395,12 +399,16 @@ bool write_LAS(std::ostream& os,
   return okay;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool write_LAS(std::ostream& os, CGAL::Point_set_3<Point, Vector>& point_set)
 {
   return write_LAS(os, point_set, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
   \ingroup PkgPointSet3IOLAS
 
@@ -431,6 +439,8 @@ bool write_LAS(const char* fname, CGAL::Point_set_3<Point, Vector>& point_set, c
   return write_LAS(os, point_set, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool write_LAS(const char* fname, CGAL::Point_set_3<Point, Vector>& point_set)
 {
@@ -450,6 +460,8 @@ bool write_LAS(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point
   return write_LAS(fname.c_str(), point_set, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!

Point_set_3/include/CGAL/Point_set_3/IO/OFF.h

@@ -97,12 +97,16 @@ bool read_OFF(const char* fname, CGAL::Point_set_3<Point, Vector>& point_set)
   return read_OFF(is, point_set);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool read_OFF(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point_set)
 {
   return read_OFF(fname.c_str(), point_set);
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!
@@ -161,12 +165,16 @@ bool write_OFF(std::ostream& os,
                                                          np.point_map(point_set.point_map()));
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool write_OFF(std::ostream& os, const CGAL::Point_set_3<Point, Vector>& point_set)
 {
   return write_OFF(os, point_set, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
   \ingroup PkgPointSet3IOOFF
 
@@ -197,6 +205,8 @@ bool write_OFF(const char* fname, const CGAL::Point_set_3<Point, Vector>& point_
   return write_OFF(os, point_set, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool write_OFF(const char* fname, const CGAL::Point_set_3<Point, Vector>& point_set)
 {
@@ -216,6 +226,8 @@ bool write_OFF(const std::string& fname, const CGAL::Point_set_3<Point, Vector>&
   return write_OFF(fname.c_str(), point_set, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!

Point_set_3/include/CGAL/Point_set_3/IO/PLY.h

@@ -299,6 +299,8 @@ bool read_PLY(std::istream& is,
   return !is.bad();
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool read_PLY(std::istream& is, CGAL::Point_set_3<Point, Vector>& point_set)
 {
@@ -306,6 +308,8 @@ bool read_PLY(std::istream& is, CGAL::Point_set_3<Point, Vector>& point_set)
   return read_PLY(is, point_set, dummy);
 }
 
+/// \endcond
+
 /*!
   \ingroup PkgPointSet3IOPLY
 
@@ -362,6 +366,8 @@ bool read_PLY(const char* fname,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool read_PLY(const char* fname, CGAL::Point_set_3<Point, Vector>& point_set, std::string& comments)
 {
@@ -402,6 +408,8 @@ bool read_PLY(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point_
   return read_PLY(fname.c_str(), point_set, unused_comments, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!
@@ -694,6 +702,8 @@ bool write_PLY(std::ostream& os,
   return true;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_PLY(std::ostream& os, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np)
 {
@@ -712,6 +722,8 @@ bool write_PLY(std::ostream& os, const CGAL::Point_set_3<Point, Vector>& point_s
   return write_PLY(os, point_set, std::string(), parameters::all_default());
 }
 
+/// \endcond
+
 /*!
   \ingroup PkgPointSet3IOPLY
 
@@ -770,6 +782,8 @@ bool write_PLY(const char* fname,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool write_PLY(const char* fname, const CGAL::Point_set_3<Point, Vector>& point_set, const std::string& comments)
 {
@@ -813,6 +827,8 @@ bool write_PLY(const std::string& fname, const CGAL::Point_set_3<Point, Vector>&
   return write_PLY(fname.c_str(), point_set, std::string(), parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!

Point_set_3/include/CGAL/Point_set_3/IO/XYZ.h

@@ -96,12 +96,16 @@ bool read_XYZ(const char* fname, CGAL::Point_set_3<Point, Vector>& point_set)
   return read_XYZ(is, point_set);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool read_XYZ(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point_set)
 {
   return read_XYZ(fname.c_str(), point_set);
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!
@@ -158,12 +162,16 @@ bool write_XYZ(std::ostream& os,
   return Point_set_processing_3::internal::write_XYZ_PSP(os, point_set, np.point_map(point_set.point_map()));
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool write_XYZ(std::ostream& os, const CGAL::Point_set_3<Point, Vector>& point_set)
 {
   return write_XYZ(os, point_set, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
   \ingroup PkgPointSet3IOXYZ
 
@@ -194,6 +202,8 @@ bool write_XYZ(const char* fname, const CGAL::Point_set_3<Point, Vector>& point_
   return write_XYZ(os, point_set, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Point, typename Vector>
 bool write_XYZ(const char* fname, const CGAL::Point_set_3<Point, Vector>& point_set)
 {
@@ -213,6 +223,8 @@ bool write_XYZ(const std::string& fname, const CGAL::Point_set_3<Point, Vector>&
   return write_XYZ(fname.c_str(), point_set, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!

Point_set_processing_3/include/CGAL/IO/read_las_points.h

@@ -403,6 +403,8 @@ bool read_LAS_with_properties(std::istream& is,
 
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIterator,
           typename ... PropertyHandler>
 bool read_LAS_with_properties(std::istream& is,
@@ -414,6 +416,8 @@ bool read_LAS_with_properties(std::istream& is,
   return read_LAS_with_properties<OutputValueType>(is, output, std::forward<PropertyHandler>(properties)...);
 }
 
+/// \endcond
+
 /**
    \ingroup PkgPointSetProcessing3IOLas
 
@@ -466,6 +470,8 @@ bool read_LAS(std::istream& is,
   return read_LAS_with_properties(is, output, make_las_point_reader(point_map));
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_LAS(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np,
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
@@ -487,6 +493,8 @@ bool read_LAS(std::istream& is, OutputIterator output,
   return read_LAS<typename value_type_traits<OutputIterator>::type>(is, output, parameters::all_default());
 }
 
+/// \endcond
+
 /**
    \ingroup PkgPointSetProcessing3IOLas
 
@@ -531,6 +539,8 @@ bool read_LAS(const char* filename,
   return read_LAS<OutputIteratorValueType>(filename, output, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_LAS(const char* fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np)
 {
@@ -574,8 +584,12 @@ bool read_LAS(const std::string& fname, OutputIterator output)
   return read_LAS<typename value_type_traits<OutputIterator>::type>(fname, output, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIteratorValueType,
           typename OutputIterator,
           typename PointMap >
@@ -598,9 +612,8 @@ bool read_las_points(std::istream& is, ///< input stream.
                                                                            CGAL::parameters::point_map(point_map));
 }
 
-#endif //CGAL_NO_DEPRECATED_CODE
+/// \endcond
 
-#ifndef CGAL_NO_DEPRECATED_CODE
 /**
  \ingroup PkgPointSetProcessing3IODeprecated
 
@@ -617,6 +630,7 @@ CGAL_DEPRECATED bool read_las_points_with_properties(std::istream& is,
 }
 
 /// \cond SKIP_IN_MANUAL
+
 template <typename OutputIterator,
           typename ... PropertyHandler>
 CGAL_DEPRECATED bool read_las_points_with_properties(std::istream& is,
@@ -627,6 +641,7 @@ CGAL_DEPRECATED bool read_las_points_with_properties(std::istream& is,
 
   return read_LAS<OutputValueType>(is, output, std::forward<PropertyHandler>(properties)...);
 }
+
 /// \endcond
 
 /**
@@ -652,6 +667,8 @@ CGAL_DEPRECATED bool read_las_points(std::istream& is,
   return read_LAS(is, output, make_las_point_reader(point_map));
 }
 
+/// \cond SKIP_IN_MANUAL
+
 // variant with default NP
 template <typename OutputIteratorValueType, typename OutputIterator>
 CGAL_DEPRECATED bool read_las_points(std::istream& is, OutputIterator output)
@@ -673,6 +690,8 @@ CGAL_DEPRECATED bool read_las_points(std::istream& is, OutputIterator output)
   return read_LAS<typename value_type_traits<OutputIterator>::type>(is, output, CGAL::parameters::all_default());
 }
 
+/// \endcond
+
 #endif // CGAL_NO_DEPRECATED_CODE
 
 } // namespace CGAL

Point_set_processing_3/include/CGAL/IO/read_off_points.h

@@ -254,6 +254,8 @@ bool read_OFF(const char* fname,
   return read_OFF(is, output, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIteratorValueType, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_OFF(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np,
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
@@ -330,8 +332,12 @@ bool read_OFF(const char* fname, OutputIterator output,
   return read_OFF<typename value_type_traits<OutputIterator>::type>(fname, output, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIteratorValueType,
           typename OutputIterator,
           typename PointPMap,
@@ -465,9 +471,8 @@ bool read_off_points(std::istream& is, ///< input stream.
   return read_off_points<typename value_type_traits<OutputIterator>::type>(is, output, parameters::point_map(point_map));
 }
 
-#endif // CGAL_NO_DEPRECATED_CODE
+/// \endcond
 
-#ifndef CGAL_NO_DEPRECATED_CODE
 /*!
  \ingroup PkgPointSetProcessing3IODeprecated
 
@@ -484,6 +489,8 @@ CGAL_DEPRECATED bool read_off_points(std::istream& is,
   return read_OFF(is, output, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIteratorValueType, typename OutputIterator>
 CGAL_DEPRECATED bool read_off_points(std::istream& is, OutputIterator output)
 {
@@ -504,6 +511,8 @@ CGAL_DEPRECATED bool read_off_points(std::istream& is, OutputIterator output)
   return read_OFF(is, output, CGAL::parameters::all_default());
 }
 
+/// \endcond
+
 #endif //CGAL_NO_DEPRECATED_CODE
 
 } // namespace CGAL

Point_set_processing_3/include/CGAL/IO/read_ply_points.h

@@ -100,7 +100,7 @@ make_ply_normal_reader(VectorMap normal_map);
 #endif // DOXYGEN_RUNNING
 
 /**
-  \ingroup PkgPointSetProcessingIOPly
+  \ingroup PkgPointSetProcessing3IOPly
 
   \brief reads user-selected points properties from a .ply stream (ASCII or binary).
 
@@ -179,6 +179,8 @@ bool read_PLY_with_properties(std::istream& is,
   return true;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIterator,
           typename ... PropertyHandler>
 bool read_PLY_with_properties(std::istream& is,
@@ -190,6 +192,8 @@ bool read_PLY_with_properties(std::istream& is,
   return read_PLY_with_properties<OutputValueType>(is, output, std::forward<PropertyHandler>(properties)...);
 }
 
+/// \endcond
+
 /**
    \ingroup PkgPointSetProcessing3IOPly
 
@@ -336,6 +340,8 @@ bool read_PLY(const char* fname,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIteratorValueType, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_PLY(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np,
               typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
@@ -409,8 +415,12 @@ bool read_PLY(const char* fname, OutputIterator output,
   return read_PLY<typename value_type_traits<OutputIterator>::type>(fname, output, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIteratorValueType,
           typename OutputIterator,
           typename PointMap,
@@ -479,6 +489,8 @@ bool read_ply_points(std::istream& is, ///< input stream.
   return read_PLY<typename value_type_traits<OutputIterator>::type>(is, output, parameters::point_map(point_map));
 }
 
+/// \endcond
+
 /**
  \ingroup PkgPointSetProcessing3IODeprecated
 

Point_set_processing_3/include/CGAL/IO/read_points.h

@@ -92,6 +92,8 @@ bool read_points(const std::string& fname,
   return false;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 // variant with default OutputIteratorType
 template <typename OutputIterator, typename NamedParameters>
 bool read_points(const std::string& fname, OutputIterator output, const NamedParameters& np)
@@ -139,6 +141,8 @@ bool read_points(const char* fname, OutputIterator output)
   return read_points<typename value_type_traits<OutputIterator>::type>(fname, output, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_POINT_SET_PROCESSING_READ_POINTS_H

Point_set_processing_3/include/CGAL/IO/read_xyz_points.h

@@ -306,8 +306,12 @@ bool read_XYZ(const char* fname, OutputIterator output)
   return read_XYZ<typename value_type_traits<OutputIterator>::type>(fname, output, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename OutputIteratorValueType,
           typename OutputIterator,
           typename PointPMap,
@@ -445,8 +449,6 @@ bool read_xyz_points(std::istream& is, ///< input stream.
                                                                     parameters::point_map(point_map));
 }
 
-#endif // CGAL_NO_DEPRECATED_CODE
-
 /// \endcond
 
 /**
@@ -467,8 +469,6 @@ CGAL_DEPRECATED bool read_xyz_points(std::istream& is,
   return read_XYZ(is, output, np);
 }
 
-#ifndef CGAL_NO_DEPRECATED_CODE
-
 /// \cond SKIP_IN_MANUAL
 
 template <typename OutputIteratorValueType,

Point_set_processing_3/include/CGAL/IO/write_las_points.h

@@ -358,6 +358,8 @@ bool write_LAS(const char* filename,
   return write_LAS(os, points, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_LAS(const std::string& filename, const PointRange& points, const CGAL_BGL_NP_CLASS& np,
                typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -388,8 +390,12 @@ bool write_LAS(const std::string& filename, const PointRange& points,
   return write_LAS(filename, points, CGAL::Point_set_processing_3::parameters::all_default(points));
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename ForwardIterator,
           typename PointMap>
 CGAL_DEPRECATED_MSG("you are using the deprecated V1 API of CGAL::write_las_points(), please update your code")
@@ -412,9 +418,7 @@ bool write_las_points(std::ostream& os, ///< output stream.
   return write_LAS(os, points);
 }
 
-#endif // CGAL_NO_DEPRECATED_CODE
+/// \endcond
-
-#ifndef CGAL_NO_DEPRECATED_CODE
 
 /**
   \ingroup PkgPointSetProcessing3IODeprecated

Point_set_processing_3/include/CGAL/IO/write_off_points.h

@@ -149,6 +149,8 @@ bool write_OFF(std::ostream& os,
   return Point_set_processing_3::internal::write_OFF_PSP(os, points, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange>
 bool write_OFF(std::ostream& os, const PointRange& points,
                typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -156,6 +158,8 @@ bool write_OFF(std::ostream& os, const PointRange& points,
   return write_OFF(os, points, parameters::all_default());
 }
 
+/// \endcond
+
 /**
    \ingroup PkgPointSetProcessing3IOOff
 
@@ -219,6 +223,8 @@ bool write_OFF(const char* filename,
   return write_OFF(os, points, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange>
 bool write_OFF(const char* filename, const PointRange& points,
                typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -241,8 +247,12 @@ bool write_OFF(const std::string& filename, const PointRange& points,
   return write_OFF(filename, points, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename ForwardIterator,
           typename PointMap,
           typename NormalMap,
@@ -330,9 +340,7 @@ bool write_off_points(std::ostream& os, ///< output stream.
   return write_off_points(os, points);
 }
 
-#endif // CGAL_NO_DEPRECATED_CODE
+/// \endcond
-
-#ifndef CGAL_NO_DEPRECATED_CODE
 
 /**
   \ingroup PkgPointSetProcessing3IODeprecated

Point_set_processing_3/include/CGAL/IO/write_ply_points.h

@@ -222,6 +222,8 @@ bool write_PLY(std::ostream& os,
   return write_PLY_with_properties(os, points, make_ply_point_writer(point_map));
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange>
 bool write_PLY(std::ostream& os, const PointRange& points,
                typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -229,6 +231,7 @@ bool write_PLY(std::ostream& os, const PointRange& points,
   return write_PLY(os, points, parameters::all_default());
 }
 
+/// \endcond
 
 /**
    \ingroup PkgPointSetProcessing3IOPly
@@ -305,6 +308,8 @@ bool write_PLY(const char* filename,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange>
 bool write_PLY(const char* filename, const PointRange& points,
                typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -326,8 +331,12 @@ bool write_PLY(const std::string& filename, const PointRange& points,
   return write_PLY(filename.c_str(), points, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename ForwardIterator,
           typename PointMap,
           typename VectorMap>
@@ -377,9 +386,7 @@ bool write_ply_points(std::ostream& os, ///< output stream.
   return write_PLY(os, points);
 }
 
-#endif // CGAL_NO_DEPRECATED_CODE
+/// \endcond
-
-#ifndef CGAL_NO_DEPRECATED_CODE
 
 /**
 \ingroup PkgPointSetProcessing3IODeprecated

Point_set_processing_3/include/CGAL/IO/write_points.h

@@ -104,6 +104,8 @@ bool write_points(const std::string& fname,
   return false;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_points(const char* fname, const PointRange& points, const CGAL_BGL_NP_CLASS& np,
                   typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -125,6 +127,8 @@ bool write_points(const char* fname,const PointRange& points,
   return write_points(fname, points, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_POINT_SET_PROCESSING_WRITE_POINTS_H

Point_set_processing_3/include/CGAL/IO/write_xyz_points.h

@@ -141,6 +141,8 @@ bool write_XYZ(std::ostream& os,
   return Point_set_processing_3::internal::write_XYZ_PSP(os, points, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange>
 bool write_XYZ(std::ostream& os, const PointRange& points,
                typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -148,6 +150,8 @@ bool write_XYZ(std::ostream& os, const PointRange& points,
   return write_XYZ(os, points, parameters::all_default());
 }
 
+/// \endcond
+
 /**
    \ingroup PkgPointSetProcessing3IOXyz
 
@@ -207,6 +211,8 @@ bool write_XYZ(const char* filename,
   return write_XYZ(os, points, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange>
 bool write_XYZ(const char* filename, const PointRange& points,
                typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -215,8 +221,6 @@ bool write_XYZ(const char* filename, const PointRange& points,
   return write_XYZ(os, points, parameters::all_default());
 }
 
-/// \cond SKIP_IN_MANUAL
-
 template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool write_XYZ(const std::string& filename, const PointRange& points, const CGAL_BGL_NP_CLASS& np,
                typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
@@ -231,8 +235,12 @@ bool write_XYZ(const std::string& filename, const PointRange& points,
   return write_XYZ(filename, points, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename ForwardIterator,
           typename PointMap,
           typename NormalMap,
@@ -318,12 +326,8 @@ bool write_xyz_points(std::ostream& os, ///< output stream.
   return write_XYZ(os, points);
 }
 
-#endif // CGAL_NO_DEPRECATED_CODE
-
 /// \endcond
 
-#ifndef CGAL_NO_DEPRECATED_CODE
-
 /**
   \ingroup PkgPointSetProcessing3IODeprecated
 
@@ -337,6 +341,7 @@ CGAL_DEPRECATED bool write_xyz_points(std::ostream& os, const PointRange& points
 }
 
 /// \cond SKIP_IN_MANUAL
+
 template <typename PointRange>
 CGAL_DEPRECATED bool write_xyz_points(std::ostream& os, const PointRange& points)
 {

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h

@@ -139,6 +139,8 @@ bool read_polygon_mesh(const char* fname,
   return true;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename Graph>
 bool read_polygon_mesh(const char* fname, Graph& g)
 {
@@ -157,6 +159,8 @@ bool read_polygon_mesh(const std::string& fname, Graph& g)
   return CGAL::Polygon_mesh_processing::read_polygon_mesh(fname, g, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace Polygon_mesh_processing
 } // namespace CGAL
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_mesh_to_polygon_soup.h

@@ -116,6 +116,8 @@ void polygon_mesh_to_polygon_soup(const PolygonMesh& mesh,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template<typename PolygonMesh, typename PointRange, typename PolygonRange>
 void polygon_mesh_to_polygon_soup(const PolygonMesh& mesh,
                                   PointRange& points,
@@ -124,6 +126,8 @@ void polygon_mesh_to_polygon_soup(const PolygonMesh& mesh,
   return polygon_mesh_to_polygon_soup(mesh, points, polygons, CGAL::parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace Polygon_mesh_processing
 } // namespace CGAL
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h

@@ -278,6 +278,8 @@ void polygon_soup_to_polygon_mesh(const PointRange& points,
   converter(out, vpm);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template<typename PolygonMesh, typename PointRange, typename PolygonRange>
 void polygon_soup_to_polygon_mesh(const PointRange& points,
                                   const PolygonRange& polygons,
@@ -286,6 +288,8 @@ void polygon_soup_to_polygon_mesh(const PointRange& points,
   return polygon_soup_to_polygon_mesh(points, polygons, out, parameters::all_default(), parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace Polygon_mesh_processing
 } // namespace CGAL
 

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_mesh.h

@@ -328,6 +328,7 @@ void smooth_mesh(const FaceRange& faces,
   }
 }
 
+///\cond SKIP_IN_MANUAL
 template <typename FaceRange, typename TriangleMesh>
 void smooth_mesh(const FaceRange& face_range, TriangleMesh& tmesh)
 {
@@ -346,8 +347,6 @@ void smooth_mesh(TriangleMesh& tmesh)
   smooth_mesh(faces(tmesh), tmesh, parameters::all_default());
 }
 
-
-///\cond SKIP_IN_MANUAL
 template<typename TriangleMesh, typename GeomTraits, typename Stream>
 void angles_evaluation(TriangleMesh& tmesh, GeomTraits traits, Stream& output)
 {

Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_shape.h

@@ -201,6 +201,7 @@ void smooth_shape(const FaceRange& faces,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
 template<typename TriangleMesh, typename FaceRange>
 void smooth_shape(const FaceRange& faces,
                   TriangleMesh& tmesh,
@@ -223,6 +224,7 @@ void smooth_shape(TriangleMesh& tmesh,
 {
   smooth_shape(faces(tmesh), tmesh, time, parameters::all_default());
 }
+/// \endcond
 
 } // Polygon_mesh_processing
 } // CGAL

Polyhedron/demo/Polyhedron/Plugins/IO/3mf_io_plugin.cpp

@@ -78,8 +78,8 @@ class Io_3mf_plugin:
     QList<Scene_item*> result;
     std::vector<std::vector<CGAL::Color> > all_colors;
     int nb_meshes =
-        CGAL::read_triangle_soups_from_3mf(fileinfo.filePath().toUtf8().toStdString(),
+        CGAL::read_3MF(fileinfo.filePath().toUtf8().toStdString(),
-                                  all_points, all_polygons, all_colors, names);
+                       all_points, all_polygons, all_colors, names);
     if(nb_meshes <0 )
     {
       ok = false;

Stream_support/doc/Stream_support/File_formats/Supported_file_formats.txt

@@ -9,216 +9,397 @@ this specific format.
 
 - \ref IOStreamOFF
 - \ref IOStreamOBJ
-- \ref IOStreamPLY
 - \ref IOStreamSTL
+- \ref IOStreamPLY
 - \ref IOStreamXYZ
 - \ref IOStreamVTK
+- \ref IOStreamGocad
+- \ref IOStream3MF
+- \ref IOStreamWRL
+- \ref IOStreamLAS
 - \ref IOStreamAvizo
 - \ref IOStreamMedit
 - \ref IOStreamTetgen
-- \ref IOStreamGocad
+- \ref IOStreamWKT
-- \ref IOStreamWRL
-- \ref IOStreamLAS
 
 \section IOStreamOFF Object File Format (OFF)
-The `OFF` file format can be used to represent collections of planar polygons with possibly shared vertices.
+
+The `Object File Format (OFF)` file format can be used to represent collections of planar polygons with possibly shared vertices.
 Although it can be as light as providing points and faces described by IDs, the format also allows
 users to provide more properties such as associating normals or colors to vertices.
+
 A precise specification of the format is available at <a href="http://www.geomview.org/docs/html/OFF.html">geomview.org</a>.
 
-\subsection IOStreamOFFInput Reading OFF files
+The following table lists some \cgal data structures that have I/O functions compatible with this file format.
-Objects represented in the `.OFF` format can be imported into \cgal's working environment
-using the following data structures and functions:
 
-- `CGAL::Surface_mesh` (\link PkgSurfaceMeshIOFunc read_OFF(std::istream&, Surface_mesh<Point>& sm, const NamedParameters&)\endlink), a halfedge data structure allowing to represent polyhedral surfaces
+<table class="iotable">
+  <tr>
+    <th colspan="4">Object File Format (OFF)</th>
+  </tr>
+  <tr>
+    <td rowspan="6" width="75">Input</td>
+    <td rowspan="3" width="175">Polygon Mesh</td>
+    <td width="250">`CGAL::Surface_mesh`</td>
+    <td width="500">\link PkgSurfaceMeshIOFuncOFF CGAL::read_OFF(const char*, CGAL::Surface_mesh&)\endlink</td>
+  </tr>
+  <tr>
+    <td>`CGAL::Polyhedron_3`</td>
+    <td>\link PkgPolyhedronIOFunc CGAL::read_OFF(const char*, CGAL::Polyhedron_3&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncsOFF CGAL::read_OFF(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Point Set</td>
+    <td>`CGAL::Point_set_3`</td>
+    <td>\link PkgPointSet3IOOFF CGAL::read_OFF(const char*, CGAL::Point_set_3&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any point range</td>
+    <td>\link PkgPointSetProcessing3IOOff CGAL::read_OFF(const char*, PointRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsOFF CGAL::read_OFF(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="6">Output</td>
+    <td rowspan="3">Polygon Mesh</td>
+    <td>`CGAL::Surface_mesh`</td>
+    <td>\link PkgSurfaceMeshIOFuncOFF CGAL::write_OFF(const char*, CGAL::Surface_mesh&)\endlink</td>
+  </tr>
+  <tr>
+    <td>`CGAL::Polyhedron_3`</td>
+    <td>\link PkgPolyhedronIOFunc CGAL::write_OFF(const char*, CGAL::Polyhedron_3&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncsOFF CGAL::write_OFF(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Point Set</td>
+    <td>`CGAL::Point_set_3`</td>
+    <td>\link PkgPointSet3IOOFF CGAL::write_OFF(const char*, CGAL::Point_set_3&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any point range</td>
+    <td>\link PkgPointSetProcessing3IOOff CGAL::write_OFF(const char*, PointRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsOFF CGAL::write_OFF(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+</table>
 
-- CGAL::Polyhedron_3 (\ref read_OFF( std::istream&, Polyhedron_3<PolyhedronTraits_3>&)), a halfedge data structure, which restricts the class of representable surfaces
+If the data of a polygon mesh cannot be read in a `FaceGraph` due to bad orientation or
-  to orientable 2-manifolds.
+manifoldness issues, consider using \link PMP_IO_grp `CGAL::Polygon_mesh_processing::read_polygon_mesh()` \endlink,
-
+which offers combinatorial reparation while reading bad inputs.
-- Any structure that is a model of the concept `FaceGraph` ( \link PkgBGLIOFct read_OFF(std::istream&,FaceGraph&,NamedParameters)\endlink)
-
-- `CGAL::Point_set_3` (operator>>(std::istream&,CGAL::Point_set_3<Point, Vector>&)
-
-Polygon soups can also be imported using the function read_OFF().
-
-As documented in the functions above, the only property that we support is the color,
-and it is only supported for the CGAL::Surface_mesh.
-
-\subsection IOStreamOFFOutput Writing OFF files
-The following \cgal data structures can be exported into the `OFF` file format:
-
-- `CGAL::Surface_mesh` (\link PkgSurfaceMeshIOFunc write_OFF(std::ostream&, const Surface_mesh<P>&, const NamedParameters&)\endlink)
-- Any structure that is a model of the concept `FaceGraph` (\link PkgBGLIOFct write_OFF(std::ostream&, const FaceGraph&,const NamedParameters&)\endlink)
-- `CGAL::Point_set_3` (\ref write_OFF())
-
-Polygon soups can also be exported using the function write_OFF().
-Note that we only support OFF, and COFF for CGAL::Surface_mesh.
 
 
 \section IOStreamOBJ Wavefront Advanced Visualizer Object Format (OBJ)
+
 The OBJ file format is a simple data-format that represents 3D geometry.
 Vertices are stored in a counter-clockwise order by default, making explicit declaration of face normals unnecessary.
+
 A precise specification of the format is available <a href="http://www.martinreddy.net/gfx/3d/OBJ.spec">here</a>.
 
-\subsection IOStreamOBJInput Reading OBJ files
+<table class="iotable">
-Objects represented in the `.OBJ` format can be imported into \cgal's working environment
+  <tr>
-using any structure that is a model of the concept `FaceGraph`, and the function `read_OBJ()`.
+    <th colspan="4">Wavefront Advanced Visualizer Object Format (OBJ)</th>
+  </tr>
+  <tr>
+    <td rowspan="2" width="75">Input</td>
+    <td rowspan="1" width="175">Polygon Mesh</td>
+    <td width="250">Any model of `FaceGraph`</td>
+    <td width="500">\link PkgBGLIoFuncsOBJ CGAL::read_OBJ(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsOBJ CGAL::read_OBJ(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Output</td>
+    <td rowspan="1">Polygon Mesh</td>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncsOBJ CGAL::write_OBJ(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsOBJ CGAL::write_OBJ(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+</table>
 
-Polygon soups can also be imported using the function \ref IOstreamFunctions "read_OBJ()".
+If the data of a polygon mesh cannot be read in a `FaceGraph` due to bad orientation or
-
+manifoldness issues, consider using \link PMP_IO_grp `CGAL::Polygon_mesh_processing::read_polygon_mesh()` \endlink,
-\subsection IOStreamOBJOutput Writing OBJ files
+which offers combinatorial reparation while reading bad inputs.
-Any structure that is a model of the concept `FaceGraph` can be exported into the `OBJ` file format
-using the function `write_OBJ()`.
 
 
 \section IOStreamSTL Standard Triangle Language (STL) File Format
-  STL is a file format native to the stereolithography CAD software created by
-  3D Systems.STL files describe the surface geometry of a three-dimensional object.
-  A precise specification of those formats is available at
-  <a href="http://www.fabbers.com/tech/STL_Format"> fabbers.com</a>.
 
-\subsection IOStreamSTLInput Reading STL files
+STL is a file format native to the stereolithography CAD software created by 3D Systems.
-Objects represented in the `.STL` format can be imported into \cgal's working environment
+STL files describe the surface geometry of a three-dimensional object.
-using any data structure that is a model of the `FaceGraph` concept, using \ref CGAL::read_STL();
 
-In addition, if the data cannot be read in a `FaceGraph` because of bad orientation or
+A precise specification of those formats is available
-manifoldness, the function \link IOstreamFunctions `CGAL::read_STL(std::istream&,PointRange&,TriangleRange&,bool)` \endlink
+<a href="http://www.fabbers.com/tech/STL_Format">here</a>.
-allows to load data directly in a soup of triangles. From there, you can use \ref PMPRepairing
-functions to construct a valid PolygonMesh.
 
-\subsection IOStreamSTLOutput Writing STL files
+<table class="iotable">
-Similarly, any data structure that is a model of the `FaceGraph` concept can be exported
+  <tr>
-as a `.STL` file using \link PkgBGLIOFct CGAL::write_STL(std::ostream&, const TriangleMesh&, const NamedParameters&)\endlink.
+    <th colspan="4">Standard Triangle Language (STL)</th>
-
+  </tr>
-Polygon soups can also be exported using the function \link IOstreamFunctions `CGAL::write_STL(std::ostream&, const PointRange&,const TriangleRange&)`. \endlink
+  <tr>
+    <td rowspan="2" width="75">Input</td>
+    <td rowspan="1" width="175">Polygon Mesh</td>
+    <td width="250">Any model of `FaceGraph`</td>
+    <td width="500">\link PkgBGLIoFuncsSTL CGAL::read_STL(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsSTL CGAL::read_STL(const char*, PointRange&, TriangleRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Output</td>
+    <td rowspan="1">Polygon Mesh</td>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncsSTL CGAL::write_STL(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsSTL CGAL::write_STL(const char*, PointRange&, TriangleRange&)\endlink</td>
+  </tr>
+</table>
 
 Note that the STL file format exports triangular faces as geometric triangles and thus
-lose combinatorial information.
+combinatorial information is lost.
+
+If the data of a polygon mesh cannot be read in a `FaceGraph` due to bad orientation or
+manifoldness issues, consider using \link PMP_IO_grp `CGAL::Polygon_mesh_processing::read_polygon_mesh()` \endlink,
+which offers combinatorial reparation while reading bad inputs.
 
 
 \section IOStreamPLY Polygon File Format (PLY)
+
 Conceived to store the data obtained during 3D scans, the `PLY` file format stores objects
-as a simple list of polygons, etc.
+as a simple list of polygons and is capable of storing external properties.
-A precise specification of those formats is available at
-<a href="http://paulbourke.net/dataformats/ply/"> paulbourke.net</a>.
 
-\subsection IOStreamPLYInput Reading PLY files
+A precise specification of those formats is available
-Objects represented in the `.PLY` format can be imported into \cgal's working environment
+<a href="http://paulbourke.net/dataformats/ply/">here</a>.
-using the following data structures and functions:
+
-- `CGAL::Surface_mesh` (`CGAL::read_PLY()`)
+<table class="iotable">
-- `CGAL::Point_set_3` (`operator>>(std::istream&,CGAL::Point_set_3<Point, Vector>&)`) a collection of points with dynamically associated properties
+  <tr>
+    <th colspan="4">Polygon File Format (PLY)</th>
+  </tr>
+  <tr>
+    <td rowspan="5" width="75">Input</td>
+    <td rowspan="2" width="175">Polygon Mesh</td>
+    <td width="250">`CGAL::Surface_mesh`</td>
+    <td width="500">\link PkgSurfaceMeshIOFuncPLY CGAL::read_PLY(const char*, CGAL::Surface_mesh&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncsPLY CGAL::read_PLY(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Point Set</td>
+    <td>`CGAL::Point_set_3`</td>
+    <td>\link PkgPointSet3IOPLY CGAL::read_PLY(const char*, CGAL::Point_set_3&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any point range</td>
+    <td>\link PkgPointSetProcessing3IOPly CGAL::read_PLY(const char*, PointRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsPLY CGAL::read_PLY(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="5">Output</td>
+    <td rowspan="2">Polygon Mesh</td>
+    <td>`CGAL::Surface_mesh`</td>
+    <td>\link PkgSurfaceMeshIOFuncPLY CGAL::write_PLY(const char*, CGAL::Surface_mesh&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncsPLY CGAL::write_PLY(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Point Set</td>
+    <td>`CGAL::Point_set_3`</td>
+    <td>\link PkgPointSet3IOPLY CGAL::write_PLY(const char*, CGAL::Point_set_3&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any point range</td>
+    <td>\link PkgPointSetProcessing3IOPly CGAL::write_PLY(const char*, PointRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsPLY CGAL::write_PLY(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+</table>
+
+If the data of a polygon mesh cannot be read in a `FaceGraph` due to bad orientation or
+manifoldness issues, consider using \link PMP_IO_grp `CGAL::Polygon_mesh_processing::read_polygon_mesh()` \endlink,
+which offers combinatorial reparation while reading bad inputs.
 
-\subsection IOStreamPLYOutput Writing PLY files
-The following \cgal data structures can be exported into the `PLY` file format:
-- `CGAL::Surface_mesh` (write_PLY())
-- `CGAL::Point_set_3` (operator<<(std::ostream&,const CGAL::Point_set_3<Point, Vector>&))
 
 \section IOStreamLAS LAS (Lidar) File Format
-https://www.loc.gov/preservation/digital/formats/fdd/fdd000418.shtml
+
 Similar to the \ref IOStreamPLY, but this format does not handle normals and requires the \ref thirdpartyLASlib library.
 
-\subsection IOStreamLASInput Reading LAS files
+A precise specification of those formats is available at
-Objects represented in the `.LAS` format can be imported into \cgal's working environment
+<a href="https://www.loc.gov/preservation/digital/formats/fdd/fdd000418.shtml">here</a>.
-using the following data structures and functions:
+
-- `CGAL::Point_set_3 (`CGAL::read_LAS`) a collection of points with dynamically associated properties
+<table class="iotable">
-- Point ranges
+  <tr>
+    <th colspan="4">LAS (Lidar) File Format</th>
+  </tr>
+  <tr>
+    <td rowspan="2" width="75">Input</td>
+    <td rowspan="2" width="175">Point Set</td>
+    <td width="250">`CGAL::Point_set_3`</td>
+    <td width="500">\link PkgPointSet3IOLAS CGAL::read_LAS(const char*, CGAL::Point_set_3&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any point range</td>
+    <td>\link PkgPointSetProcessing3IOLas CGAL::read_LAS(const char*, PointRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Output</td>
+    <td rowspan="2">Point Set</td>
+    <td>`CGAL::Point_set_3`</td>
+    <td>\link PkgPointSet3IOLAS CGAL::write_LAS(const char*, CGAL::Point_set_3&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any point range</td>
+    <td>\link PkgPointSetProcessing3IOLas CGAL::write_LAS(const char*, PointRange&)\endlink</td>
+  </tr>
+</table>
 
-\subsection IOStreamLASOutput Writing LAS files
-@todo also add to data structures --> formats
-The following \cgal data structures can be exported into the `LAS` file format:
-- `CGAL::Point_set_3 (`CGAL::write_LAS`) a collection of points with dynamically associated properties
-- Point ranges
 
 \section IOStreamXYZ XYZ (or PWN) File Format
-The `XYZ` format is a non standard format regularly used to described point sets.
-each line represent a point, and is composed of its coordinates and other properties.
-We only support coordinates and normals (in that case the standard extension in CGAL
-is .pwn for points with normals.)
 
-\subsection IOStreamZYZInput Reading XYZ files
+The `XYZ` format is a non-standard format regularly used to described point sets.
-Objects represented in the `.XYZ` or `.PWN` format can be imported into \cgal's working environment
+Each line represent a point, and is composed of its coordinates and other properties.
-using the `CGAL::Point_set_3` and the function `CGAL::read_point_set()`.
+We only support coordinates and normals (in that case the standard extension in \cgal
+is `.pwn` for <em>points with normals</em>.)
 
-\subsection IOStreamXYZOutput Writing XYZ files
+<table class="iotable">
-The CGAL::Point_set_3 can be exported into a `XYZ` or a `PWN` file using the function
+  <tr>
-write_xyz_point_set().
+    <th colspan="4">LAS (Lidar) File Format</th>
-
+  </tr>
-
+  <tr>
-\section IOStreamVTK VTK (VTU / VTP) File Formats
+    <td rowspan="2" width="75">Input</td>
-The VTK libraries use different file formats to handle data structures, but we only support two:
+    <td rowspan="2" width="175">Point Set</td>
-- The `VTU` format can be used to store am unordered collection of 3D cells, like tetrahedra,
+    <td width="250">`CGAL::Point_set_3`</td>
-  but also points, triangles, lines, etc. In the <a href="https://vtk.org/"> VTK Libraries</a>,
+    <td width="500">\link PkgPointSet3IOXYZ CGAL::read_XYZ(const char*, CGAL::Point_set_3&)\endlink</td>
-  it is the format reserved to store `Unstructured Grids`, and in \cgal,
+  </tr>
-  we use it to store triangulations(2D and 3D).
+  <tr>
-
+    <td>Any point range</td>
-- The `VTP` format can be used to store collections of points, lines and triangles.
+    <td>\link PkgPointSetProcessing3IOXyz CGAL::read_XYZ(const char*, PointRange&)\endlink</td>
-  In the <a href="https://vtk.org/"> VTK Libraries</a>, it is the format
+  </tr>
-  reserved to store `PolyData`., and in CGAL, we use it to store Polygon Meshes.
+  <tr>
-
+    <td rowspan="2">Output</td>
-A precise specification of those formats is available at
+    <td rowspan="2">Point Set</td>
-<a href="https://vtk.org/wp-content/uploads/2015/04/file-formats.pdf"> vtk.org</a>.
+    <td>`CGAL::Point_set_3`</td>
-
+    <td>\link PkgPointSet3IOXYZ CGAL::write_XYZ(const char*, CGAL::Point_set_3&)\endlink</td>
-\subsection IOStreamVTKInput Reading VTK files
+  </tr>
-Objects represented in the `VTP` format can be imported into \cgal's working environment
+  <tr>
-using the following data structures and functions:
+    <td>Any point range</td>
-- CGAL::Surface_mesh
+    <td>\link PkgPointSetProcessing3IOXyz CGAL::write_XYZ(const char*, PointRange&)\endlink</td>
-- CGAL::Polyhedron_3
+  </tr>
-
+</table>
-using the function \link PkgBGLIOFct CGAL::read_VTP()\endlink, in the condition that CGAL has been configured
-with the VTK libraries.
-
-\subsection IOStreamVTKOutput Writing VTK files
-The following \cgal data structures can be exported into the `.VTP` file format:
-- CGAL::Surface_mesh
-- CGAL::Polyhedron_3
-
-using the function \link PkgBGLIOFct CGAL::write_VTP()\endlink.
-
-The following \cgal data structures can be exported into the `.VTU` file format:
-- CGAL::Mesh_complex_3_in_triangulation_3 using \ref CGAL::output_to_vtu()`.
-- CGAL::Constrained_Delaunay_triangulation_2 using the function \ref CGAL::write_vtu()
-
-
-\section IOStreamAvizo Avizo File Format
-The `.am` files are used by Avizo to read 3D geometry.
-
-\subsection IOStreamtAvizoOutput Writing Avizo files
-Only the `CGAL::Mesh_complex_3_in_triangulation_3` \cgal data structure can be exported into `.am`
-This can be done using the function \ref CGAL::output_to_avizo()
-
-
-\section IOStreamMedit Medit File Format
-The `.mesh` Medit file format is a format used by the Medit software. In CGAL,
-it is mostly used to represent 3D meshes.
-A precise specification of the format is available <a href="https://hal.inria.fr/inria-00069921/document"> in this report</a>,
-in the appendices (section 7.2.1, page 36).
-
-\subsection IOStreamtMeditOutput Writing Medit files
-Only the `CGAL::Mesh_complex_3_in_triangulation_3` \cgal data structure can be exported into `.mesh`
-This can be done using the function \ref CGAL::output_to_medit()
-
-
-\section IOStreamTetgen Tetgen File Format
-The `Tetgen` file formatscan be used to represent lists of nodes, edges, faces, ...
-A precise specification of the format is available at <a href="https://wias-berlin.de/software/tetgen/fformats.html"> wias-berlin.de</a>.
-
-\subsection IOStreamTetgenOutput Writing Tetgen files
-Only the `CGAL::Mesh_complex_3_in_triangulation_3` \cgal data structure can be exported into some of the Tetgen file formats,
-naming `.node`, `.ele` and `.face`
-This can be done using the function \ref CGAL::output_to_tetgen()
 
 
 \section IOStreamGocad GOCAD (TS) File Format
+
 The `.ts` format is an ASCII file format that allows a range of primitive types to be imported into the GOCAD package.
+
 A precise specification of the format is available <a href="http://paulbourke.net/dataformats/gocad/gocad.pdf"> here</a>.
 
-\subsection IOStreamGocadInput Reading Gocad files
+<table class="iotable">
-Objects represented in the `.ts` format can be imported into \cgal's working environment
+  <tr>
-using any structure that is a model of the concept `FaceGraph`, and the function `read_GOCAD()`.
+    <th colspan="4">GOCAD (TS) File Format</th>
+  </tr>
+  <tr>
+    <td rowspan="2" width="75">Input</td>
+    <td rowspan="1" width="175">Polygon Mesh</td>
+    <td width="250">Any model of `FaceGraph`</td>
+    <td width="500">\link PkgBGLIoFuncsOBJ CGAL::read_OBJ(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsOBJ CGAL::read_OBJ(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Output</td>
+    <td rowspan="1">Polygon Mesh</td>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncsOBJ CGAL::write_OBJ(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsOBJ CGAL::write_OBJ(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+</table>
 
-\subsection IOStreamGocadOutput Writing Gocad files
+If the data of a polygon mesh cannot be read in a `FaceGraph` due to bad orientation or
- Any structure that is a model of the concept `FaceGraph` can be exported into the `.ts` file format
+manifoldness issues, consider using \link PMP_IO_grp `CGAL::Polygon_mesh_processing::read_polygon_mesh()` \endlink,
- using the function `write_GOCAD()`
+which offers combinatorial reparation while reading bad inputs.
+
+
+\section IOStream3MF 3D Manufacturing Format (3MF)
+
+The `3D Manufacturing Format (3MF)` is an open source file format created by the 3MF Consortium.
+It is an XML-based format that aims to enhance the \ref IOStreamSTL by adding means to include
+extra information such as colors.
+
+A precise specification of the format is available on <a href="http://www.3mf.io/specification/">3mf.io</a>.
+
+<table class="iotable">
+  <tr>
+    <th colspan="4">3D Manufacturing Format (3MF)</th>
+  </tr>
+  <tr>
+    <td rowspan="2" width="75">Input</td>
+    <td rowspan="1" width="175">Polygon Mesh</td>
+    <td width="250">`CGAL::Surface_mesh`</td>
+    <td width="500">\link PkgSurfaceMeshIOFunc3MF CGAL::read_3MF(const char*, CGAL::Surface_mesh&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncs3MF CGAL::read_3MF(const char*, PointRanges&, PolygonRanges&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="3">Output</td>
+    <td rowspan="2">Polygon Mesh</td>
+    <td width="250">`CGAL::Surface_mesh`</td>
+    <td width="500">\link PkgSurfaceMeshIOFunc3MF CGAL::read_3MF(const char*, CGAL::Surface_mesh&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncs3MF CGAL::write_3MF(const char*, GraphRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncs3MF CGAL::write_3MF(const char*, PointRanges&, PolygonRanges&)\endlink</td>
+  </tr>
+</table>
+
+If the data of a polygon mesh cannot be read in a `FaceGraph` due to bad orientation or
+manifoldness issues, consider using \link PMP_IO_grp `CGAL::Polygon_mesh_processing::read_polygon_mesh()` \endlink,
+which offers combinatorial reparation while reading bad inputs.
 
 
 \section IOStreamWRL Virtual Reality Modeling Language (VRML) File Format
@@ -228,11 +409,95 @@ VRML files are known as “worlds,” which is what WRL stands for.
 WRL files are plain ASCII text files.
 A WRL file includes data specifying 3-D details such as vertices,
 edges for a 3-D polygon, surface color, ...
+
 A precise specification of the format is available <a href="http://gun.teipir.gr/VRML-amgem/spec/"> here</a>.
 
-\subsection IOStreamtWRLOutput Writing WRL files
 Any structure that is a model of the concept `FaceGraph` can be exported into the `.wrl` file format
-using the `write_WRL()` function.
+using the function \link PkgBGLIoFuncsWRL `CGAL::write_WRL()` \endlink.
+
+\section IOStreamVTK VTK (VTU / VTP) File Formats
+
+The VTK libraries use different file formats to handle data structures, but we only support two:
+- The `VTU` format can be used to store am unordered collection of 3D cells, like tetrahedra,
+  but also points, triangles, lines, etc. In the <a href="https://vtk.org/"> VTK Libraries</a>,
+  it is the format reserved to store `Unstructured Grids`, and in \cgal,
+  we use it to store triangulations(2D and 3D).
+
+- The `VTP` format can be used to store collections of points, lines and triangles.
+  In the <a href="https://vtk.org/"> VTK Libraries</a>, it is the format
+  reserved to store `PolyData`, and in \cgal, we use it to store Polygon Meshes.
+
+A precise specification of those formats is available at
+<a href="https://vtk.org/wp-content/uploads/2015/04/file-formats.pdf">vtk.org</a>.
+
+<table class="iotable">
+  <tr>
+    <th colspan="4">VTK (VTU / VTP) File Formats</th>
+  </tr>
+  <tr>
+    <td rowspan="2" width="75">Input</td>
+    <td rowspan="1" width="175">Polygon Mesh</td>
+    <td width="250">Any model of `FaceGraph`</td>
+    <td width="500">\link PkgBGLIoFuncsVTP CGAL::read_VTP(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsVTP CGAL::read_VTP(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+  <tr>
+    <td rowspan="2">Output</td>
+    <td rowspan="1">Polygon Mesh</td>
+    <td>Any model of `FaceGraph`</td>
+    <td>\link PkgBGLIoFuncsVTP CGAL::write_VTP(const char*, Graph&)\endlink</td>
+  </tr>
+  <tr>
+    <td>Polygon Soup</td>
+    <td>Any point + polygon range</td>
+    <td>\link PkgStreamSupportIoFuncsVTP CGAL::write_VTP(const char*, PointRange&, PolygonRange&)\endlink</td>
+  </tr>
+</table>
+
+The following \cgal data structures can be exported into the `.VTU` file format:
+
+- `CGAL::Mesh_complex_3_in_triangulation_3`, using \link PkgMesh3IOFunctions `CGAL::output_to_vtu()` \endlink
+- `CGAL::Constrained_Delaunay_triangulation_2`, using the function \link PkgMesh2IO `CGAL::write_vtu()` \endlink
 
 
+\section IOStreamAvizo Avizo File Format
+
+The `.am` files are used by <a href="https://www.fei.com/software/avizo3d">Avizo</a> to read 3D geometry.
+
+Only the `CGAL::Mesh_complex_3_in_triangulation_3` \cgal data structure can be exported into `.am` files.
+This can be done using the function \ref CGAL::output_to_avizo().
+
+
+\section IOStreamMedit Medit File Format
+
+The `.mesh` Medit file format is a format used by the Medit software. In \cgal,
+it is mostly used to represent 3D meshes.
+A precise specification of the format is available <a href="https://hal.inria.fr/inria-00069921/document">in this report</a>,
+in the appendices (section 7.2.1, page 36).
+
+Only the `CGAL::Mesh_complex_3_in_triangulation_3` \cgal data structure can be exported into `.mesh`
+This can be done using the function \ref CGAL::output_to_medit()
+
+
+\section IOStreamTetgen Tetgen File Format
+
+The `Tetgen` file formats can be used to represent lists of nodes, edges, faces, ...
+A precise specification of the format is available at <a href="https://wias-berlin.de/software/tetgen/fformats.html"> wias-berlin.de</a>.
+
+Only the `CGAL::Mesh_complex_3_in_triangulation_3` \cgal data structure can be exported into
+some of the Tetgen file formats, namely `.node`, `.ele` and `.face`.
+This can be done using the function \ref CGAL::output_to_tetgen()
+
+
+\section IOStreamWKT Well-Known Text (WKT) File Format
+
+`WKT` stands for <em>Well-Known Text</em>. It is a text markup language for representing
+vector geometry objects on a geographical map. See the
+<A HREF="https://en.wikipedia.org/wiki/Well-known_text">wikipedia page</A> for details.
+
+See Section \ref IOstreamWKT for a list of available structures.
 */

Stream_support/doc/Stream_support/IOstream.txt

@@ -252,7 +252,7 @@ output is active or not. If the state is active, the stream output
 operator `<<` uses the internal stream to output its argument. If
 the state is inactive, nothing happens.
 
-\section IOstreamSupportedFormats Importing and Exporting Data using Standard Formats
+\section IOstreamSupportedFormats Importing and Exporting Data using Standard File Formats
 
 Although there is a large number of different types of input data structures in \cgal algorithms,
 some common data structures such as point sets or polygon meshes appear often. These
@@ -276,7 +276,7 @@ can be read from and written to for basic point ranges.
     </tr>
     <tr>
       <td>Input</td>
-      <td>read_points()</td>
+      <td>`read_points()`</td>
       <td>\link PkgPointSetProcessing3IOOff `read_OFF()` \endlink</td>
       <td>\link PkgPointSetProcessing3IOXyz `read_XYZ()` \endlink</td>
       <td>\link PkgPointSetProcessing3IOPly `read_PLY()` \endlink</td>
@@ -284,7 +284,7 @@ can be read from and written to for basic point ranges.
     </tr>
     <tr>
       <td>Output</td>
-      <td>write_points()</td>
+      <td>`write_points()`</td>
       <td>\link PkgPointSetProcessing3IOOff `write_OFF()` \endlink</td>
       <td>\link PkgPointSetProcessing3IOXyz `write_XYZ()` \endlink</td>
       <td>\link PkgPointSetProcessing3IOPly `write_PLY()` \endlink</td>
@@ -293,8 +293,8 @@ can be read from and written to for basic point ranges.
 </table>
 
 
-The class `CGAL::Point_set_3` is the data structure used in \cgal.
+The class `CGAL::Point_set_3` is the data structure used in \cgal to represent point sets.
-It is a vector-based data structure that contains a default property (named point)
+It is a vector-based data structure that contains a default property (named <em>point</em>)
 for the coordinates of the points, and is able to work with dynamic properties.
 The file formats supported for `CGAL::Point_set_3` are detailed in the table below.
 
@@ -309,7 +309,7 @@ The file formats supported for `CGAL::Point_set_3` are detailed in the table bel
     </tr>
     <tr>
       <td>Input</td>
-      <td>read_point_set()</td>
+      <td>`read_point_set()`</td>
       <td>\link PkgPointSet3IOOFF `read_OFF()` \endlink</td>
       <td>\link PkgPointSet3IOXYZ `read_XYZ()` \endlink</td>
       <td>\link PkgPointSet3IOPLY `read_PLY()` \endlink</td>
@@ -317,7 +317,7 @@ The file formats supported for `CGAL::Point_set_3` are detailed in the table bel
     </tr>
     <tr>
       <td>Output</td>
-      <td>write_point_set()</td>
+      <td>`write_point_set()`</td>
       <td>\link PkgPointSet3IOOFF `write_OFF()` \endlink</td>
       <td>\link PkgPointSet3IOXYZ `write_XYZ()` \endlink</td>
       <td>\link PkgPointSet3IOPLY `write_PLY()` \endlink</td>
@@ -338,14 +338,14 @@ their indices per face (i.e a vector of 3 integers represent a triangle face).
       <th colspan="1">\ref IOStreamOBJ "OBJ"</th>
       <th colspan="1">\ref IOStreamSTL "STL"</th>
       <th colspan="1">\ref IOStreamPLY "PLY"</th>
-      <th colspan="1">\ref IOStreamVTP "VTP"</th>
+      <th colspan="1">\ref IOStreamVTK "VTP"</th>
-      <th colspan="1">\ref IOStreamGOCAD "GOCAD"</th>
+      <th colspan="1">\ref IOStreamGocad "GOCAD"</th>
       <th colspan="1">\ref IOStreamWKT "WKT"</th>
       <th colspan="1">\ref IOStream3MF "3MF"</th>
     </tr>
     <tr>
       <td>Input</td>
-      <td>read_polygon_soup()</td>
+      <td>`read_polygon_soup()`</td>
       <td>\link PkgStreamSupportIoFuncsOFF `read_OFF()` \endlink</td>
       <td>\link PkgStreamSupportIoFuncsOBJ `read_OBJ()` \endlink</td>
       <td>\link PkgStreamSupportIoFuncsSTL `read_STL()` \endlink</td>
@@ -353,11 +353,11 @@ their indices per face (i.e a vector of 3 integers represent a triangle face).
       <td>\link PkgStreamSupportIoFuncsVTP `read_VTP()` \endlink</td>
       <td>\link PkgStreamSupportIoFuncsGOCAD `read_GOCAD()` \endlink</td>
       <td>\link PkgStreamSupportIoFuncsWKT `read_WKT()` \endlink</td>
-      <td>\link PkgStreamSupportIoFuncs3MF `read_triangle_soups_from_3mf()` \endlink</td>
+      <td>\link PkgStreamSupportIoFuncs3MF `read_3MF()` \endlink</td>
     </tr>
     <tr>
       <td>Output</td>
-      <td>write_polygon_soup()</td>
+      <td>`write_polygon_soup()`</td>
       <td>\link PkgStreamSupportIoFuncsOFF `write_OFF()` \endlink</td>
       <td>\link PkgStreamSupportIoFuncsOBJ `write_OBJ()` \endlink</td>
       <td>\link PkgStreamSupportIoFuncsSTL `write_STL()` \endlink</td>
@@ -365,13 +365,14 @@ their indices per face (i.e a vector of 3 integers represent a triangle face).
       <td>\link PkgStreamSupportIoFuncsVTP `write_VTP()` \endlink</td>
       <td>\link PkgStreamSupportIoFuncsGOCAD `write_GOCAD()` \endlink</td>
       <td>\link PkgStreamSupportIoFuncsWKT `write_WKT()` \endlink</td>
-      <td>\link PkgStreamSupportIoFuncs3MF `write_triangle_soups_to_3mf()` \endlink</td>
+      <td>\link PkgStreamSupportIoFuncs3MF `write_3MF()` \endlink</td>
     </tr>
 </table>
 
 \subsection IOstreamPolygonMeshIO Polygon Mesh IO
 A Polygon Mesh is a 3D structure that refines the concept of `FaceGraph`
 with some additional restrictions; a more precise definition can be found \ref PMPDef "here".
+The table above only lists the functions that work with any Polygon Mesh.
 
 <table class="iotable">
     <tr>
@@ -379,7 +380,7 @@ with some additional restrictions; a more precise definition can be found \ref P
       <th colspan="1">Generic</th>
       <th colspan="1">\ref IOStreamOFF "OFF"</th>
       <th colspan="1">\ref IOStreamSTL "STL"</th>
-      <th colspan="2">\ref IOStreamVTK "VTP"</th>
+      <th colspan="1">\ref IOStreamVTK "VTP"</th>
       <th colspan="1">\ref IOStreamOBJ "OBJ"</th>
       <th colspan="1">\ref IOStreamGocad "GOCAD"</th>
       <th colspan="1">\ref IOStreamWRL "WRL"</th>
@@ -390,7 +391,6 @@ with some additional restrictions; a more precise definition can be found \ref P
       <td>`read_OFF()`</td>
       <td>`read_STL()`</td>
       <td>`read_VTP()`</td>
-      <td>`read_VTP()`</td>
       <td>`read_OBJ()`</td>
       <td>`read_GOCAD()`</td>
       <td> - </td>
@@ -401,20 +401,24 @@ with some additional restrictions; a more precise definition can be found \ref P
       <td>`write_OFF()`</td>
       <td>`write_STL()`</td>
       <td>`write_VTP()`</td>
-      <td>`write_VTP()`</td>
       <td>`write_OBJ()`</td>
       <td>`write_GOCAD()`</td>
       <td>`write_WRL()`</td>
     </tr>
 </table>
 
-The table above only lists the functions that work with any Polygon Mesh.
+Some particular polygon mesh data structures such as `CGAL::Surface_mesh` have specific overloads
-More functions are available for more specific classes, and they can be found
+of these functions, enabling reading and writing of dynamic information for some file format.
-\link IOStreamSupportedFileFormats here\endlink.
+See the reference manual of each data structure for more information.
+
+The functions above require the input to represent a 2-manifold surface (possibly with boundaries).
+If this is not the case, the package \ref PkgPolygonMeshProcessing offers the function
+\link PMP_IO_grp `CGAL::Polgyon_mesh_processing::read_polygon_mesh()` \endlink
+which can perform some combinatorial repairing to ensure the input data is a 2-manifold.
 
 \subsection IOstreamWKT Simple 2D Geometry IO
 
-`WKT` stands for <em>Well Known Text</em> and it is a text markup language for representing
+`WKT` stands for <em>Well-Known Text</em> and it is a text markup language for representing
 vector geometry objects on a geographical map. See the
 <A HREF="https://en.wikipedia.org/wiki/Well-known_text">wikipedia page</A> for details.
 CGAL supports a subset of WKT types: point, multipoint, linestring, multilinestring, polygon and multipolygon.
@@ -429,36 +433,39 @@ here is a table to summarize the most useful functions :
 <table>
 <tr>
 <th colspan="1"></th>
+<th colspan="1">Generic</th>
 <th colspan="1">Points</th>
 <th colspan="1">Polylines</th>
 <th colspan="1">Polygons</th>
-<th colspan="1">Everything</th>
 </tr>
 <tr>
 <td>Input</td>
+<td>read_WKT()</td>
 <td>read_multi_point_WKT()</td>
 <td>read_multi_linestring_WKT()</td>
 <td>read_multi_polygon_WKT()</td>
-<td>read_WKT()</td>
 </tr>
 <tr>
 <td>Output</td>
+<td> - </td>
 <td>write_multi_point_WKT()</td>
 <td>write_multi_linestring_WKT()</td>
 <td>write_multi_polygon_WKT()</td>
-<td>n/a</td>
 </tr>
 </table>
 
 \subsection IOstreamOtherIO Other Data Structures
 
-- \ref AlphaShape3DIO "3D Alpha Shapes".
+Other data structures of \cgal have their own I/O functions, detailed in their respective manuals,
+for example:
+
+- \ref AlphaShape3DIO "3D Alpha Shapes"
 - \ref arr_secio "2D Arrangements"
+- \ref Nef_3File "3D Boolean Operations on Nef Polyhedra"
 - \ref secMesh_2_IO "2D Conforming Triangulations and Meshes"
 - \ref Mesh_3_section_io "3D Mesh Generation"
-- \ref Nef_3File "3D Boolean Operations on Nef Polyhedra"
+- \ref Surface_mesherIO "Surface Mesh Generation"
-- \ref Surface_mesherIO "3D Surface Mesh"
+- ...
-- \ref TriangulationSecIO "Triangulation"
 
 \subsection IOstreamOther Reading Unsupported Formats
 

Stream_support/include/CGAL/IO/3MF.h

@@ -11,18 +11,20 @@
 #ifndef CGAL_IO_3MF_H
 #define CGAL_IO_3MF_H
 
-#include <CGAL/IO/Color.h>
 #include <CGAL/IO/3MF/read_3mf.h>
 #include <CGAL/IO/3MF/write_3mf.h>
+#include <CGAL/IO/Color.h>
+#include <CGAL/IO/helpers.h>
 
 #include <CGAL/boost/graph/iterator.h>
 
-#include <boost/range/value_type.hpp>
-
 #ifdef CGAL_LINKED_WITH_3MF
 #include <Model/COM/NMR_DLLInterfaces.h>
 #endif
 
+#include <boost/range/value_type.hpp>
+#include <boost/utility/enable_if.hpp>
+
 #include <functional>
 #include <iostream>
 #include <string>
@@ -36,19 +38,21 @@ namespace CGAL {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Read
 
+/// \cond SKIP_IN_MANUAL
+
 template<typename PointRanges, typename PolygonRanges, typename ColorRanges,
          typename PointRange, typename PolygonRange, typename ColorRange>
-int read_from_3mf(const std::string& fname,
+int read_3MF(const std::string& fname,
-                  PointRanges& all_points,
+             PointRanges& all_points,
-                  PolygonRanges& all_polygons,
+             PolygonRanges& all_polygons,
-                  ColorRanges& all_colors,
+             ColorRanges& all_colors,
-                  std::vector<std::string>& names,
+             std::vector<std::string>& names,
-                  std::function<bool(NMR::PLib3MFModelMeshObject*,
+             std::function<bool(NMR::PLib3MFModelMeshObject*,
-                                     const NMR::MODELTRANSFORM&,
+                                const NMR::MODELTRANSFORM&,
-                                     PointRange&,
+                                PointRange&,
-                                     PolygonRange&,
+                                PolygonRange&,
-                                     ColorRange&,
+                                ColorRange&,
-                                     std::string&)> func)
+                                std::string&)> func)
 {
   DWORD nInterfaceVersionMajor, nInterfaceVersionMinor, nInterfaceVersionMicro, nbVertices, nbPolygons;
   HRESULT hResult;
@@ -371,6 +375,8 @@ int read_from_3mf(const std::string& fname,
   return all_points.size();
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncs3MF
  *
@@ -402,20 +408,19 @@ int read_from_3mf(const std::string& fname,
  * \return the number of soups read.
  */
 template<typename PointRanges, typename PolygonRanges, typename ColorRanges>
-int read_triangle_soups_from_3mf(const std::string& fname,
+int read_3MF(const std::string& fname,
-                                 PointRanges& all_points,
+             PointRanges& all_points,
-                                 PolygonRanges& all_polygons,
+             PolygonRanges& all_polygons,
-                                 ColorRanges& all_colors,
+             ColorRanges& all_colors,
-                                 std::vector<std::string>& names)
+             std::vector<std::string>& names)
 {
   typedef typename boost::range_value<PointRanges>::type    PointRange;
   typedef typename boost::range_value<PolygonRanges>::type  PolygonRange;
   typedef typename boost::range_value<ColorRanges>::type    ColorRange;
 
-  return read_from_3mf<PointRanges,PolygonRanges,ColorRanges,
+  return read_3MF<PointRanges,PolygonRanges,ColorRanges,
-                       PointRange, PolygonRange, ColorRange>
+                  PointRange, PolygonRange, ColorRange>(fname, all_points, all_polygons, all_colors, names,
-          (fname, all_points, all_polygons, all_colors, names,
+                                                        extract_soups<PointRange, PolygonRange, ColorRange>);
-           extract_soups<PointRange, PolygonRange, ColorRange>);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -445,10 +450,10 @@ int read_triangle_soups_from_3mf(const std::string& fname,
  * \return `true` if the writing is successful, `false` otherwise.
  */
 template<typename PointRanges, typename PolygonRanges>
-bool write_triangle_soups_to_3mf(const std::string& fname,
+bool write_3MF(const std::string& fname,
-                                 const PointRanges& all_points,
+               const PointRanges& all_points,
-                                 const PolygonRanges& all_polygons,
+               const PolygonRanges& all_polygons,
-                                 const std::vector<std::string>& names)
+               const std::vector<std::string>& names)
 {
   // Create Model Instance
   NMR::PLib3MFModel * pModel;
@@ -479,28 +484,31 @@ bool write_triangle_soups_to_3mf(const std::string& fname,
   return IO::export_model_to_file(fname, pModel);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 // convenience
 template<typename PointRange, typename PolygonRange>
-bool write_triangle_soup_to_3mf(const std::string& fname,
+bool write_3MF(const std::string& fname,
-                                const PointRange& points,
+               const PointRange& points,
-                                const PolygonRange& polygons,
+               const PolygonRange& polygons,
-                                const std::string& name)
+               const std::string& name)
 {
   std::vector<PointRange> all_points(1, points);
   std::vector<PointRange> all_polygons(1, polygons);
   std::vector<std::string> names(1, name);
 
-  return write_triangle_soups_to_3mf(fname, all_points, all_polygons, names);
+  return write_3MF(fname, all_points, all_polygons, names);
 }
 
 template<typename PointRange, typename PolygonRange>
-bool write_3MF(const std::string& fname,
+bool write_3MF(const std::string& fname, const PointRange& points, const PolygonRange& polygons,
-               const PointRange& points,
+               typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
-               const PolygonRange& polygons)
 {
   return write_triangle_soup_to_3mf(fname, points, polygons, "anonymous");
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // defined(CGAL_LINKED_WITH_3MF) || defined(DOXYGEN_RUNNING)

Stream_support/include/CGAL/IO/GOCAD.h

@@ -35,6 +35,8 @@ namespace CGAL {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Read
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_GOCAD(std::istream& is,
                 std::pair<std::string, std::string>& name_and_color,
@@ -181,6 +183,8 @@ bool read_GOCAD(const std::string& fname,
   return read_GOCAD(fname.c_str(), points, polygons, np);
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsGOCAD
  *
@@ -228,12 +232,16 @@ bool read_GOCAD(const char* fname, PointRange& points, PolygonRange& polygons)
   return read_GOCAD(fname, points, polygons, parameters::all_default());
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool read_GOCAD(const std::string& fname, PointRange& points, PolygonRange& polygons)
 {
   return read_GOCAD(fname, points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -338,12 +346,16 @@ bool write_GOCAD(std::ostream& os,
   return IO::internal::write_GOCAD(os, "anonymous", points, polygons, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool write_GOCAD(std::ostream& os, const PointRange& points, const PolygonRange& polygons)
 {
   return IO::internal::write_GOCAD(os, "anonymous", points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsGOCAD
  *
@@ -383,19 +395,16 @@ bool write_GOCAD(const char* fname,
   return IO::internal::write_GOCAD(os, fname, points, polygons, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool write_GOCAD(const char* fname, const PointRange& points, const PolygonRange& polygons)
 {
   return write_GOCAD(fname, points, polygons, parameters::all_default());
 }
 
-template <typename PointRange,
+template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-          typename PolygonRange,
+bool write_GOCAD(const std::string& fname, const PointRange& points, const PolygonRange& polygons, const CGAL_BGL_NP_CLASS& np)
-          typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool write_GOCAD(const std::string& fname,
-                 const PointRange& points,
-                 const PolygonRange& polygons,
-                 const CGAL_BGL_NP_CLASS& np)
 {
   return IO::internal::write_GOCAD(fname.c_str(), fname.c_str(), points, polygons, np);
 }
@@ -406,6 +415,8 @@ bool write_GOCAD(const std::string& fname, const PointRange& points, const Polyg
   return write_GOCAD(fname.c_str(), points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_IO_GOCAD_H

Stream_support/include/CGAL/IO/OBJ.h

@@ -178,6 +178,8 @@ bool read_OBJ(std::istream& is,
 } // namespace internal
 } // namespace IO
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_OBJ(std::istream& is,
               PointRange& points,
@@ -185,11 +187,9 @@ bool read_OBJ(std::istream& is,
               const CGAL_BGL_NP_CLASS&,
               bool verbose = true)
 {
-  using parameters::choose_parameter;
+  return IO::internal::read_OBJ(is, points, faces,
-  using parameters::get_parameter;
+                                CGAL::Emptyset_iterator(), CGAL::Emptyset_iterator(),
-
+                                verbose);
-  return IO::internal::read_OBJ(is, points, faces, CGAL::Emptyset_iterator(),
-                                CGAL::Emptyset_iterator(), verbose);
 }
 
 template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
@@ -207,6 +207,8 @@ bool read_OBJ(const std::string& fname, PointRange& points, PolygonRange& polygo
   return read_OBJ(fname.c_str(), points, polygons, np, verbose);
 }
 
+/// \endcond
+
 /// \ingroup PkgStreamSupportIoFuncsOBJ
 ///
 /// \brief reads the content of `is` into `points` and `polygons`, using the \ref IOStreamOBJ.
@@ -249,12 +251,16 @@ bool read_OBJ(const char* fname, PointRange& points, PolygonRange& polygons)
   return read_OBJ(fname, points, polygons, parameters::all_default());
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool read_OBJ(const std::string& fname, PointRange& points, PolygonRange& polygons)
 {
   return read_OBJ(fname, points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -299,12 +305,16 @@ bool write_OBJ(std::ostream& os,
   return writer(points, polygons, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool write_OBJ(std::ostream& os, const PointRange& points, const PolygonRange& polygons)
 {
   return write_OBJ(os, points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsOBJ
  *
@@ -342,6 +352,8 @@ bool write_OBJ(const char* fname, const PointRange& points, const PolygonRange&
   return write_OBJ(out, points, polygons, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool write_OBJ(const char* fname, const PointRange& points, const PolygonRange& polygons)
 {
@@ -360,6 +372,8 @@ bool write_OBJ(const std::string& fname, const PointRange& points, const Polygon
   return write_OBJ(fname.c_str(), points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_IO_OBJ_H

Stream_support/include/CGAL/IO/OFF.h

@@ -160,6 +160,8 @@ bool read_OFF(std::istream& is,
 } // namespace internal
 } // namespace IO
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange, typename NamedParameters>
 bool read_OFF(std::istream& is,
               PointRange& points,
@@ -183,11 +185,7 @@ bool read_OFF(std::istream& is,
 }
 
 template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
-bool read_OFF(const char* fname,
+bool read_OFF(const char* fname, PointRange& points, PolygonRange& polygons, const CGAL_BGL_NP_CLASS& np, bool verbose = true)
-              PointRange& points,
-              PolygonRange& polygons,
-              const CGAL_BGL_NP_CLASS& np,
-              bool verbose = true)
 {
   std::ifstream in(fname);
   return read_OFF(in, points, polygons, np, verbose);
@@ -200,6 +198,8 @@ bool read_OFF(const std::string& fname, PointRange& points, PolygonRange& polygo
   return read_OFF(fname.c_str(), points, polygons, np, verbose);
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsOFF
  *
@@ -246,12 +246,16 @@ bool read_OFF(const char* fname, PointRange& points, PolygonRange& polygons)
   return read_OFF(fname, points, polygons, parameters::all_default());
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool read_OFF(const std::string& fname, PointRange& points, PolygonRange& polygons)
 {
   return read_OFF(fname, points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -293,6 +297,8 @@ bool write_OFF(std::ostream& os,
   return writer(points, polygons, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool write_OFF(std::ostream& os, const PointRange& points, const PolygonRange& polygons
                , typename boost::enable_if<IO::internal::is_Range<PolygonRange> >::type* = nullptr)
@@ -300,6 +306,8 @@ bool write_OFF(std::ostream& os, const PointRange& points, const PolygonRange& p
   return write_OFF(os, points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsOFF
  *
@@ -338,14 +346,11 @@ bool write_OFF(const char* fname,
   return writer(points, polygons, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
-bool write_OFF(const char* fname,
+bool write_OFF(const char* fname, const PointRange& points, const PolygonRange& polygons,
-               const PointRange& points,
+               typename boost::enable_if<IO::internal::is_Range<PolygonRange> >::type* = nullptr)
-               const PolygonRange& polygons
-#ifndef DOXYGEN_RUNNING
-               , typename boost::enable_if<IO::internal::is_Range<PolygonRange> >::type* = nullptr
-#endif
-               )
 {
   return write_OFF(fname, points, polygons, parameters::all_default());
 }
@@ -363,6 +368,8 @@ bool write_OFF(const std::string& fname, const PointRange& points, const Polygon
   return write_OFF(fname, points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_IO_OFF_H

Stream_support/include/CGAL/IO/PLY.h

@@ -222,6 +222,8 @@ bool read_PLY(std::istream& is,
 } // namespace internal
 } // namespace IO
 
+/// \cond SKIP_IN_MANUAL
+
 template <class PointRange, class PolygonRange, class ColorRange, class HEdgesRange, class HUVRange>
 bool read_PLY(std::istream& is,
               PointRange& points,
@@ -278,6 +280,8 @@ bool read_PLY(std::istream& is, PointRange& points, PolygonRange& polygons,
                                 std::back_inserter(dummy_pf), verbose);
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsPLY
  *
@@ -365,6 +369,8 @@ bool read_PLY(const char* fname,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool read_PLY(const char* fname, PointRange& points, PolygonRange& polygons,
               const bool verbose = true, typename boost::enable_if<IO::internal::is_Range<PolygonRange> >::type* = nullptr)
@@ -386,6 +392,8 @@ bool read_PLY(const std::string& fname, PointRange& points, PolygonRange& polygo
   return read_PLY(fname.c_str(), points, polygons, parameters::all_default(), verbose);
 }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -467,6 +475,8 @@ bool write_PLY(std::ostream& out,
   return out.good();
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <class PointRange, class PolygonRange>
 bool write_PLY(std::ostream& out, const PointRange& points, const PolygonRange& polygons,
                typename boost::enable_if<IO::internal::is_Range<PolygonRange> >::type* = nullptr)
@@ -474,6 +484,8 @@ bool write_PLY(std::ostream& out, const PointRange& points, const PolygonRange&
   return write_PLY(out, points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsPLY
  *
@@ -532,6 +544,8 @@ bool write_PLY(const char* fname,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <class PointRange, class PolygonRange>
 bool write_PLY(const char* fname, const PointRange& points, const PolygonRange& polygons,
                typename boost::enable_if<IO::internal::is_Range<PolygonRange> >::type* = nullptr)
@@ -553,6 +567,8 @@ bool write_PLY(const std::string& fname, const PointRange& points, const Polygon
   return write_PLY(fname.c_str(), points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_IO_PLY_H

Stream_support/include/CGAL/IO/STL.h

@@ -145,6 +145,8 @@ bool read_STL(std::istream& is, PointRange& points, TriangleRange& facets)
   return read_STL(is, points, facets, parameters::all_default());
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename TriangleRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
 bool read_STL(const char* fname, PointRange& points, TriangleRange& facets,
               const CGAL_BGL_NP_CLASS& np)
@@ -159,6 +161,8 @@ bool read_STL(const std::string& fname, PointRange& points, TriangleRange& facet
   return read_STL(fname.c_str(), points, facets, np);
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsSTL
  *
@@ -182,12 +186,16 @@ bool read_STL(const char* fname, PointRange& points, TriangleRange& facets)
   return read_STL(fname, points, facets, parameters::all_default());
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename TriangleRange>
 bool read_STL(const std::string& fname, PointRange& points, TriangleRange& facets)
 {
   return read_STL(fname, points, facets, parameters::all_default());
 }
 
+/// \endcond
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Write
@@ -290,12 +298,16 @@ bool write_STL(std::ostream& os,
   return !os.fail();
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename TriangleRange>
 bool write_STL(std::ostream& os, const PointRange& points, const TriangleRange& facets)
 {
   return write_STL(os, points, facets, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsSTL
  *
@@ -331,6 +343,8 @@ bool write_STL(const char* fname, const PointRange& points, const TriangleRange&
   return write_STL(os, points, facets, np);
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename TriangleRange>
 bool write_STL(const char* fname, const PointRange& points, const TriangleRange& facets)
 {
@@ -350,6 +364,8 @@ bool write_STL(const std::string& fname, const PointRange& points, const Triangl
   return write_STL(fname.c_str(), points, facets, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // CGAL_IO_STL_H

Stream_support/include/CGAL/IO/VTK.h

@@ -444,12 +444,16 @@ bool write_VTP(std::ostream& os,
   os << "</VTKFile>\n";
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool write_VTP(std::ostream& os, const PointRange& points, const PolygonRange& polygons)
 {
   return write_VTP(os, points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 /*!
  * \ingroup PkgStreamSupportIoFuncsVTP
  *
@@ -504,6 +508,8 @@ bool write_VTP(const char* fname,
   }
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename PointRange, typename PolygonRange>
 bool write_VTP(const char* fname, const PointRange& points, const PolygonRange& polygons)
 {
@@ -522,6 +528,8 @@ bool write_VTP(const std::string& fname, const PointRange& points, const Polygon
   return write_VTP(fname.c_str(), points, polygons, parameters::all_default());
 }
 
+/// \endcond
+
 } // namespace CGAL
 
 #endif // defined(CGAL_USE_VTK) || defined(DOXYGEN_RUNNING)

Stream_support/include/CGAL/IO/io.h

@@ -388,7 +388,7 @@ Benchmark_rep<T,F> bmformat( const T& t, F) { return Benchmark_rep<T,F>(t); }
 
 returns the printing mode of the %IO stream `s`.
 
-\sa `CGAL::IO::Mode`
+\link PkgStreamSupportEnumRef `CGAL::IO::Mode`\endlink
 \sa `CGAL::set_mode()`
 \sa `CGAL::set_ascii_mode()`
 \sa `CGAL::set_binary_mode()`
@@ -408,7 +408,7 @@ inline IO::Mode get_mode(std::ios& i)
 sets the mode of the %IO stream `s` to be the `IO::ASCII` mode.
 Returns the previous mode of `s`.
 
-\sa `CGAL::IO::Mode`
+\link PkgStreamSupportEnumRef `CGAL::IO::Mode`\endlink
 \sa `CGAL::set_mode()`
 \sa `CGAL::set_binary_mode()`
 \sa `CGAL::set_pretty_mode()`
@@ -430,7 +430,7 @@ inline IO::Mode set_ascii_mode(std::ios& i)
 sets the mode of the %IO stream `s` to be the `IO::BINARY` mode.
 Returns the previous mode of `s`.
 
-\sa `CGAL::IO::Mode`
+\link PkgStreamSupportEnumRef `CGAL::IO::Mode`\endlink
 \sa `CGAL::set_mode()`
 \sa `CGAL::set_ascii_mode()`
 \sa `CGAL::set_pretty_mode()`
@@ -452,7 +452,7 @@ inline IO::Mode set_binary_mode(std::ios& i)
 sets the mode of the %IO stream `s` to be the `IO::PRETTY` mode.
 Returns the previous mode of `s`.
 
-\sa `CGAL::IO::Mode`
+\link PkgStreamSupportEnumRef `CGAL::IO::Mode`\endlink
 \sa `CGAL::set_mode()`
 \sa `CGAL::set_ascii_mode()`
 \sa `CGAL::set_binary_mode()`
@@ -473,7 +473,7 @@ inline IO::Mode set_pretty_mode(std::ios& i)
 
 sets the printing mode of the %IO stream `s`.
 
-\sa `CGAL::IO::Mode`
+\link PkgStreamSupportEnumRef `CGAL::IO::Mode`\endlink
 \sa `CGAL::set_ascii_mode()`
 \sa `CGAL::set_binary_mode()`
 \sa `CGAL::set_pretty_mode()`
@@ -494,7 +494,7 @@ inline IO::Mode set_mode(std::ios& i, IO::Mode m)
 
 checks if the %IO stream `s` is in `IO::PRETTY` mode.
 
-\sa `CGAL::IO::Mode`
+\link PkgStreamSupportEnumRef `CGAL::IO::Mode`\endlink
 \sa `CGAL::set_mode()`
 \sa `CGAL::set_ascii_mode()`
 \sa `CGAL::set_binary_mode()`
@@ -510,7 +510,7 @@ inline bool is_pretty(std::ios& i) { return i.iword(IO::Static::get_mode()) == I
 
 checks if the %IO stream `s` is in `IO::ASCII` mode.
 
-\sa `CGAL::IO::Mode`
+\link PkgStreamSupportEnumRef `CGAL::IO::Mode`\endlink
 \sa `CGAL::set_mode()`
 \sa `CGAL::set_ascii_mode()`
 \sa `CGAL::set_binary_mode()`
@@ -526,7 +526,7 @@ inline bool is_ascii(std::ios& i) { return i.iword(IO::Static::get_mode()) == IO
 
 checks if the %IO stream `s` is in `IO::BINARY` mode.
 
-\sa `CGAL::IO::Mode`
+\link PkgStreamSupportEnumRef `CGAL::IO::Mode`\endlink
 \sa `CGAL::set_mode()`
 \sa `CGAL::set_ascii_mode()`
 \sa `CGAL::set_binary_mode()`

Stream_support/include/CGAL/IO/polygon_soup_io.h

@@ -15,7 +15,7 @@
 #ifndef CGAL_IO_READ_POLYGON_SOUP_H
 #define CGAL_IO_READ_POLYGON_SOUP_H
 
-// #include <CGAL/IO/3MF.h>
+#include <CGAL/IO/3MF.h>
 #include <CGAL/IO/OBJ.h>
 #include <CGAL/IO/OFF.h>
 // #include <CGAL/IO/OI.h>

Surface_mesh/doc/Surface_mesh/PackageDescription.txt

@@ -19,6 +19,10 @@
 /// I/O Functions for \ref IOStreamPLY
 /// \ingroup PkgSurfaceMeshIOFunc
 
+/// \defgroup PkgSurfaceMeshIOFunc3MF I/O Functions (3MF)
+/// I/O Functions for \ref IOStream3MF
+/// \ingroup PkgSurfaceMeshIOFunc
+
 /// \defgroup PkgSurfaceMeshIOFuncDeprecated I/O Functions (Deprecated)
 /// \ingroup PkgSurfaceMeshIOFunc
 

Surface_mesh/include/CGAL/Surface_mesh/IO/3MF.h

@@ -29,7 +29,7 @@ namespace CGAL {
 // @todo generalize it to any model of `FaceGraph` and put it in BGL/IO (see read_OFF for the face color map)
 
 /*!
- * \ingroup PkgSurfaceMeshIOFunc
+ * \ingroup PkgSurfaceMeshIOFunc3MF
  *
  * \brief extracts the surface meshes from an input 3mf file and appends it to `output`.
  *
@@ -59,7 +59,7 @@ int read_3MF(const std::string& filename,
   std::vector<std::vector<CGAL::Color> > all_colors;
   int result = 0;
 
-  int nb_meshes = CGAL::read_triangle_soups_from_3mf(filename, all_points, all_polygons, all_colors, names);
+  int nb_meshes = CGAL::read_3MF(filename, all_points, all_polygons, all_colors, names);
   if(nb_meshes < 0)
   {
     std::cerr << "Error in reading meshes." << std::endl;

Surface_mesh/include/CGAL/Surface_mesh/IO/PLY.h

@@ -840,6 +840,8 @@ bool read_PLY(std::istream& is,
   return true;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename P>
 bool read_PLY(std::istream& is, Surface_mesh<P>& sm)
 {
@@ -847,13 +849,14 @@ bool read_PLY(std::istream& is, Surface_mesh<P>& sm)
   return read_PLY(is, sm, dummy);
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!
   \ingroup PkgSurfaceMeshIOFuncDeprecated
   \deprecated This function is deprecated since \cgal 5.2, `CGAL::read_PLY(std::ostream&, const Surface_mesh<Point>&)` should be used instead.
 */
-
 template <typename P>
 CGAL_DEPRECATED bool read_ply(std::istream& is, Surface_mesh<P>& sm, std::string& comments)
 {
@@ -1098,6 +1101,8 @@ bool write_PLY(std::ostream& os,
   return true;
 }
 
+/// \cond SKIP_IN_MANUAL
+
 template <typename P>
 bool write_PLY(std::ostream& os, const Surface_mesh<P>& sm, const std::string& comments)
 {
@@ -1118,6 +1123,8 @@ bool write_PLY(std::ostream& os, const Surface_mesh<P>& sm)
   return write_PLY(os, sm, unused_comment, parameters::all_default());
 }
 
+/// \endcond
+
 #ifndef CGAL_NO_DEPRECATED_CODE
 
 /*!

Triangulation/doc/Triangulation/Triangulation.txt

@@ -566,11 +566,6 @@ Performance of the insertion of 1000 points in a Delaunay triangulation.
 Running time wrt. number of maximal simplices, for dimensions for 2 to 12.
 \cgalFigureEnd
 
-\section TriangulationSecIO Input/Output
-
-It is possible to export a Triangulation to the OFF format with the function
-`CGAL::export_triangulation_to_off()`.
-
 \section TriangulationSecDesign Design and Implementation History
 
 Starting with the version 2.3 of \cgal, a package written by Susan Hert and Michael Seel