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

IO doc fixes

This commit is contained in:
Mael Rouxel-Labbé 2020-06-26 16:08:02 +02:00
parent a3d8f10647
commit ae4c2aaa9e
48 changed files with 897 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BGL/doc/BGL/PackageDescription.txt
View File

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

16
BGL/include/CGAL/boost/graph/IO/3MF.h
View File

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

17
BGL/include/CGAL/boost/graph/IO/GOCAD.h
View File

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

4
BGL/include/CGAL/boost/graph/IO/INP.h
View File

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

13
BGL/include/CGAL/boost/graph/IO/OBJ.h
View File

@ -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,
Graph& g,
const CGAL_BGL_NP_CLASS& np,
bool verbose = true)
bool read_OBJ(const std::string& fname, 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

16
BGL/include/CGAL/boost/graph/IO/OFF.h
View File

@ -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
/*!

16
BGL/include/CGAL/boost/graph/IO/PLY.h
View File

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

8
BGL/include/CGAL/boost/graph/IO/STL.h
View File

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

8
BGL/include/CGAL/boost/graph/IO/VTK.h
View File

@ -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
/*!

8
BGL/include/CGAL/boost/graph/IO/polygon_mesh_io.h
View File

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

2
BGL/test/BGL/test_3mf_to_sm.cpp
View File

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

8
Mesh_3/doc/Mesh_3/Mesh_3.txt
View File

@ -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()`
- Medit with `CGAL::output_to_medit()`
- Tetgen with `CGAL::output_to_tetgen()`
- Avizo, with `CGAL::output_to_avizo()`
- Medit, with `CGAL::output_to_medit()`
- Tetgen, with `CGAL::output_to_tetgen()`
\section Mesh_3_section_examples Examples

8
Point_set_3/include/CGAL/Point_set_3/IO.h
View File

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

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

@ -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
/*!

12
Point_set_3/include/CGAL/Point_set_3/IO/OFF.h
View File

@ -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
/*!

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

@ -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
/*!

12
Point_set_3/include/CGAL/Point_set_3/IO/XYZ.h
View File

@ -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
/*!

23
Point_set_processing_3/include/CGAL/IO/read_las_points.h
View File

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

13
Point_set_processing_3/include/CGAL/IO/read_off_points.h
View File

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

14
Point_set_processing_3/include/CGAL/IO/read_ply_points.h
View File

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

4
Point_set_processing_3/include/CGAL/IO/read_points.h
View File

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

8
Point_set_processing_3/include/CGAL/IO/read_xyz_points.h
View File

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

10
Point_set_processing_3/include/CGAL/IO/write_las_points.h
View File

@ -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
#ifndef CGAL_NO_DEPRECATED_CODE
/// \endcond
/**
\ingroup PkgPointSetProcessing3IODeprecated

14
Point_set_processing_3/include/CGAL/IO/write_off_points.h
View File

@ -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
#ifndef CGAL_NO_DEPRECATED_CODE
/// \endcond
/**
\ingroup PkgPointSetProcessing3IODeprecated

13
Point_set_processing_3/include/CGAL/IO/write_ply_points.h
View File

@ -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
#ifndef CGAL_NO_DEPRECATED_CODE
/// \endcond
/**
\ingroup PkgPointSetProcessing3IODeprecated

4
Point_set_processing_3/include/CGAL/IO/write_points.h
View File

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

17
Point_set_processing_3/include/CGAL/IO/write_xyz_points.h
View File

@ -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)
{

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/IO/polygon_mesh_io.h
View File

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

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_mesh_to_polygon_soup.h
View File

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

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/polygon_soup_to_polygon_mesh.h
View File

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

3
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/smooth_mesh.h
View File

@ -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)
{

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

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

4
Polyhedron/demo/Polyhedron/Plugins/IO/3mf_io_plugin.cpp
View File

@ -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(),
all_points, all_polygons, all_colors, names);
CGAL::read_3MF(fileinfo.filePath().toUtf8().toStdString(),
all_points, all_polygons, all_colors, names);
if(nb_meshes <0 )
{
ok = false;

585
Stream_support/doc/Stream_support/File_formats/Supported_file_formats.txt
View File

@ -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 IOStreamWRL
- \ref IOStreamLAS
- \ref IOStreamWKT
\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
Objects represented in the `.OFF` format can be imported into \cgal's working environment
using the following data structures and functions:
The following table lists some \cgal data structures that have I/O functions compatible with this file format.
- `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
to orientable 2-manifolds.
- 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.
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 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
Objects represented in the `.OBJ` format can be imported into \cgal's working environment
using any structure that is a model of the concept `FaceGraph`, and the function `read_OBJ()`.
<table class="iotable">
<tr>
<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()".
\subsection IOStreamOBJOutput Writing OBJ files
Any structure that is a model of the concept `FaceGraph` can be exported into the `OBJ` file format
using the function `write_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,
which offers combinatorial reparation while reading bad inputs.
\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
Objects represented in the `.STL` format can be imported into \cgal's working environment
using any data structure that is a model of the `FaceGraph` concept, using \ref CGAL::read_STL();
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.
In addition, if the data cannot be read in a `FaceGraph` because of bad orientation or
manifoldness, the function \link IOstreamFunctions `CGAL::read_STL(std::istream&,PointRange&,TriangleRange&,bool)` \endlink
allows to load data directly in a soup of triangles. From there, you can use \ref PMPRepairing
functions to construct a valid PolygonMesh.
A precise specification of those formats is available
<a href="http://www.fabbers.com/tech/STL_Format">here</a>.
\subsection IOStreamSTLOutput Writing STL files
Similarly, any data structure that is a model of the `FaceGraph` concept can be exported
as a `.STL` file using \link PkgBGLIOFct CGAL::write_STL(std::ostream&, const TriangleMesh&, const NamedParameters&)\endlink.
Polygon soups can also be exported using the function \link IOstreamFunctions `CGAL::write_STL(std::ostream&, const PointRange&,const TriangleRange&)`. \endlink
<table class="iotable">
<tr>
<th colspan="4">Standard Triangle Language (STL)</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 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.
A precise specification of those formats is available at
<a href="http://paulbourke.net/dataformats/ply/"> paulbourke.net</a>.
as a simple list of polygons and is capable of storing external properties.
\subsection IOStreamPLYInput Reading PLY files
Objects represented in the `.PLY` format can be imported into \cgal's working environment
using the following data structures and functions:
- `CGAL::Surface_mesh` (`CGAL::read_PLY()`)
- `CGAL::Point_set_3` (`operator>>(std::istream&,CGAL::Point_set_3<Point, Vector>&)`) a collection of points with dynamically associated properties
A precise specification of those formats is available
<a href="http://paulbourke.net/dataformats/ply/">here</a>.
<table class="iotable">
<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
Objects represented in the `.LAS` format can be imported into \cgal's working environment
using the following data structures and functions:
- `CGAL::Point_set_3 (`CGAL::read_LAS`) a collection of points with dynamically associated properties
- Point ranges
A precise specification of those formats is available at
<a href="https://www.loc.gov/preservation/digital/formats/fdd/fdd000418.shtml">here</a>.
<table class="iotable">
<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
Objects represented in the `.XYZ` or `.PWN` format can be imported into \cgal's working environment
using the `CGAL::Point_set_3` and the function `CGAL::read_point_set()`.
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 <em>points with normals</em>.)
\subsection IOStreamXYZOutput Writing XYZ files
The CGAL::Point_set_3 can be exported into a `XYZ` or a `PWN` file using the function
write_xyz_point_set().
\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>.
\subsection IOStreamVTKInput Reading VTK files
Objects represented in the `VTP` format can be imported into \cgal's working environment
using the following data structures and functions:
- CGAL::Surface_mesh
- CGAL::Polyhedron_3
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()
<table class="iotable">
<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 PkgPointSet3IOXYZ CGAL::read_XYZ(const char*, CGAL::Point_set_3&)\endlink</td>
</tr>
<tr>
<td>Any point range</td>
<td>\link PkgPointSetProcessing3IOXyz CGAL::read_XYZ(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 PkgPointSet3IOXYZ CGAL::write_XYZ(const char*, CGAL::Point_set_3&)\endlink</td>
</tr>
<tr>
<td>Any point range</td>
<td>\link PkgPointSetProcessing3IOXyz CGAL::write_XYZ(const char*, PointRange&)\endlink</td>
</tr>
</table>
\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
Objects represented in the `.ts` format can be imported into \cgal's working environment
using any structure that is a model of the concept `FaceGraph`, and the function `read_GOCAD()`.
<table class="iotable">
<tr>
<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
Any structure that is a model of the concept `FaceGraph` can be exported into the `.ts` file format
using the function `write_GOCAD()`
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 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.
*/

61
Stream_support/doc/Stream_support/IOstream.txt
View File

@ -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.
It is a vector-based data structure that contains a default property (named point)
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 <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 IOStreamGOCAD "GOCAD"</th>
<th colspan="1">\ref IOStreamVTK "VTP"</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.
More functions are available for more specific classes, and they can be found
\link IOStreamSupportedFileFormats here\endlink.
Some particular polygon mesh data structures such as `CGAL::Surface_mesh` have specific overloads
of these functions, enabling reading and writing of dynamic information for some file format.
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 "3D Surface Mesh"
- \ref TriangulationSecIO "Triangulation"
- \ref Surface_mesherIO "Surface Mesh Generation"
- ...
\subsection IOstreamOther Reading Unsupported Formats

78
Stream_support/include/CGAL/IO/3MF.h
View File

@ -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,
PointRanges& all_points,
PolygonRanges& all_polygons,
ColorRanges& all_colors,
std::vector<std::string>& names,
std::function<bool(NMR::PLib3MFModelMeshObject*,
const NMR::MODELTRANSFORM&,
PointRange&,
PolygonRange&,
ColorRange&,
std::string&)> func)
int read_3MF(const std::string& fname,
PointRanges& all_points,
PolygonRanges& all_polygons,
ColorRanges& all_colors,
std::vector<std::string>& names,
std::function<bool(NMR::PLib3MFModelMeshObject*,
const NMR::MODELTRANSFORM&,
PointRange&,
PolygonRange&,
ColorRange&,
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,
PointRanges& all_points,
PolygonRanges& all_polygons,
ColorRanges& all_colors,
std::vector<std::string>& names)
int read_3MF(const std::string& fname,
PointRanges& all_points,
PolygonRanges& all_polygons,
ColorRanges& all_colors,
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,
PointRange, PolygonRange, ColorRange>
(fname, all_points, all_polygons, all_colors, names,
extract_soups<PointRange, PolygonRange, ColorRange>);
return read_3MF<PointRanges,PolygonRanges,ColorRanges,
PointRange, PolygonRange, ColorRange>(fname, all_points, all_polygons, all_colors, names,
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,
const PointRanges& all_points,
const PolygonRanges& all_polygons,
const std::vector<std::string>& names)
bool write_3MF(const std::string& fname,
const PointRanges& all_points,
const PolygonRanges& all_polygons,
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,
const PointRange& points,
const PolygonRange& polygons,
const std::string& name)
bool write_3MF(const std::string& fname,
const PointRange& points,
const PolygonRange& polygons,
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,
const PointRange& points,
const PolygonRange& polygons)
bool write_3MF(const std::string& fname, const PointRange& points, const PolygonRange& polygons,
typename boost::enable_if<IO::internal::is_Range<PointRange> >::type* = nullptr)
{
return write_triangle_soup_to_3mf(fname, points, polygons, "anonymous");
}
/// \endcond
} // namespace CGAL
#endif // defined(CGAL_LINKED_WITH_3MF) || defined(DOXYGEN_RUNNING)

25
Stream_support/include/CGAL/IO/GOCAD.h
View File

@ -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,
typename PolygonRange,
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)
template <typename PointRange, typename PolygonRange, 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

24
Stream_support/include/CGAL/IO/OBJ.h
View File

@ -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;
using parameters::get_parameter;
return IO::internal::read_OBJ(is, points, faces, 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

31
Stream_support/include/CGAL/IO/OFF.h
View File

@ -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,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np,
bool verbose = true)
bool read_OFF(const char* fname, 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,
const PointRange& points,
const PolygonRange& polygons
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<IO::internal::is_Range<PolygonRange> >::type* = nullptr
#endif
)
bool write_OFF(const char* fname, const PointRange& points, const PolygonRange& polygons,
typename boost::enable_if<IO::internal::is_Range<PolygonRange> >::type* = nullptr)
{
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

16
Stream_support/include/CGAL/IO/PLY.h
View File

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

16
Stream_support/include/CGAL/IO/STL.h
View File

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

8
Stream_support/include/CGAL/IO/VTK.h
View File

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

16
Stream_support/include/CGAL/IO/io.h
View File

@ -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()`

2
Stream_support/include/CGAL/IO/polygon_soup_io.h
View File

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

4
Surface_mesh/doc/Surface_mesh/PackageDescription.txt
View File

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

4
Surface_mesh/include/CGAL/Surface_mesh/IO/3MF.h
View File

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

9
Surface_mesh/include/CGAL/Surface_mesh/IO/PLY.h
View File

@ -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
/*!

5
Triangulation/doc/Triangulation/Triangulation.txt
View File

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