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

rename macro since Named_function_parameter is part of STL_Extension

This commit is contained in:
Sébastien Loriot 2022-01-13 14:43:34 +01:00
parent 4bbe759f08
commit 10b0af3092
54 changed files with 514 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
BGL/include/CGAL/boost/graph/Face_filtered_graph.h
View File

@ -147,9 +147,9 @@ struct Face_filtered_graph
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <class CGAL_NP_TEMPLATE_PARAMETERS>
Face_filtered_graph(const Graph& graph,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
: _graph(const_cast<Graph&>(graph))
, fimap(CGAL::get_initialized_face_index_map(graph, np))
, vimap(CGAL::get_initialized_vertex_index_map(graph, np))
@ -208,11 +208,11 @@ struct Face_filtered_graph
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <typename FacePatchIndexMap, class FacePatchIndexRange, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename FacePatchIndexMap, class FacePatchIndexRange, class CGAL_NP_TEMPLATE_PARAMETERS>
Face_filtered_graph(const Graph& graph,
const FacePatchIndexRange& selected_face_patch_indices,
FacePatchIndexMap face_patch_index_map,
const CGAL_BGL_NP_CLASS& np
const CGAL_NP_CLASS& np
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<
typename boost::has_range_const_iterator<FacePatchIndexRange>::type
@ -290,11 +290,11 @@ struct Face_filtered_graph
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <typename FacePatchIndexMap, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename FacePatchIndexMap, class CGAL_NP_TEMPLATE_PARAMETERS>
Face_filtered_graph(const Graph& graph,
typename boost::property_traits<FacePatchIndexMap>::value_type selected_face_patch_index,
FacePatchIndexMap face_patch_index_map,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
: _graph(const_cast<Graph&>(graph)),
fimap(CGAL::get_initialized_face_index_map(graph, np)),
vimap(CGAL::get_initialized_vertex_index_map(graph, np)),
@ -360,10 +360,10 @@ struct Face_filtered_graph
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <typename FaceRange, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename FaceRange, class CGAL_NP_TEMPLATE_PARAMETERS>
Face_filtered_graph(const Graph& graph,
const FaceRange& selected_faces,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
: _graph(const_cast<Graph&>(graph)),
fimap(CGAL::get_initialized_face_index_map(graph, np)),
vimap(CGAL::get_initialized_vertex_index_map(graph, np)),

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

@ -108,17 +108,17 @@ public:
/// \returns `true` if reading was successful and the resulting mesh is valid, `false` otherwise.
///
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(std::istream& is,
std::pair<std::string, std::string>& name_and_color,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
)
{
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::type VPM;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::type VPM;
typedef typename boost::property_traits<VPM>::value_type Point;
internal::GOCAD_builder<Graph, Point> builder(is);
@ -133,8 +133,8 @@ bool read_GOCAD(std::istream& is,
/// \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 = parameters::default_values(),
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(std::istream& is, Graph& g, const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
{
std::pair<std::string, std::string> dummy;
@ -182,11 +182,11 @@ bool read_GOCAD(std::istream& is, Graph& g, const CGAL_BGL_NP_CLASS& np = parame
/// \returns `true` if reading was successful and the resulting mesh is valid, `false` otherwise.
///
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(const std::string& fname,
std::pair<std::string, std::string>& name_and_color,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -199,8 +199,8 @@ bool read_GOCAD(const std::string& fname,
/// \cond SKIP_IN_MANUAL
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(const std::string& fname, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(const std::string& fname, Graph& g, const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
{
std::pair<std::string, std::string> dummy;
@ -245,11 +245,11 @@ bool read_GOCAD(const std::string& fname, Graph& g, const CGAL_BGL_NP_CLASS& np
/// \returns `true` if writing was successful, `false` otherwise.
///
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_GOCAD(std::ostream& os,
const char* name,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -263,7 +263,7 @@ bool write_GOCAD(std::ostream& os,
using parameters::choose_parameter;
using parameters::get_parameter;
typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::const_type
typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::const_type
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
@ -342,10 +342,10 @@ bool write_GOCAD(std::ostream& os,
/// \returns `true` if writing was successful, `false` otherwise.
///
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_GOCAD(std::ostream& os,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -387,10 +387,10 @@ bool write_GOCAD(std::ostream& os,
/// \sa Overloads of this function for specific models of the concept `FaceGraph`.
///
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_GOCAD(const std::string& fname,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif

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

@ -27,18 +27,18 @@ namespace IO {
/// \cond SKIP_IN_MANUAL
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_INP(std::ostream& os,
const std::string& name,
const std::string& type,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<Graph>::face_descriptor face_descriptor;
typedef typename boost::graph_traits<Graph>::vertices_size_type vertices_size_type;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::const_type VPM;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::const_type VPM;
typedef typename boost::property_traits<VPM>::reference Point_ref;
using parameters::choose_parameter;
@ -76,11 +76,11 @@ bool write_INP(std::ostream& os,
return os.good();
}
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_INP(const std::string& fname,
const std::string& type,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values() )
const CGAL_NP_CLASS& np = parameters::default_values() )
{
std::ofstream os(fname);
return write_INP(os, fname, type, g, np);

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

@ -104,16 +104,16 @@ public:
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OBJ(std::istream& is,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
)
{
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::type VPM;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::type VPM;
typedef typename boost::property_traits<VPM>::value_type Point;
internal::OBJ_builder<Graph, Point> builder(is);
@ -160,10 +160,10 @@ bool read_OBJ(std::istream& is,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OBJ(const std::string& fname,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -212,10 +212,10 @@ bool read_OBJ(const std::string& fname,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OBJ(std::ostream& os,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -258,10 +258,10 @@ bool write_OBJ(std::ostream& os,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OBJ(const std::string& fname,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif

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

@ -64,12 +64,12 @@ public:
// Because some packages can provide overloads with the same signature to automatically initialize
// property maps (see Surface_mesh/IO/ for example)
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF_BGL(std::istream& is,
Graph& g,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::type VPM;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::type VPM;
typedef typename boost::property_traits<VPM>::value_type Point;
internal::OFF_builder<Graph, Point> builder(is);
@ -150,10 +150,10 @@ bool read_OFF_BGL(std::istream& is,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(std::istream& is,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -234,10 +234,10 @@ bool read_OFF(std::istream& is,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(const std::string& fname,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -256,8 +256,8 @@ bool read_OFF(const std::string& fname,
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::read_OFF()` should be used instead.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off(std::istream& is, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off(std::istream& is, Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_OFF(is, g, np);
}
@ -267,8 +267,8 @@ CGAL_DEPRECATED bool read_off(std::istream& is, Graph& g, const CGAL_BGL_NP_CLAS
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::read_OFF()` should be used instead.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off(const char* fname, Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off(const char* fname, Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_OFF(fname, g, np);
}
@ -287,10 +287,10 @@ CGAL_DEPRECATED bool read_off(const std::string& fname, Graph& g)
namespace IO {
namespace internal {
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF_BGL(std::ostream& os,
const Graph& g,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
internal::Generic_facegraph_printer<std::ostream, Graph, CGAL::File_writer_OFF> printer(os);
return printer(g, np);
@ -360,10 +360,10 @@ bool write_OFF_BGL(std::ostream& os,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(std::ostream& os,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -434,10 +434,10 @@ bool write_OFF(std::ostream& os,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(const std::string& fname,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -462,8 +462,8 @@ bool write_OFF(const std::string& fname,
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_OFF()` should be used instead.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_off(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_off(std::ostream& os, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_OFF(os, g, np);
}
@ -473,8 +473,8 @@ CGAL_DEPRECATED bool write_off(std::ostream& os, const Graph& g, const CGAL_BGL_
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_OFF()` should be used instead.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_off(const char* fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_off(const char* fname, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_OFF(fname, g, np);
}

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

@ -58,12 +58,12 @@ public:
}
};
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY_BGL(std::istream& is,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::type VPM;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::type VPM;
typedef typename boost::property_traits<VPM>::value_type Point;
internal::PLY_builder<Graph, Point> builder(is);
@ -131,10 +131,10 @@ bool read_PLY_BGL(std::istream& is,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(std::istream& is,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -206,10 +206,10 @@ bool read_PLY(std::istream& is,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(const std::string& fname,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -292,11 +292,11 @@ bool read_PLY(const std::string& fname,
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os,
const Graph& g,
const std::string& comments,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -306,17 +306,17 @@ bool write_PLY(std::ostream& os,
typedef typename boost::graph_traits<Graph>::halfedge_descriptor halfedge_descriptor;
typedef typename boost::graph_traits<Graph>::face_descriptor face_descriptor;
typedef typename CGAL::GetInitializedVertexIndexMap<Graph, CGAL_BGL_NP_CLASS>::const_type VIMap;
typedef typename GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::const_type Vpm;
typedef typename CGAL::GetInitializedVertexIndexMap<Graph, CGAL_NP_CLASS>::const_type VIMap;
typedef typename GetVertexPointMap<Graph, CGAL_NP_CLASS>::const_type Vpm;
typedef typename boost::property_traits<Vpm>::value_type Point_3;
typedef CGAL::IO::Color Color;
typedef typename internal_np::Lookup_named_param_def<
internal_np::vertex_color_map_t,
CGAL_BGL_NP_CLASS,
CGAL_NP_CLASS,
Constant_property_map<vertex_descriptor, Color> >::type VCM;
typedef typename internal_np::Lookup_named_param_def<
internal_np::face_color_map_t,
CGAL_BGL_NP_CLASS,
CGAL_NP_CLASS,
Constant_property_map<face_descriptor, Color> >::type FCM;
using parameters::choose_parameter;
@ -326,8 +326,8 @@ bool write_PLY(std::ostream& os,
VCM vcm = choose_parameter(get_parameter(np, internal_np::vertex_color_map), VCM());
FCM fcm = choose_parameter(get_parameter(np, internal_np::face_color_map), FCM());
bool has_vcolor = !is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>();
bool has_fcolor = !is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>();
bool has_vcolor = !is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_color_map_t>();
bool has_fcolor = !is_default_parameter<CGAL_NP_CLASS, internal_np::face_color_map_t>();
VIMap vim = CGAL::get_initialized_vertex_index_map(g, np);
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, g));
@ -419,8 +419,8 @@ bool write_PLY(std::ostream& os,
/// \cond SKIP_IN_MANUAL
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
{
return write_PLY(os, g, std::string(), np);
@ -488,11 +488,11 @@ bool write_PLY(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = p
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(const std::string& fname,
const Graph& g,
const std::string& comments,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr
#endif
@ -516,8 +516,8 @@ bool write_PLY(const std::string& fname,
/// \cond SKIP_IN_MANUAL
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(const std::string& fname, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::disable_if<internal::is_Point_set_or_Range_or_Iterator<Graph> >::type* = nullptr)
{
return write_PLY(fname, g, std::string(), np);

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

@ -98,12 +98,12 @@ public:
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_STL(std::istream& is,
Graph& g,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::type VPM;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::type VPM;
typedef typename boost::property_traits<VPM>::value_type Point;
if(!is.good())
return false;
@ -155,10 +155,10 @@ bool read_STL(std::istream& is,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_STL(const std::string& fname,
Graph& g, const
CGAL_BGL_NP_CLASS& np = parameters::default_values())
CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -177,7 +177,7 @@ bool read_STL(const std::string& fname,
std::ifstream is(fname);
CGAL::IO::set_mode(is, CGAL::IO::ASCII);
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::type VPM;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::type VPM;
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, g));
bool v = choose_parameter(get_parameter(np, internal_np::verbose),
@ -234,15 +234,15 @@ bool read_STL(std::istream& is, Graph& g) { return read_STL(is, g, parameters::d
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_STL(std::ostream& os,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<Graph>::halfedge_descriptor halfedge_descriptor;
typedef typename boost::graph_traits<Graph>::face_descriptor face_descriptor;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_BGL_NP_CLASS>::const_type VPM;
typedef typename CGAL::GetVertexPointMap<Graph, CGAL_NP_CLASS>::const_type VPM;
typedef typename boost::property_traits<VPM>::reference Point_ref;
typedef typename boost::property_traits<VPM>::value_type Point;
typedef typename Kernel_traits<Point>::Kernel::Vector_3 Vector;
@ -351,8 +351,8 @@ bool write_STL(std::ostream& os,
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
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 = parameters::default_values())
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_STL(const std::string& fname, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
const bool binary = CGAL::parameters::choose_parameter(CGAL::parameters::get_parameter(np, internal_np::use_binary_mode), true);
if(binary)

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

@ -140,10 +140,10 @@ bool vtkPointSet_to_polygon_mesh(vtkPointSet* poly_data,
* \returns `true` if reading was successful, `false` otherwise.
*/
template<typename Graph,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_VTP(const std::string& fname,
Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ifstream test(fname);
if(!test.good())
@ -412,10 +412,10 @@ void write_polys_points(std::ostream& os,
*
* \returns `true` if writing was successful, `false` otherwise.
*/
template<typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template<typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_VTP(std::ostream& os,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::get_parameter;
using parameters::choose_parameter;
@ -511,8 +511,8 @@ bool write_VTP(std::ostream& os,
*
* \returns `true` if writing was successful, `false` otherwise.
*/
template<typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_VTP(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template<typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_VTP(const std::string& fname, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
const bool binary = CGAL::parameters::choose_parameter(CGAL::parameters::get_parameter(np, internal_np::use_binary_mode), true);
std::ofstream os;
@ -536,8 +536,8 @@ bool write_VTP(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_VTP()` should be used instead.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_vtp(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_vtp(std::ostream& os, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_VTP(os, g, np);
}

12
BGL/include/CGAL/boost/graph/IO/WRL.h
View File

@ -61,10 +61,10 @@ namespace IO {
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_WRL(std::ostream& os,
const Graph& g,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
CGAL::VRML_2_ostream vos(os);
internal::Generic_facegraph_printer<CGAL::VRML_2_ostream, Graph, CGAL::File_writer_VRML_2> printer(vos);
@ -102,8 +102,8 @@ bool write_WRL(std::ostream& os,
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_WRL(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_WRL(const std::string& fname, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ofstream os(fname);
return write_WRL(os, g, np);
@ -118,8 +118,8 @@ bool write_WRL(const std::string& fname, const Graph& g, const CGAL_BGL_NP_CLASS
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_WRL()` should be used instead.
*/
template <typename Graph, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_wrl(std::ostream& os, const Graph& g, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Graph, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_wrl(std::ostream& os, const Graph& g, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_WRL(os, g, np);
}

12
Documentation/doc/resources/1.8.13/BaseDoxyfile.in
View File

@ -2173,12 +2173,12 @@ INCLUDE_FILE_PATTERNS =
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
PREDEFINED = DOXYGEN_RUNNING \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_BGL_NP_CLASS=NamedParameters" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_1=NamedParameters1" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_2=NamedParameters2" \
"CGAL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_NP_CLASS=NamedParameters" \
"CGAL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_1=NamedParameters1" \
"CGAL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_2=NamedParameters2" \
CGAL_DEPRECATED
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this

12
Documentation/doc/resources/1.8.14/BaseDoxyfile.in
View File

@ -2161,12 +2161,12 @@ INCLUDE_FILE_PATTERNS =
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
PREDEFINED = DOXYGEN_RUNNING \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_BGL_NP_CLASS=NamedParameters" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_1=NamedParameters1" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_2=NamedParameters2" \
"CGAL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_NP_CLASS=NamedParameters" \
"CGAL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_1=NamedParameters1" \
"CGAL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_2=NamedParameters2" \
CGAL_DEPRECATED
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this

12
Documentation/doc/resources/1.8.20/BaseDoxyfile.in
View File

@ -2244,12 +2244,12 @@ INCLUDE_FILE_PATTERNS =
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
PREDEFINED = DOXYGEN_RUNNING \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_BGL_NP_CLASS=NamedParameters" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_1=NamedParameters1" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_2=NamedParameters2" \
"CGAL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_NP_CLASS=NamedParameters" \
"CGAL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_1=NamedParameters1" \
"CGAL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_2=NamedParameters2" \
CGAL_DEPRECATED
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this

12
Documentation/doc/resources/1.8.4/BaseDoxyfile.in
View File

@ -1761,12 +1761,12 @@ INCLUDE_FILE_PATTERNS =
# instead of the = operator.
PREDEFINED = DOXYGEN_RUNNING \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_BGL_NP_CLASS=NamedParameters" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_1=NamedParameters1" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_2=NamedParameters2" \
"CGAL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_NP_CLASS=NamedParameters" \
"CGAL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_1=NamedParameters1" \
"CGAL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_2=NamedParameters2" \
CGAL_DEPRECATED
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then

12
Documentation/doc/resources/1.9.3/BaseDoxyfile.in
View File

@ -2244,12 +2244,12 @@ INCLUDE_FILE_PATTERNS =
# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
PREDEFINED = DOXYGEN_RUNNING \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_BGL_NP_CLASS=NamedParameters" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_1=NamedParameters1" \
"CGAL_BGL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_BGL_NP_CLASS_2=NamedParameters2" \
"CGAL_NP_TEMPLATE_PARAMETERS=NamedParameters = CGAL::parameters::Default_named_parameters" \
"CGAL_NP_CLASS=NamedParameters" \
"CGAL_NP_TEMPLATE_PARAMETERS_1=NamedParameters1 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_1=NamedParameters1" \
"CGAL_NP_TEMPLATE_PARAMETERS_2=NamedParameters2 = CGAL::parameters::Default_named_parameter" \
"CGAL_NP_CLASS_2=NamedParameters2" \
CGAL_DEPRECATED

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

@ -118,10 +118,10 @@ namespace IO {
\return `true` if the reading was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_point_set(const std::string& fname,
CGAL::Point_set_3<Point, Vector>& ps,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
const std::string ext = internal::get_file_extension(fname);
@ -211,10 +211,10 @@ namespace IO {
\return `true` if the writing was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_point_set(const std::string& fname,
CGAL::Point_set_3<Point, Vector>& ps,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
const std::string ext = internal::get_file_extension(fname);

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

@ -140,10 +140,10 @@ namespace IO {
\return `true` if the writing was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(std::ostream& os,
const CGAL::Point_set_3<Point, Vector>& point_set,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
if(point_set.has_normal_map())
return Point_set_processing_3::internal::write_OFF_PSP(os, point_set,
@ -179,8 +179,8 @@ bool write_OFF(std::ostream& os,
\return `true` if the writing was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ofstream os(fname);
return write_OFF(os, point_set, np);

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

@ -333,11 +333,11 @@ bool read_PLY(std::istream& is, CGAL::Point_set_3<Point, Vector>& point_set)
\return `true` if the reading was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(const std::string& fname,
CGAL::Point_set_3<Point, Vector>& point_set,
std::string& comments,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
const bool binary = CGAL::parameters::choose_parameter(CGAL::parameters::get_parameter(np, internal_np::use_binary_mode), true);
if(binary)
@ -355,8 +355,8 @@ bool read_PLY(const std::string& fname,
}
/// \cond SKIP_IN_MANUAL
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(const std::string& fname, CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_NP_CLASS& np = parameters::default_values())
{
std::string unused_comments;
return read_PLY(fname, point_set, unused_comments, np);
@ -446,11 +446,11 @@ namespace IO {
\return `true` if the reading was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os,
const CGAL::Point_set_3<Point, Vector>& point_set,
const std::string& comments,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef CGAL::Point_set_3<Point, Vector> Point_set;
typedef typename Point_set::Index Index;
@ -663,8 +663,8 @@ bool write_PLY(std::ostream& os,
/// \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 = parameters::default_values())
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_NP_CLASS& np = parameters::default_values())
{
return write_PLY(os, point_set, std::string(), np);
}
@ -709,11 +709,11 @@ bool write_PLY(std::ostream& os, const CGAL::Point_set_3<Point, Vector>& point_s
\return `true` if the reading was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(const std::string& fname,
const CGAL::Point_set_3<Point, Vector>& point_set,
const std::string& comments,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
const bool binary = CGAL::parameters::choose_parameter(CGAL::parameters::get_parameter(np, internal_np::use_binary_mode), true);
if(binary)
@ -732,8 +732,8 @@ bool write_PLY(const std::string& fname,
/// \cond SKIP_IN_MANUAL
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_NP_CLASS& np = parameters::default_values())
{
return write_PLY(fname, point_set, std::string(), np);
}

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

@ -138,10 +138,10 @@ namespace IO {
\return `true` if the writing was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_XYZ(std::ostream& os,
const CGAL::Point_set_3<Point, Vector>& point_set,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
if(point_set.has_normal_map())
return Point_set_processing_3::internal::write_XYZ_PSP(os, point_set,
@ -176,8 +176,8 @@ bool write_XYZ(std::ostream& os,
\return `true` if the writing was successful, `false` otherwise.
*/
template <typename Point, typename Vector, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_XYZ(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Point, typename Vector, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_XYZ(const std::string& fname, const CGAL::Point_set_3<Point, Vector>& point_set, const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ofstream os(fname);
return write_XYZ(os, point_set, np);

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

@ -456,17 +456,17 @@ bool read_LAS_with_properties(std::istream& is,
*/
template <typename OutputIteratorValueType,
typename PointOutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_LAS(std::istream& is,
PointOutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
typedef Point_set_processing_3::Fake_point_range<OutputIteratorValueType> PointRange;
typedef typename CGAL::GetPointMap<PointRange, CGAL_BGL_NP_CLASS>::type PointMap;
typedef typename CGAL::GetPointMap<PointRange, CGAL_NP_CLASS>::type PointMap;
PointMap point_map = choose_parameter<PointMap>(get_parameter(np, internal_np::point_map));
return read_LAS_with_properties(is, output, make_las_point_reader(point_map));
@ -474,8 +474,8 @@ bool read_LAS(std::istream& is,
/// \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 = parameters::default_values(),
template <typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_LAS(std::istream& is, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values(),
typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
{
return read_LAS<typename value_type_traits<OutputIterator>::type>(is, output, np);
@ -520,10 +520,10 @@ bool read_LAS(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS&
*/
template <typename OutputIteratorValueType,
typename PointOutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_LAS(const std::string& filename,
PointOutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ifstream is(filename, std::ios::binary);
CGAL::IO::set_mode(is, CGAL::IO::BINARY);
@ -532,8 +532,8 @@ bool read_LAS(const std::string& filename,
/// \cond SKIP_IN_MANUAL
template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_LAS(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename OutputIterator,typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_LAS(const std::string& fname, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ifstream is(fname, std::ios::binary);
CGAL::IO::set_mode(is, CGAL::IO::BINARY);
@ -610,16 +610,16 @@ CGAL_DEPRECATED bool read_las_points_with_properties(std::istream& is,
*/
template <typename OutputIteratorValueType,
typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_las_points(std::istream& is,
OutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
typename CGAL::GetPointMap<Point_set_processing_3::Fake_point_range<OutputIteratorValueType>, CGAL_BGL_NP_CLASS>::type point_map =
choose_parameter<typename CGAL::GetPointMap<Point_set_processing_3::Fake_point_range<OutputIteratorValueType>, CGAL_BGL_NP_CLASS>::type>(get_parameter(np, internal_np::point_map));
typename CGAL::GetPointMap<Point_set_processing_3::Fake_point_range<OutputIteratorValueType>, CGAL_NP_CLASS>::type point_map =
choose_parameter<typename CGAL::GetPointMap<Point_set_processing_3::Fake_point_range<OutputIteratorValueType>, CGAL_NP_CLASS>::type>(get_parameter(np, internal_np::point_map));
return IO::read_LAS(is, output, make_las_point_reader(point_map));
}
@ -628,8 +628,8 @@ CGAL_DEPRECATED bool read_las_points(std::istream& is,
// variant with default output iterator value type
template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_las_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_las_points(std::istream& is, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_LAS<typename value_type_traits<OutputIterator>::type>(is, output, np);
}

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

@ -77,10 +77,10 @@ namespace IO {
*/
template <typename OutputIteratorValueType,
typename PointOutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(std::istream& is,
PointOutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename std::enable_if<CGAL::is_iterator<PointOutputIterator>::value>::type* = nullptr
#endif
@ -92,7 +92,7 @@ bool read_OFF(std::istream& is,
typedef Point_set_processing_3::Fake_point_range<OutputIteratorValueType> PointRange;
// basic geometric types
typedef Point_set_processing_3_np_helper<PointRange, CGAL_BGL_NP_CLASS> NP_helper;
typedef Point_set_processing_3_np_helper<PointRange, CGAL_NP_CLASS> NP_helper;
typedef typename NP_helper::Point_map PointMap;
typedef typename NP_helper::Normal_map NormalMap;
typedef typename NP_helper::Geom_traits Kernel;
@ -239,10 +239,10 @@ bool read_OFF(std::istream& is,
*/
template <typename OutputIteratorValueType,
typename PointOutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(const std::string& fname,
PointOutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename std::enable_if<CGAL::is_iterator<PointOutputIterator>::value>::type* = nullptr
#endif
@ -256,15 +256,15 @@ bool read_OFF(const std::string& fname,
// variants with default output iterator value type
template <typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(std::istream& is, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values(),
typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
{
return read_OFF<typename value_type_traits<OutputIterator>::type>(is, output, np);
}
template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
template <typename OutputIterator,typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(const std::string& fname, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values(),
typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
{
std::ifstream is(fname);
@ -422,10 +422,10 @@ bool read_off_points(std::istream& is, ///< input stream.
*/
template <typename OutputIteratorValueType,
typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off_points(std::istream& is,
OutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_OFF(is, output, np);
}
@ -439,8 +439,8 @@ CGAL_DEPRECATED bool read_off_points(std::istream& is, OutputIterator output)
}
// variant with default output iterator value type
template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off_points(std::istream& is, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_OFF(is, output, np);
}

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

@ -239,10 +239,10 @@ bool read_PLY_with_properties(std::istream& is,
*/
template <typename OutputIteratorValueType,
typename PointOutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(std::istream& is,
PointOutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename std::enable_if<CGAL::is_iterator<PointOutputIterator>::value>::type* = nullptr
#endif
@ -254,7 +254,7 @@ bool read_PLY(std::istream& is,
typedef Point_set_processing_3::Fake_point_range<OutputIteratorValueType> PointRange;
// basic geometric types
typedef Point_set_processing_3_np_helper<PointRange, CGAL_BGL_NP_CLASS> NP_helper;
typedef Point_set_processing_3_np_helper<PointRange, CGAL_NP_CLASS> NP_helper;
typedef typename NP_helper::Point_map PointMap;
typedef typename NP_helper::Normal_map NormalMap;
@ -321,10 +321,10 @@ bool read_PLY(std::istream& is,
*/
template <typename OutputIteratorValueType,
typename PointOutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(const std::string& fname,
PointOutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename std::enable_if<CGAL::is_iterator<PointOutputIterator>::value>::type* = nullptr
#endif
@ -348,15 +348,15 @@ bool read_PLY(const std::string& fname,
/// \cond SKIP_IN_MANUAL
// variants with default output iterator value type
template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
template <typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(std::istream& is, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values(),
typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
{
return read_PLY<typename value_type_traits<OutputIterator>::type>(is, output, np);
}
template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
template <typename OutputIterator,typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(const std::string& fname, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values(),
typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
{
return read_PLY<typename value_type_traits<OutputIterator>::type>(fname, output, np);
@ -458,8 +458,8 @@ CGAL_DEPRECATED bool read_ply_points_with_properties(std::istream& is, OutputIte
\deprecated This function is deprecated since \cgal 5.3,
\link PkgPointSetProcessing3IOPly `CGAL::IO::read_PLY()` \endlink should be used instead.
*/
template <typename OutputIteratorValueType, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_ply_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename OutputIteratorValueType, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_ply_points(std::istream& is, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_PLY(is, output, np);
}
@ -475,8 +475,8 @@ CGAL_DEPRECATED bool read_ply_points_with_properties(std::istream& is, OutputIte
// variant with default output iterator value type
template <typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_ply_points(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_ply_points(std::istream& is, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_PLY<typename value_type_traits<OutputIterator>::type>(is, output, np);
}

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

@ -74,10 +74,10 @@ namespace IO {
*/
template <typename OutputIteratorValueType,
typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_XYZ(std::istream& is,
OutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -85,7 +85,7 @@ bool read_XYZ(std::istream& is,
typedef Point_set_processing_3::Fake_point_range<OutputIteratorValueType> PointRange;
// basic geometric types
typedef Point_set_processing_3_np_helper<PointRange, CGAL_BGL_NP_CLASS> NP_helper;
typedef Point_set_processing_3_np_helper<PointRange, CGAL_NP_CLASS> NP_helper;
typedef typename NP_helper::Point_map PointMap;
typedef typename NP_helper::Normal_map NormalMap;
typedef typename NP_helper::Geom_traits Kernel;
@ -223,10 +223,10 @@ bool read_XYZ(std::istream& is,
*/
template <typename OutputIteratorValueType,
typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_XYZ(const std::string& fname,
OutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ifstream is(fname);
return read_XYZ<OutputIteratorValueType>(is, output, np);
@ -235,15 +235,15 @@ bool read_XYZ(const std::string& fname,
/// \cond SKIP_IN_MANUAL
// variants with default output iterator value type
template <typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_XYZ(std::istream& is, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
template <typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_XYZ(std::istream& is, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values(),
typename std::enable_if<CGAL::is_iterator<OutputIterator>::value>::type* = nullptr)
{
return read_XYZ<typename value_type_traits<OutputIterator>::type>(is, output, np);
}
template <typename OutputIterator,typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool read_XYZ(const std::string& fname, OutputIterator output, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename OutputIterator,typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_XYZ(const std::string& fname, OutputIterator output, const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ifstream is(fname);
return read_XYZ<typename value_type_traits<OutputIterator>::type>(is, output, np);
@ -406,20 +406,20 @@ bool read_xyz_points(std::istream& is, ///< input stream.
*/
template <typename OutputIteratorValueType,
typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_xyz_points(std::istream& is,
OutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_XYZ(is, output, np);
}
/// \cond SKIP_IN_MANUAL
template <typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_xyz_points(std::istream& is,
OutputIterator output,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_XYZ<typename value_type_traits<OutputIterator>::type>(is, output, np);
}

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

@ -277,10 +277,10 @@ bool write_LAS_with_properties(std::ostream& os, ///< output stream.
\sa \ref IOStreamLAS
\sa `write_LAS_with_properties()`
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_LAS(std::ostream& os,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif
@ -289,7 +289,7 @@ bool write_LAS(std::ostream& os,
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename CGAL::GetPointMap<PointRange, CGAL_BGL_NP_CLASS>::type PointMap;
typedef typename CGAL::GetPointMap<PointRange, CGAL_NP_CLASS>::type PointMap;
PointMap point_map = choose_parameter<PointMap>(get_parameter(np, internal_np::point_map));
if(!os)
@ -332,10 +332,10 @@ bool write_LAS(std::ostream& os,
\sa `write_LAS_with_properties()`
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_LAS(const std::string& filename,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif
@ -402,8 +402,8 @@ CGAL_DEPRECATED bool write_las_points_with_properties(std::ostream& os,
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_LAS()` should be used instead.
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_las_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_las_points(std::ostream& os, const PointRange& points, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_LAS(os, points, np);
}

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

@ -34,21 +34,21 @@ namespace CGAL {
namespace Point_set_processing_3 {
namespace internal {
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF_PSP(std::ostream& os,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = CGAL::parameters::default_values())
const CGAL_NP_CLASS& np = CGAL::parameters::default_values())
{
using CGAL::parameters::choose_parameter;
using CGAL::parameters::get_parameter;
using CGAL::parameters::is_default_parameter;
// basic geometric types
typedef Point_set_processing_3_np_helper<PointRange, CGAL_BGL_NP_CLASS> NP_helper;
typedef Point_set_processing_3_np_helper<PointRange, CGAL_NP_CLASS> NP_helper;
typedef typename NP_helper::Const_point_map PointMap;
typedef typename NP_helper::Normal_map NormalMap;
const bool has_normals = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::normal_t>());
const bool has_normals = !(is_default_parameter<CGAL_NP_CLASS, internal_np::normal_t>());
PointMap point_map = NP_helper::get_const_point_map(points, np);
NormalMap normal_map = NP_helper::get_normal_map(points, np);
@ -130,10 +130,10 @@ namespace IO {
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(std::ostream& os,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif
@ -186,10 +186,10 @@ bool write_OFF(std::ostream& os,
\sa \ref IOStreamOFF
*/
template <typename PointRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(const std::string& filename,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif
@ -301,8 +301,8 @@ bool write_off_points(std::ostream& os, ///< output stream.
\deprecated This function is deprecated since \cgal 5.3,
\link PkgPointSetProcessing3IOOff `CGAL::IO::write_OFF()` \endlink should be used instead.
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_off_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_off_points(std::ostream& os, const PointRange& points, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_OFF(os, points, np);
}

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

@ -184,10 +184,10 @@ template <typename PointRange,
\sa `write_PLY_with_properties()`
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif
@ -197,7 +197,7 @@ bool write_PLY(std::ostream& os,
using parameters::get_parameter;
// basic geometric types
typedef Point_set_processing_3_np_helper<PointRange, CGAL_BGL_NP_CLASS> NP_helper;
typedef Point_set_processing_3_np_helper<PointRange, CGAL_NP_CLASS> NP_helper;
typedef typename NP_helper::Const_point_map PointMap;
typedef typename NP_helper::Normal_map NormalMap;
@ -272,10 +272,10 @@ bool write_PLY(std::ostream& os,
\sa `write_PLY_with_properties()`
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(const std::string& filename,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif
@ -374,8 +374,8 @@ CGAL_DEPRECATED bool write_ply_points_with_properties(std::ostream& os, ///< out
\deprecated This function is deprecated since \cgal 5.3,
\link PkgPointSetProcessing3IOPly `CGAL::IO::write_PLY()` \endlink should be used instead.
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_ply_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_ply_points(std::ostream& os, const PointRange& points, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_PLY(os, points, np);
}

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

@ -88,10 +88,10 @@ namespace IO {
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_points(const std::string& fname,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
const CGAL_NP_CLASS& np = parameters::default_values(),
#ifndef DOXYGEN_RUNNING
typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif

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

@ -34,16 +34,16 @@ namespace CGAL {
namespace Point_set_processing_3 {
namespace internal {
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_XYZ_PSP(std::ostream& os,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = CGAL::parameters::default_values())
const CGAL_NP_CLASS& np = CGAL::parameters::default_values())
{
using CGAL::parameters::choose_parameter;
using CGAL::parameters::get_parameter;
// basic geometric types
typedef Point_set_processing_3_np_helper<PointRange, CGAL_BGL_NP_CLASS> NP_helper;
typedef Point_set_processing_3_np_helper<PointRange, CGAL_NP_CLASS> NP_helper;
typedef typename NP_helper::Const_point_map PointMap;
typedef typename NP_helper::Normal_map NormalMap;
@ -122,10 +122,10 @@ namespace IO {
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_XYZ(std::ostream& os,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif
@ -175,10 +175,10 @@ bool write_XYZ(std::ostream& os,
\returns `true` if writing was successful, `false` otherwise.
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_XYZ(const std::string& filename,
const PointRange& points,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PointRange> >::type* = nullptr
#endif
@ -287,8 +287,8 @@ bool write_xyz_points(std::ostream& os, ///< output stream.
\deprecated This function is deprecated since \cgal 5.3,
\link PkgPointSetProcessing3IOXyz `CGAL::write_XYZ()` \endlink should be used instead.
*/
template <typename PointRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_xyz_points(std::ostream& os, const PointRange& points, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename PointRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_xyz_points(std::ostream& os, const PointRange& points, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_XYZ(os, points, np);
}

8
Point_set_processing_3/include/CGAL/compute_average_spacing.h
View File

@ -145,24 +145,24 @@ compute_average_spacing(const typename NeighborQuery::Kernel::Point_3& query, //
*/
template <typename ConcurrencyTag,
typename PointRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS
typename CGAL_NP_TEMPLATE_PARAMETERS
>
#ifdef DOXYGEN_RUNNING
FT
#else
typename Point_set_processing_3_np_helper<PointRange, CGAL_BGL_NP_CLASS>::FT
typename Point_set_processing_3_np_helper<PointRange, CGAL_NP_CLASS>::FT
#endif
compute_average_spacing(
const PointRange& points,
unsigned int k,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename PointRange::const_iterator iterator;
typedef Point_set_processing_3_np_helper<PointRange, CGAL_BGL_NP_CLASS> NP_helper;
typedef Point_set_processing_3_np_helper<PointRange, CGAL_NP_CLASS> NP_helper;
typedef typename NP_helper::Const_point_map PointMap;
typedef typename NP_helper::Geom_traits Kernel;

26
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/connected_components.h
View File

@ -298,9 +298,9 @@ namespace internal {
// *
// */
template <typename PolygonMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t number_of_connected_components(const PolygonMesh& pmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<PolygonMesh>::faces_size_type faces_size_type;
typedef CGAL::dynamic_face_property_t<faces_size_type> Face_property_tag;
@ -600,12 +600,12 @@ std::size_t keep_large_connected_components(PolygonMesh& pmesh,
template <typename PolygonMesh
, typename ComponentRange
, typename FaceComponentMap
, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
, typename CGAL_NP_TEMPLATE_PARAMETERS>
void keep_or_remove_connected_components(PolygonMesh& pmesh
, const ComponentRange& components_to_keep
, const FaceComponentMap& fcm
, bool keep
, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
, const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -616,7 +616,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename boost::graph_traits<PolygonMesh>::edge_descriptor edge_descriptor;
typedef typename GetInitializedVertexIndexMap<PolygonMesh, CGAL_BGL_NP_CLASS>::type VertexIndexMap;
typedef typename GetInitializedVertexIndexMap<PolygonMesh, CGAL_NP_CLASS>::type VertexIndexMap;
VertexIndexMap vim = get_initialized_vertex_index_map(pmesh, np);
std::set<std::size_t> cc_to_keep;
@ -720,13 +720,13 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
for(vertex_descriptor v: vertices(pmesh))
if (!keep_vertex[v])
vertices_to_remove.push_back(v);
if ( is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_is_constrained_t>() )
if ( is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_is_constrained_t>() )
for (vertex_descriptor v : vertices_to_remove)
remove_vertex(v, pmesh);
else
{
typedef typename internal_np::Lookup_named_param_def<internal_np::vertex_is_constrained_t,
CGAL_BGL_NP_CLASS,
CGAL_NP_CLASS,
Static_boolean_property_map<vertex_descriptor, false> // default (not used)
>::type Vertex_map;
Vertex_map is_cst = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
@ -871,10 +871,10 @@ void remove_connected_components(PolygonMesh& pmesh
*/
template <typename PolygonMesh
, typename FaceRange
, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
, typename CGAL_NP_TEMPLATE_PARAMETERS>
void remove_connected_components(PolygonMesh& pmesh
, const FaceRange& components_to_remove
, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
, const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -885,7 +885,7 @@ void remove_connected_components(PolygonMesh& pmesh
typedef PolygonMesh PM;
typedef typename boost::graph_traits<PM>::face_descriptor face_descriptor;
typedef typename CGAL::GetInitializedFaceIndexMap<PolygonMesh, CGAL_BGL_NP_CLASS>::type FaceIndexMap;
typedef typename CGAL::GetInitializedFaceIndexMap<PolygonMesh, CGAL_NP_CLASS>::type FaceIndexMap;
FaceIndexMap fim = CGAL::get_initialized_face_index_map(pmesh, np);
boost::vector_property_map<std::size_t, FaceIndexMap> face_cc(static_cast<unsigned>(num_faces(pmesh)), fim);
@ -941,10 +941,10 @@ void remove_connected_components(PolygonMesh& pmesh
*/
template <typename PolygonMesh
, typename FaceRange
, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
, typename CGAL_NP_TEMPLATE_PARAMETERS>
void keep_connected_components(PolygonMesh& pmesh
, const FaceRange& components_to_keep
, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
, const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef PolygonMesh PM;
typedef typename boost::graph_traits<PM>::face_descriptor face_descriptor;
@ -952,7 +952,7 @@ void keep_connected_components(PolygonMesh& pmesh
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename CGAL::GetInitializedFaceIndexMap<PolygonMesh, CGAL_BGL_NP_CLASS>::type FaceIndexMap;
typedef typename CGAL::GetInitializedFaceIndexMap<PolygonMesh, CGAL_NP_CLASS>::type FaceIndexMap;
FaceIndexMap fim = CGAL::get_initialized_face_index_map(pmesh, np);
boost::vector_property_map<std::size_t, FaceIndexMap> face_cc(static_cast<unsigned>(num_faces(pmesh)), fim);

28
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/extrude.h
View File

@ -158,15 +158,15 @@ template <class InputMesh,
class OutputMesh,
class BottomFunctor,
class TopFunctor,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS_1,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS_2
class CGAL_NP_TEMPLATE_PARAMETERS_1,
class CGAL_NP_TEMPLATE_PARAMETERS_2
>
void extrude_mesh(const InputMesh& input,
OutputMesh& output,
const BottomFunctor& bot,
const TopFunctor& top,
const CGAL_BGL_NP_CLASS_1& np_in = parameters::default_values(),
const CGAL_BGL_NP_CLASS_2& np_out = parameters::default_values())
const CGAL_NP_CLASS_1& np_in = parameters::default_values(),
const CGAL_NP_CLASS_2& np_out = parameters::default_values())
{
typedef typename boost::graph_traits<InputMesh>::vertex_descriptor input_vertex_descriptor;
typedef typename boost::graph_traits<InputMesh>::halfedge_descriptor input_halfedge_descriptor;
@ -175,8 +175,8 @@ void extrude_mesh(const InputMesh& input,
typedef typename boost::graph_traits<OutputMesh>::halfedge_descriptor output_halfedge_descriptor;
CGAL_assertion(!CGAL::is_closed(input));
typedef typename GetVertexPointMap < OutputMesh, CGAL_BGL_NP_CLASS_2>::type VPMap;
typedef typename GetVertexPointMap < InputMesh, CGAL_BGL_NP_CLASS_1>::const_type IVPMap;
typedef typename GetVertexPointMap < OutputMesh, CGAL_NP_CLASS_2>::type VPMap;
typedef typename GetVertexPointMap < InputMesh, CGAL_NP_CLASS_1>::const_type IVPMap;
using parameters::get_parameter;
using parameters::choose_parameter;
@ -276,25 +276,25 @@ void extrude_mesh(const InputMesh& input,
*/
template <class InputMesh,
class OutputMesh,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS_1,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS_2>
class CGAL_NP_TEMPLATE_PARAMETERS_1,
class CGAL_NP_TEMPLATE_PARAMETERS_2>
void extrude_mesh(const InputMesh& input,
OutputMesh& output,
#ifdef DOXYGEN_RUNNING
Vector_3 v,
#else
typename GetGeomTraits<OutputMesh, CGAL_BGL_NP_CLASS_2>::type::Vector_3 v,
typename GetGeomTraits<OutputMesh, CGAL_NP_CLASS_2>::type::Vector_3 v,
#endif
const CGAL_BGL_NP_CLASS_1& np_in = parameters::default_values(),
const CGAL_BGL_NP_CLASS_2& np_out = parameters::default_values())
const CGAL_NP_CLASS_1& np_in = parameters::default_values(),
const CGAL_NP_CLASS_2& np_out = parameters::default_values())
{
typedef typename GetVertexPointMap < OutputMesh, CGAL_BGL_NP_CLASS_2>::type VPMap;
typedef typename GetVertexPointMap < OutputMesh, CGAL_NP_CLASS_2>::type VPMap;
VPMap output_vpm = parameters::choose_parameter(parameters::get_parameter(np_out, internal_np::vertex_point),
get_property_map(vertex_point, output));
extrude_impl::Const_dist_translation<
typename GetVertexPointMap<OutputMesh, CGAL_BGL_NP_CLASS_2>::type,
typename GetGeomTraits<OutputMesh, CGAL_BGL_NP_CLASS_2>::type::Vector_3> bot(output_vpm,
typename GetVertexPointMap<OutputMesh, CGAL_NP_CLASS_2>::type,
typename GetGeomTraits<OutputMesh, CGAL_NP_CLASS_2>::type::Vector_3> bot(output_vpm,
v);
extrude_impl::Identity_functor top;
extrude_mesh(input, output, bot,top, np_in, np_out);

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/snap.h
View File

@ -1357,10 +1357,10 @@ std::size_t snap_borders(TriangleMesh& tm_A,
template <typename ConcurrencyTag = CGAL::Sequential_tag,
typename TriangleMesh,
typename ToleranceMap,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t snap_borders(TriangleMesh& tm,
ToleranceMap tolerance_map,
const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
const CGAL_NP_CLASS& np = parameters::default_values(),
const typename std::enable_if_t<!std::is_same<TriangleMesh, ToleranceMap>::value>* = 0
)
{
@ -1376,9 +1376,9 @@ std::size_t snap_borders(TriangleMesh& tm,
template <typename ConcurrencyTag = CGAL::Sequential_tag,
typename TriangleMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t snap_borders(TriangleMesh& tm,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;

10
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/snap_vertices.h
View File

@ -1218,16 +1218,16 @@ std::size_t snap_vertices(const HalfedgeRange_A& halfedge_range_A,
template <typename ConcurrencyTag = CGAL::Sequential_tag,
typename HalfedgeRange_A, typename HalfedgeRange_B, typename PolygonMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS_1,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS_2>
typename CGAL_NP_TEMPLATE_PARAMETERS_1,
typename CGAL_NP_TEMPLATE_PARAMETERS_2>
std::size_t snap_vertices(const HalfedgeRange_A& halfedge_range_A,
PolygonMesh& tm_A,
const HalfedgeRange_B& halfedge_range_B,
PolygonMesh& tm_B,
const CGAL_BGL_NP_CLASS_1& np_A=parameters::default_values(),
const CGAL_BGL_NP_CLASS_2& np_B=parameters::default_values())
const CGAL_NP_CLASS_1& np_A=parameters::default_values(),
const CGAL_NP_CLASS_2& np_B=parameters::default_values())
{
typedef typename GetGeomTraits<PolygonMesh, CGAL_BGL_NP_CLASS_1>::type GT;
typedef typename GetGeomTraits<PolygonMesh, CGAL_NP_CLASS_1>::type GT;
typedef typename GT::FT FT;
typedef CGAL::dynamic_vertex_property_t<FT> Vertex_property_tag;
typedef typename boost::property_map<PolygonMesh, Vertex_property_tag>::type Tolerance_map;

18
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h
View File

@ -1251,12 +1251,12 @@ bool do_intersect(const Polyline& polyline1,
*
*/
template <class TriangleMesh,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS_1,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS_2>
class CGAL_NP_TEMPLATE_PARAMETERS_1,
class CGAL_NP_TEMPLATE_PARAMETERS_2>
bool do_intersect(const TriangleMesh& tm1,
const TriangleMesh& tm2,
const CGAL_BGL_NP_CLASS_1& np1 = parameters::default_values(),
const CGAL_BGL_NP_CLASS_2& np2 = parameters::default_values()
const CGAL_NP_CLASS_1& np1 = parameters::default_values(),
const CGAL_NP_CLASS_2& np2 = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, const typename boost::disable_if<
typename boost::has_range_const_iterator<TriangleMesh>::type
@ -1285,13 +1285,13 @@ bool do_intersect(const TriangleMesh& tm1,
if (test_overlap)
{
typedef typename GetVertexPointMap<TriangleMesh, CGAL_BGL_NP_CLASS_1>::const_type VertexPointMap1;
typedef typename GetVertexPointMap<TriangleMesh, CGAL_BGL_NP_CLASS_2>::const_type VertexPointMap2;
typedef typename GetVertexPointMap<TriangleMesh, CGAL_NP_CLASS_1>::const_type VertexPointMap1;
typedef typename GetVertexPointMap<TriangleMesh, CGAL_NP_CLASS_2>::const_type VertexPointMap2;
VertexPointMap1 vpm1 = choose_parameter(get_parameter(np1, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm1));
VertexPointMap2 vpm2 = choose_parameter(get_parameter(np2, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm2));
typedef typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS_1>::type GeomTraits;
typedef typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS_1>::type GeomTraits;
GeomTraits gt = choose_parameter<GeomTraits>(get_parameter(np1, internal_np::geom_traits));
return internal::is_mesh2_in_mesh1(tm1, tm2, vpm1, vpm2, gt) ||
@ -1402,10 +1402,10 @@ bool do_intersect(const TriangleMesh& tm,
*/
template <class TriangleMesh,
class Polyline,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
class CGAL_NP_TEMPLATE_PARAMETERS>
bool do_intersect(const TriangleMesh& tm,
const Polyline& polyline,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, const typename boost::disable_if<
typename boost::mpl::or_<

70
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/measure.h
View File

@ -38,8 +38,8 @@
namespace CGAL {
// workaround for area(face_range, tm) overload
template<typename CGAL_BGL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT, typename NP>
class GetGeomTraits<CGAL_BGL_NP_CLASS, NP>
template<typename CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT, typename NP>
class GetGeomTraits<CGAL_NP_CLASS, NP>
{
public:
struct type{};
@ -397,15 +397,15 @@ longest_border(const PolygonMesh& pmesh,
* @sa `area()`
*/
template<typename TriangleMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
#ifdef DOXYGEN_RUNNING
FT
#else
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT
#endif
face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
const TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -414,14 +414,14 @@ face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
CGAL_precondition(boost::graph_traits<TriangleMesh>::null_face() != f);
typename GetVertexPointMap<TriangleMesh, CGAL_BGL_NP_CLASS>::const_type
typename GetVertexPointMap<TriangleMesh, CGAL_NP_CLASS>::const_type
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
halfedge_descriptor hd = halfedge(f, tmesh);
halfedge_descriptor nhd = next(hd, tmesh);
typedef typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type GT;
typedef typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type GT;
GT traits = choose_parameter<GT>(get_parameter(np, internal_np::geom_traits));
return approximate_sqrt(traits.compute_squared_area_3_object()(get(vpm, source(hd, tmesh)),
@ -469,15 +469,15 @@ face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
* @sa `face_area()`
*/
template<typename TriangleMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
#ifdef DOXYGEN_RUNNING
FT
#else
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT
#endif
squared_face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
const TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -486,14 +486,14 @@ squared_face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
CGAL_precondition(boost::graph_traits<TriangleMesh>::null_face() != f);
typename GetVertexPointMap<TriangleMesh, CGAL_BGL_NP_CLASS>::const_type
typename GetVertexPointMap<TriangleMesh, CGAL_NP_CLASS>::const_type
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
halfedge_descriptor hd = halfedge(f, tmesh);
halfedge_descriptor nhd = next(hd, tmesh);
typedef typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type GT;
typedef typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type GT;
GT traits = choose_parameter<GT>(get_parameter(np, internal_np::geom_traits));
return traits.compute_squared_area_3_object()(get(vpm, source(hd, tmesh)),
@ -546,19 +546,19 @@ squared_face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
*/
template<typename FaceRange,
typename TriangleMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
#ifdef DOXYGEN_RUNNING
FT
#else
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT
#endif
area(FaceRange face_range,
const TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor;
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT result = 0;
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT result = 0;
for(face_descriptor f : face_range)
{
result += face_area(f, tmesh, np);
@ -607,13 +607,13 @@ area(FaceRange face_range,
* @sa `face_area()`
*/
template<typename TriangleMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
#ifdef DOXYGEN_RUNNING
FT
#else
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT
#endif
area(const TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
area(const TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::default_values())
{
return area(faces(tmesh), tmesh, np);
}
@ -654,14 +654,14 @@ area(const TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::defaul
* of `tmesh`.
*/
template<typename TriangleMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
#ifdef DOXYGEN_RUNNING
FT
#else
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT
#endif
volume(const TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
CGAL_assertion(is_triangle_mesh(tmesh));
CGAL_assertion(is_closed(tmesh));
@ -669,14 +669,14 @@ volume(const TriangleMesh& tmesh,
using parameters::choose_parameter;
using parameters::get_parameter;
typename GetVertexPointMap<TriangleMesh, CGAL_BGL_NP_CLASS>::const_type
typename GetVertexPointMap<TriangleMesh, CGAL_NP_CLASS>::const_type
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::Point_3 origin(0, 0, 0);
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::Point_3 origin(0, 0, 0);
typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor;
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT volume = 0;
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT volume = 0;
typename CGAL::Kernel_traits<typename property_map_value<TriangleMesh,
CGAL::vertex_point_t>::type>::Kernel::Compute_volume_3 cv3;
@ -727,27 +727,27 @@ volume(const TriangleMesh& tmesh,
*
*/
template<typename TriangleMesh,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
#ifdef DOXYGEN_RUNNING
FT
#else
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::FT
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::FT
#endif
face_aspect_ratio(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
const TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
CGAL_precondition(is_triangle(f, tmesh));
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type Geom_traits;
typedef typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type Geom_traits;
typedef typename Geom_traits::FT FT;
using parameters::choose_parameter;
using parameters::get_parameter;
typename GetVertexPointMap<TriangleMesh, CGAL_BGL_NP_CLASS>::const_type
typename GetVertexPointMap<TriangleMesh, CGAL_NP_CLASS>::const_type
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
@ -833,13 +833,13 @@ face_aspect_ratio(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
*
* @return the centroid of the domain bounded by `tmesh`.
*/
template<typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template<typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
#ifdef DOXYGEN_RUNNING
Point_3
#else
typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type::Point_3
typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type::Point_3
#endif
centroid(const TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
centroid(const TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::default_values())
{
// See: http://www2.imperial.ac.uk/~rn/centroid.pdf
@ -849,11 +849,11 @@ centroid(const TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::de
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename GetVertexPointMap<TriangleMesh, CGAL_BGL_NP_CLASS>::const_type Vpm;
typedef typename GetVertexPointMap<TriangleMesh, CGAL_NP_CLASS>::const_type Vpm;
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
typedef typename GetGeomTraits<TriangleMesh, CGAL_BGL_NP_CLASS>::type Kernel;
typedef typename GetGeomTraits<TriangleMesh, CGAL_NP_CLASS>::type Kernel;
typedef typename Kernel::Point_3 Point_3;
typedef typename Kernel::Vector_3 Vector_3;
typedef typename Kernel::Construct_translated_point_3 Construct_translated_point_3;

16
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h
View File

@ -908,12 +908,12 @@ bool remove_almost_degenerate_faces(const FaceRange& face_range,
return false;
}
template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool remove_almost_degenerate_faces(TriangleMesh& tmesh,
const double cap_threshold,
const double needle_threshold,
const double collapse_length_threshold,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
return remove_almost_degenerate_faces(faces(tmesh), tmesh, cap_threshold, needle_threshold,
collapse_length_threshold, np);
@ -1705,18 +1705,18 @@ bool remove_degenerate_edges(const EdgeRange& edge_range,
return all_removed;
}
template <typename EdgeRange, typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename EdgeRange, typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool remove_degenerate_edges(const EdgeRange& edge_range,
TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
std::set<typename boost::graph_traits<TriangleMesh>::face_descriptor> face_set;
return remove_degenerate_edges(edge_range, tmesh, face_set, np);
}
template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool remove_degenerate_edges(TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
std::set<typename boost::graph_traits<TriangleMesh>::face_descriptor> face_set;
return remove_degenerate_edges(edges(tmesh), tmesh, face_set, np);
@ -2579,9 +2579,9 @@ bool remove_degenerate_faces(const FaceRange& face_range,
return all_removed;
}
template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool remove_degenerate_faces(TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
return remove_degenerate_faces(faces(tmesh), tmesh, np);
}

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

@ -2104,8 +2104,8 @@ bool remove_self_intersections(const FaceRange& face_range,
return step < max_steps;
}
template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool remove_self_intersections(TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool remove_self_intersections(TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::default_values())
{
return remove_self_intersections(faces(tmesh), tmesh, np);
}

8
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/self_intersections.h
View File

@ -520,11 +520,11 @@ self_intersections(const FaceRange& face_range,
template <class ConcurrencyTag = Sequential_tag,
class TriangleMesh,
class FacePairOutputIterator,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
class CGAL_NP_TEMPLATE_PARAMETERS>
FacePairOutputIterator
self_intersections(const TriangleMesh& tmesh,
FacePairOutputIterator out,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
return self_intersections<ConcurrencyTag>(faces(tmesh), tmesh, out, np);
}
@ -632,9 +632,9 @@ bool does_self_intersect(const FaceRange& face_range,
*/
template <class ConcurrencyTag = Sequential_tag,
class TriangleMesh,
class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
class CGAL_NP_TEMPLATE_PARAMETERS>
bool does_self_intersect(const TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
return does_self_intersect<ConcurrencyTag>(faces(tmesh), tmesh, np);
}

16
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/shape_predicates.h
View File

@ -114,11 +114,11 @@ bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descript
/// \cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
template <typename EdgeRange, typename TriangleMesh, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename EdgeRange, typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_edges(const EdgeRange& edges,
const TriangleMesh& tm,
OutputIterator out,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<TriangleMesh>::edge_descriptor edge_descriptor;
@ -134,10 +134,10 @@ OutputIterator degenerate_edges(const EdgeRange& edges,
///
/// See above for the comprehensive description of the parameters.
///
template <typename TriangleMesh, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_edges(const TriangleMesh& tm,
OutputIterator out,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
)
{
return degenerate_edges(edges(tm), tm, out, np);
@ -229,11 +229,11 @@ bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::fac
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
template <typename FaceRange, typename TriangleMesh, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename FaceRange, typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_faces(const FaceRange& faces,
const TriangleMesh& tm,
OutputIterator out,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor;
@ -250,10 +250,10 @@ OutputIterator degenerate_faces(const FaceRange& faces,
///
/// See above for the comprehensive description of the parameters.
///
template <typename TriangleMesh, typename OutputIterator, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename TriangleMesh, typename OutputIterator, typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator degenerate_faces(const TriangleMesh& tm,
OutputIterator out,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
)
{
return degenerate_faces(faces(tm), tm, out, np);

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

@ -324,8 +324,8 @@ void smooth_mesh(const FaceRange& faces,
}
///\cond SKIP_IN_MANUAL
template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
void smooth_mesh(TriangleMesh& tmesh, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
void smooth_mesh(TriangleMesh& tmesh, const CGAL_NP_CLASS& np = parameters::default_values())
{
smooth_mesh(faces(tmesh), tmesh, np);
}

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

@ -197,10 +197,10 @@ void smooth_shape(const FaceRange& faces,
}
/// \cond SKIP_IN_MANUAL
template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
void smooth_shape(TriangleMesh& tmesh,
const double time,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
smooth_shape(faces(tmesh), tmesh, time, np);
}

52
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h
View File

@ -361,20 +361,20 @@ template <typename HalfedgeRange,
typename PolygonMesh,
typename HalfedgeKeeper,
typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator collect_duplicated_stitchable_boundary_edges(const HalfedgeRange& halfedge_range,
PolygonMesh& pmesh,
const HalfedgeKeeper& hd_kpr,
const bool per_cc,
OutputIterator out,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_BGL_NP_CLASS>::const_type VPM;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_NP_CLASS>::const_type VPM;
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
@ -1021,11 +1021,11 @@ std::size_t zip_boundary_cycle(typename boost::graph_traits<PolygonMesh>::halfed
/// High-level functions
template <typename PolygonMesh, typename CycleRepMaintainer, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PolygonMesh, typename CycleRepMaintainer, typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
PolygonMesh& pmesh,
CycleRepMaintainer& cycle_reps_maintainer,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename std::pair<halfedge_descriptor, halfedge_descriptor> halfedges_pair;
@ -1037,12 +1037,12 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_BGL_NP_CLASS>::const_type VPM;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_NP_CLASS>::const_type VPM;
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
typedef typename internal_np::Lookup_named_param_def<internal_np::halfedges_keeper_t,
CGAL_BGL_NP_CLASS,
CGAL_NP_CLASS,
Default_halfedges_keeper<PolygonMesh> >::type Halfedge_keeper;
const Halfedge_keeper hd_kpr = choose_parameter(get_parameter(np, internal_np::halfedges_keeper),
Default_halfedges_keeper<PolygonMesh>());
@ -1114,10 +1114,10 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
/// \sa `stitch_boundary_cycles()`
/// \sa `stitch_borders()`
///
template <typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PolygonMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
PolygonMesh& pmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
internal::Dummy_cycle_rep_maintainer<PolygonMesh> dummy_maintainer(pmesh);
return internal::stitch_boundary_cycle(h, pmesh, dummy_maintainer, np);
@ -1126,11 +1126,11 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
namespace internal {
template <typename BorderHalfedgeRange, typename PolygonMesh,
typename CycleRepMaintainer, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CycleRepMaintainer, typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_boundary_cycles(const BorderHalfedgeRange& boundary_cycle_representatives,
PolygonMesh& pmesh,
CycleRepMaintainer& cycle_reps_maintainer,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
@ -1175,10 +1175,10 @@ std::size_t stitch_boundary_cycles(const BorderHalfedgeRange& boundary_cycle_rep
/// \sa `stitch_boundary_cycle()`
/// \sa `stitch_borders()`
///
template <typename BorderHalfedgeRange, typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename BorderHalfedgeRange, typename PolygonMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_boundary_cycles(const BorderHalfedgeRange& boundary_cycle_representatives,
PolygonMesh& pmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
// If this API is called, we are not from stitch_borders() (otherwise there would be a maintainer)
// so there is only one pass and we don't carea bout maintaining the cycle subset
@ -1189,9 +1189,9 @@ std::size_t stitch_boundary_cycles(const BorderHalfedgeRange& boundary_cycle_rep
///\cond SKIP_IN_MANUAL
// convenience overloads
template <typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PolygonMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_boundary_cycles(PolygonMesh& pmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
@ -1242,10 +1242,10 @@ std::size_t stitch_boundary_cycles(PolygonMesh& pmesh,
*/
template <typename PolygonMesh,
typename HalfedgePairsRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_borders(PolygonMesh& pmesh,
const HalfedgePairsRange& hedge_pairs_to_stitch,
const CGAL_BGL_NP_CLASS& np = parameters::default_values(),
const CGAL_NP_CLASS& np = parameters::default_values(),
typename boost::enable_if<
typename boost::has_range_iterator<HalfedgePairsRange>
>::type* = 0)
@ -1253,7 +1253,7 @@ std::size_t stitch_borders(PolygonMesh& pmesh,
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_BGL_NP_CLASS>::const_type VPM;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_NP_CLASS>::const_type VPM;
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
@ -1264,11 +1264,11 @@ namespace internal {
template <typename BorderHalfedgeRange, typename PolygonMesh,
typename CycleRepMaintainer,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_borders(const BorderHalfedgeRange& boundary_cycle_representatives,
PolygonMesh& pmesh,
CycleRepMaintainer& cycle_maintainer,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
@ -1278,12 +1278,12 @@ std::size_t stitch_borders(const BorderHalfedgeRange& boundary_cycle_representat
if(boundary_cycle_representatives.size() == 0)
return 0;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_BGL_NP_CLASS>::const_type VPM;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_NP_CLASS>::const_type VPM;
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
typedef typename internal_np::Lookup_named_param_def<internal_np::halfedges_keeper_t,
CGAL_BGL_NP_CLASS,
CGAL_NP_CLASS,
Default_halfedges_keeper<PolygonMesh> >::type Halfedge_keeper;
const Halfedge_keeper hd_kpr = choose_parameter(get_parameter(np, internal_np::halfedges_keeper),
Default_halfedges_keeper<PolygonMesh>());
@ -1374,9 +1374,9 @@ std::size_t stitch_borders(const BorderHalfedgeRange& boundary_cycle_representat
/// \sa `stitch_boundary_cycle()`
/// \sa `stitch_boundary_cycles()`
///
template <typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PolygonMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_borders(PolygonMesh& pmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
@ -1435,10 +1435,10 @@ std::size_t stitch_borders(PolygonMesh& pmesh,
/// \sa `stitch_boundary_cycle()`
/// \sa `stitch_boundary_cycles()`
///
template <typename BorderHalfedgeRange, typename PolygonMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename BorderHalfedgeRange, typename PolygonMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
std::size_t stitch_borders(const BorderHalfedgeRange& boundary_cycle_representatives,
PolygonMesh& pmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<
typename boost::has_range_iterator<BorderHalfedgeRange>

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

@ -579,11 +579,11 @@ bool use_dt3 =
*/
template <typename PointRange,
typename OutputIterator,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
OutputIterator
triangulate_hole_polyline(const PointRange& points,
OutputIterator out,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename std::iterator_traits<
typename PointRange::iterator>::value_type Point;

6
Polygon_mesh_processing/include/CGAL/Polyhedral_envelope.h
View File

@ -2220,10 +2220,10 @@ public:
* the initial list of prisms.
* \todo apply that to the soup versions
*/
template <typename TriangleMesh, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename TriangleMesh, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool
operator()(const TriangleMesh& tmesh,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename std::enable_if<!boost::has_range_const_iterator<TriangleMesh>::value>::type* = 0
#endif
@ -2232,7 +2232,7 @@ public:
using parameters::choose_parameter;
using parameters::get_parameter;
typename GetVertexPointMap<TriangleMesh, CGAL_BGL_NP_CLASS>::const_type
typename GetVertexPointMap<TriangleMesh, CGAL_NP_CLASS>::const_type
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));

34
Polyhedron/include/CGAL/IO/Polyhedron_OFF_iostream.h
View File

@ -40,10 +40,10 @@ namespace IO {
template <class Traits,
class Items,
template < class T, class I, class A> class HDS,
class Alloc, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
class Alloc, class CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(std::istream& in,
Polyhedron_3<Traits, Items, HDS, Alloc>& P,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef typename boost::graph_traits<Polyhedron_3<Traits, Items, HDS, Alloc> >::vertex_descriptor Vertex;
@ -54,7 +54,7 @@ bool read_OFF(std::istream& in,
typedef typename Kernel_traits<Def_point>::Kernel Def_kernel;
typedef typename CGAL::GetVertexPointMap<Polyhedron_3<Traits, Items, HDS, Alloc>,
CGAL_BGL_NP_CLASS>::type VPM;
CGAL_NP_CLASS>::type VPM;
typedef typename boost::property_traits<VPM>::value_type Point;
typedef typename Kernel_traits<Point>::Kernel Kernel;
@ -66,17 +66,17 @@ bool read_OFF(std::istream& in,
const bool verbose = choose_parameter(get_parameter(np, internal_np::verbose), true);
if(!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>()))
if(!(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_color_map_t>()) ||
!(is_default_parameter<CGAL_NP_CLASS, internal_np::face_color_map_t>()) ||
!(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_normal_map_t>()) ||
!(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_texture_map_t>()))
{
return CGAL::IO::internal::read_OFF_BGL(in, P, np);
}
CGAL::scan_OFF(in, P, verbose);
if(!parameters::is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_point_t>())
if(!parameters::is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_point_t>())
{
Def_VPM def_vpm = get_property_map(CGAL::vertex_point, P);
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
@ -93,10 +93,10 @@ bool read_OFF(std::istream& in,
template <class Traits,
class Items,
template < class T, class I, class A> class HDS,
class Alloc, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
class Alloc, class CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(const std::string& fname,
Polyhedron_3<Traits, Items, HDS, Alloc>& P,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ifstream in(fname);
return read_OFF(in, P, np);
@ -123,26 +123,26 @@ namespace IO {
template < class Traits,
class Items,
template < class T, class I, class A> class HDS,
class Alloc, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
class Alloc, class CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(std::ostream& out,
const Polyhedron_3<Traits, Items, HDS, Alloc>& P,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
using parameters::is_default_parameter;
if(!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>()))
if(!(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_color_map_t>()) ||
!(is_default_parameter<CGAL_NP_CLASS, internal_np::face_color_map_t>()) ||
!(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_normal_map_t>()) ||
!(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_texture_map_t>()))
{
return CGAL::IO::internal::write_OFF_BGL(out, P, np);
}
// writes P to `out' in PRETTY, ASCII or BINARY format as the stream indicates.
File_header_OFF header(is_binary(out), ! is_pretty(out), false);
typename CGAL::GetVertexPointMap<Polyhedron_3<Traits, Items, HDS, Alloc>, CGAL_BGL_NP_CLASS>::const_type
typename CGAL::GetVertexPointMap<Polyhedron_3<Traits, Items, HDS, Alloc>, CGAL_NP_CLASS>::const_type
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, P));

14
STL_Extension/include/CGAL/Named_function_parameters.h
View File

@ -21,14 +21,14 @@
#include <type_traits>
#include <utility>
#define CGAL_BGL_NP_TEMPLATE_PARAMETERS NP_T=bool, typename NP_Tag=CGAL::internal_np::all_default_t, typename NP_Base=CGAL::internal_np::No_property
#define CGAL_BGL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT NP_T, typename NP_Tag, typename NP_Base
#define CGAL_BGL_NP_CLASS CGAL::Named_function_parameters<NP_T,NP_Tag,NP_Base>
#define CGAL_NP_TEMPLATE_PARAMETERS NP_T=bool, typename NP_Tag=CGAL::internal_np::all_default_t, typename NP_Base=CGAL::internal_np::No_property
#define CGAL_NP_TEMPLATE_PARAMETERS_NO_DEFAULT NP_T, typename NP_Tag, typename NP_Base
#define CGAL_NP_CLASS CGAL::Named_function_parameters<NP_T,NP_Tag,NP_Base>
#define CGAL_BGL_NP_TEMPLATE_PARAMETERS_1 NP_T1=bool, typename NP_Tag1=CGAL::internal_np::all_default_t, typename NP_Base1=CGAL::internal_np::No_property
#define CGAL_BGL_NP_CLASS_1 CGAL::Named_function_parameters<NP_T1,NP_Tag1,NP_Base1>
#define CGAL_BGL_NP_TEMPLATE_PARAMETERS_2 NP_T2=bool, typename NP_Tag2=CGAL::internal_np::all_default_t, typename NP_Base2=CGAL::internal_np::No_property
#define CGAL_BGL_NP_CLASS_2 CGAL::Named_function_parameters<NP_T2,NP_Tag2,NP_Base2>
#define CGAL_NP_TEMPLATE_PARAMETERS_1 NP_T1=bool, typename NP_Tag1=CGAL::internal_np::all_default_t, typename NP_Base1=CGAL::internal_np::No_property
#define CGAL_NP_CLASS_1 CGAL::Named_function_parameters<NP_T1,NP_Tag1,NP_Base1>
#define CGAL_NP_TEMPLATE_PARAMETERS_2 NP_T2=bool, typename NP_Tag2=CGAL::internal_np::all_default_t, typename NP_Base2=CGAL::internal_np::No_property
#define CGAL_NP_CLASS_2 CGAL::Named_function_parameters<NP_T2,NP_Tag2,NP_Base2>
namespace CGAL {
namespace internal_np{

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

@ -40,12 +40,12 @@ namespace IO {
/// \cond SKIP_IN_MANUAL
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(std::istream& is,
std::pair<std::string, std::string>& name_and_color,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef typename boost::range_value<PointRange>::type Point;
typedef typename boost::range_value<PolygonRange>::type Poly;
@ -189,11 +189,11 @@ bool read_GOCAD(std::istream& is,
*
* \returns `true` if the reading was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(std::istream& is,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -234,11 +234,11 @@ bool read_GOCAD(std::istream& is,
*
* \returns `true` if the reading was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_GOCAD(const std::string& fname,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -258,19 +258,19 @@ namespace internal {
template <typename PointRange,
typename PolygonRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_GOCAD(std::ostream& os,
const char* fname,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef typename boost::range_value<PolygonRange>::type Poly;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename CGAL::GetPointMap<PointRange, CGAL_BGL_NP_CLASS>::type PointMap;
typedef typename CGAL::GetPointMap<PointRange, CGAL_NP_CLASS>::type PointMap;
PointMap point_map = choose_parameter<PointMap>(get_parameter(np, internal_np::point_map));
if(!os.good())
@ -342,11 +342,11 @@ bool write_GOCAD(std::ostream& os,
*/
template <typename PointRange,
typename PolygonRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_GOCAD(std::ostream& os,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -384,11 +384,11 @@ bool write_GOCAD(std::ostream& os,
*/
template <typename PointRange,
typename PolygonRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_GOCAD(const std::string& fname,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif

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

@ -206,11 +206,11 @@ bool read_OBJ(std::istream& is,
/// \cgalNamedParamsEnd
///
/// \returns `true` if the reading was successful, `false` otherwise.
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OBJ(std::istream& is,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -251,11 +251,11 @@ bool read_OBJ(std::istream& is,
/// \cgalNamedParamsEnd
///
/// \returns `true` if the reading was successful, `false` otherwise.
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OBJ(const std::string& fname,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -299,11 +299,11 @@ bool read_OBJ(const std::string& fname,
*/
template <typename PointRange,
typename PolygonRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OBJ(std::ostream& os,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -343,11 +343,11 @@ bool write_OBJ(std::ostream& os,
*/
template <typename PointRange,
typename PolygonRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OBJ(const std::string& fname,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif

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

@ -178,11 +178,11 @@ bool read_OFF(std::istream& is,
*
* \returns `true` if the reading was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(std::istream& is,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -231,11 +231,11 @@ bool read_OFF(std::istream& is,
*
* \returns `true` if the reading was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(const std::string& fname,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -276,11 +276,11 @@ bool read_OFF(const std::string& fname,
*
* \return `true` if the writing was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(std::ostream& os,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -317,11 +317,11 @@ bool write_OFF(std::ostream& os,
*
* \return `true` if the writing was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(const std::string& fname,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif

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

@ -303,11 +303,11 @@ bool read_PLY(std::istream& is,
*
* \returns `true` if the reading was successful, `false` otherwise.
*/
template <class PointRange, class PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <class PointRange, class PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(std::istream& is,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -363,11 +363,11 @@ bool read_PLY(std::istream& is,
*
* \returns `true` if the reading was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_PLY(const std::string& fname,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -426,11 +426,11 @@ bool read_PLY(const std::string& fname,
*
* \return `true` if the writing was successful, `false` otherwise.
*/
template <class PointRange, class PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS >
template <class PointRange, class PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS >
bool write_PLY(std::ostream& out,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif
@ -505,11 +505,11 @@ bool write_PLY(std::ostream& out,
*
* \return `true` if the writing was successful, `false` otherwise.
*/
template <class PointRange, class PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS >
template <class PointRange, class PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS >
bool write_PLY(const std::string& fname,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<PolygonRange> >::type* = nullptr
#endif

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

@ -68,11 +68,11 @@ namespace IO {
*
* \returns `true` if the reading was successful, `false` otherwise.
*/
template <typename PointRange, typename TriangleRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename TriangleRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_STL(std::istream& is,
PointRange& points,
TriangleRange& facets,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<TriangleRange> >::type* = nullptr
#endif
@ -202,11 +202,11 @@ bool read_STL(std::istream& is,
*
* \returns `true` if the reading was successful, `false` otherwise.
*/
template <typename PointRange, typename TriangleRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename TriangleRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_STL(const std::string& fname,
PointRange& points,
TriangleRange& facets,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<TriangleRange> >::type* = nullptr
#endif
@ -268,11 +268,11 @@ bool read_STL(const std::string& fname,
*
* \return `true` if the writing was successful, `false` otherwise.
*/
template <typename PointRange, typename TriangleRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename TriangleRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_STL(std::ostream& os,
const PointRange& points,
const TriangleRange& facets,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<TriangleRange> >::type* = nullptr
#endif
@ -283,7 +283,7 @@ bool write_STL(std::ostream& os,
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename CGAL::GetPointMap<PointRange, CGAL_BGL_NP_CLASS>::type PointMap;
typedef typename CGAL::GetPointMap<PointRange, CGAL_NP_CLASS>::type PointMap;
PointMap point_map = choose_parameter<PointMap>(get_parameter(np, internal_np::point_map));
typedef typename boost::property_traits<PointMap>::value_type Point;
@ -376,11 +376,11 @@ bool write_STL(std::ostream& os,
*
* \return `true` if the writing was successful, `false` otherwise.
*/
template <typename PointRange, typename TriangleRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename TriangleRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_STL(const std::string& fname,
const PointRange& points,
const TriangleRange& facets,
const CGAL_BGL_NP_CLASS& np = parameters::default_values()
const CGAL_NP_CLASS& np = parameters::default_values()
#ifndef DOXYGEN_RUNNING
, typename boost::enable_if<internal::is_Range<TriangleRange> >::type* = nullptr
#endif

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

@ -374,11 +374,11 @@ void write_soup_polys_points(std::ostream& os,
*/
template <typename PointRange,
typename PolygonRange,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_VTP(std::ostream& os,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::get_parameter;
using parameters::choose_parameter;
@ -460,11 +460,11 @@ bool write_VTP(std::ostream& os,
*
* \return `true` if the writing was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_VTP(const std::string& fname,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
const bool binary = CGAL::parameters::choose_parameter(CGAL::parameters::get_parameter(np, internal_np::use_binary_mode), true);
if(binary)

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

@ -73,11 +73,11 @@ namespace IO {
*
* \return `true` if reading was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_polygon_soup(const std::string& fname,
PointRange& points,
PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
const bool verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbose), false);
@ -153,11 +153,11 @@ bool read_polygon_soup(const std::string& fname,
*
* \return `true` if writing was successful, `false` otherwise.
*/
template <typename PointRange, typename PolygonRange, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename PointRange, typename PolygonRange, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_polygon_soup(const std::string& fname,
const PointRange& points,
const PolygonRange& polygons,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
const bool verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbose), false);

86
Surface_mesh/include/CGAL/Surface_mesh/IO/OFF.h
View File

@ -92,17 +92,17 @@ public:
NamedParameters, DefaultMap_const>::type const_type;
};
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF_with_or_without_fcolors(std::istream& is,
Surface_mesh<Point>& sm,
const CGAL::File_scanner_OFF& scanner,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef Surface_mesh<Point> Mesh;
typedef typename Mesh::Face_index Face_index;
typedef CGAL::IO::Color Color;
typedef typename GetFaceColorMap<Mesh, CGAL_BGL_NP_CLASS>::type FCM;
typedef typename GetFaceColorMap<Mesh, CGAL_NP_CLASS>::type FCM;
using parameters::choose_parameter;
using parameters::is_default_parameter;
@ -110,7 +110,7 @@ bool read_OFF_with_or_without_fcolors(std::istream& is,
typename Mesh::template Property_map<Face_index, Color> fcm;
bool is_fcm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>());
bool is_fcm_requested = !(is_default_parameter<CGAL_NP_CLASS, internal_np::face_color_map_t>());
if(!is_fcm_requested && scanner.has_colors())
{
bool created;
@ -130,18 +130,18 @@ bool read_OFF_with_or_without_fcolors(std::istream& is,
}
}
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF_with_or_without_vtextures(std::istream& is,
Surface_mesh<Point>& sm,
const CGAL::File_scanner_OFF& scanner,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef Surface_mesh<Point> Mesh;
typedef typename Mesh::Vertex_index Vertex_index;
typedef typename GetK<Surface_mesh<Point>, CGAL_BGL_NP_CLASS>::Kernel K;
typedef typename GetK<Surface_mesh<Point>, CGAL_NP_CLASS>::Kernel K;
typedef typename K::Point_2 Texture;
typedef typename GetVertexTextureMap<Mesh, K, CGAL_BGL_NP_CLASS>::type VTM;
typedef typename GetVertexTextureMap<Mesh, K, CGAL_NP_CLASS>::type VTM;
using parameters::choose_parameter;
using parameters::is_default_parameter;
@ -149,7 +149,7 @@ bool read_OFF_with_or_without_vtextures(std::istream& is,
typename Mesh::template Property_map<Vertex_index, Texture> vtm;
bool is_vtm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>());
bool is_vtm_requested = !(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_texture_map_t>());
if(!is_vtm_requested && scanner.has_textures())
{
bool created;
@ -169,17 +169,17 @@ bool read_OFF_with_or_without_vtextures(std::istream& is,
}
}
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF_with_or_without_vcolors(std::istream& is,
Surface_mesh<Point>& sm,
const CGAL::File_scanner_OFF& scanner,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef Surface_mesh<Point> Mesh;
typedef typename Mesh::Vertex_index Vertex_index;
typedef CGAL::IO::Color Color;
typedef typename GetVertexColorMap<Mesh, CGAL_BGL_NP_CLASS>::type VCM;
typedef typename GetVertexColorMap<Mesh, CGAL_NP_CLASS>::type VCM;
using parameters::choose_parameter;
using parameters::is_default_parameter;
@ -187,7 +187,7 @@ bool read_OFF_with_or_without_vcolors(std::istream& is,
typename Mesh::template Property_map<Vertex_index, Color> vcm;
bool is_vcm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>());
bool is_vcm_requested = !(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_color_map_t>());
if(!is_vcm_requested && scanner.has_colors())
{
bool created;
@ -207,18 +207,18 @@ bool read_OFF_with_or_without_vcolors(std::istream& is,
}
}
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF_with_or_without_vnormals(std::istream& is,
Surface_mesh<Point>& sm,
const CGAL::File_scanner_OFF& scanner,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef Surface_mesh<Point> Mesh;
typedef typename Mesh::Vertex_index Vertex_index;
typedef typename GetK<Surface_mesh<Point>, CGAL_BGL_NP_CLASS>::Kernel K;
typedef typename GetK<Surface_mesh<Point>, CGAL_NP_CLASS>::Kernel K;
typedef typename K::Vector_3 Normal;
typedef typename GetVertexNormalMap<Mesh, K, CGAL_BGL_NP_CLASS>::type VNM;
typedef typename GetVertexNormalMap<Mesh, K, CGAL_NP_CLASS>::type VNM;
using parameters::choose_parameter;
using parameters::is_default_parameter;
@ -226,7 +226,7 @@ bool read_OFF_with_or_without_vnormals(std::istream& is,
typename Mesh::template Property_map<Vertex_index, Normal> vnm;
bool is_vnm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>());
bool is_vnm_requested = !(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_normal_map_t>());
if(!is_vnm_requested && scanner.has_normals())
{
bool created;
@ -319,10 +319,10 @@ bool read_OFF_with_or_without_vnormals(std::istream& is,
/// the `failbit` of `is` is set and the mesh cleared.
///
template <typename Point,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(std::istream& is,
Surface_mesh<Point>& sm,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -340,10 +340,10 @@ bool read_OFF(std::istream& is,
}
template <typename Point,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool read_OFF(const std::string& fname,
Surface_mesh<Point>& sm,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
std::ifstream in(fname.c_str());
return read_OFF(in, sm, np);
@ -357,8 +357,8 @@ bool read_OFF(const std::string& fname,
\ingroup PkgSurfaceMeshIOFuncDeprecated
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::read_OFF(std::istream&, const Surface_mesh<Point>&)` should be used instead.
*/
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off(std::istream& is, Surface_mesh<Point>& sm, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool read_off(std::istream& is, Surface_mesh<Point>& sm, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::read_OFF(is, sm, np);
}
@ -381,10 +381,10 @@ CGAL_DEPRECATED bool read_off(Surface_mesh<Point>& sm, const std::string& filena
namespace IO {
namespace internal {
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF_with_or_without_fcolors(std::ostream& os,
const Surface_mesh<Point>& sm,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef Surface_mesh<Point> Mesh;
typedef typename Mesh::Face_index Face_index;
@ -394,7 +394,7 @@ bool write_OFF_with_or_without_fcolors(std::ostream& os,
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_fcolors = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>());
const bool has_fcolors = !(is_default_parameter<CGAL_NP_CLASS, internal_np::face_color_map_t>());
typename Mesh::template Property_map<Face_index, Color> fcolors;
bool has_internal_fcolors;
@ -406,22 +406,22 @@ bool write_OFF_with_or_without_fcolors(std::ostream& os,
return write_OFF_BGL(os, sm, np);
}
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF_with_or_without_vtextures(std::ostream& os,
const Surface_mesh<Point>& sm,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef Surface_mesh<Point> Mesh;
typedef typename Mesh::Vertex_index Vertex_index;
typedef typename GetK<Surface_mesh<Point>, CGAL_BGL_NP_CLASS>::Kernel K;
typedef typename GetK<Surface_mesh<Point>, CGAL_NP_CLASS>::Kernel K;
typedef typename K::Point_2 Texture;
using parameters::choose_parameter;
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_vtextures = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>());
const bool has_vtextures = !(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_texture_map_t>());
typename Mesh::template Property_map<Vertex_index, Texture> vtextures;
bool has_internal_vtextures;
@ -433,10 +433,10 @@ bool write_OFF_with_or_without_vtextures(std::ostream& os,
return write_OFF_with_or_without_fcolors(os, sm, np);
}
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF_with_or_without_vcolors(std::ostream& os,
const Surface_mesh<Point>& sm,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef Surface_mesh<Point> Mesh;
typedef typename Mesh::Vertex_index Vertex_index;
@ -446,7 +446,7 @@ bool write_OFF_with_or_without_vcolors(std::ostream& os,
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_vcolors = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>());
const bool has_vcolors = !(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_color_map_t>());
typename Mesh::template Property_map<Vertex_index, Color> vcolors;
bool has_internal_vcolors;
@ -458,22 +458,22 @@ bool write_OFF_with_or_without_vcolors(std::ostream& os,
return write_OFF_with_or_without_vtextures(os, sm, np);
}
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF_with_or_without_vnormals(std::ostream& os,
const Surface_mesh<Point>& sm,
const CGAL_BGL_NP_CLASS& np)
const CGAL_NP_CLASS& np)
{
typedef Surface_mesh<Point> Mesh;
typedef typename Mesh::Vertex_index Vertex_index;
typedef typename GetK<Surface_mesh<Point>, CGAL_BGL_NP_CLASS>::Kernel K;
typedef typename GetK<Surface_mesh<Point>, CGAL_NP_CLASS>::Kernel K;
typedef typename K::Vector_3 Normal;
using parameters::choose_parameter;
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_vnormals = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>());
const bool has_vnormals = !(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_normal_map_t>());
typename Mesh::template Property_map<Vertex_index, Normal> vnormals;
bool has_internal_vnormals;
@ -554,16 +554,16 @@ bool write_OFF_with_or_without_vnormals(std::ostream& os,
///
/// \returns `true` if writing was successful, `false` otherwise.
///
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_OFF(std::ostream& os,
const Surface_mesh<Point>& sm,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_vpoints = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_point_t>());
const bool has_vpoints = !(is_default_parameter<CGAL_NP_CLASS, internal_np::vertex_point_t>());
if(has_vpoints)
return internal::write_OFF_with_or_without_vnormals(os, sm, np);
@ -578,8 +578,8 @@ bool write_OFF(std::ostream& os,
\ingroup PkgSurfaceMeshIOFuncDeprecated
\deprecated This function is deprecated since \cgal 5.3, `CGAL::IO::write_OFF(std::ostream&, const Surface_mesh<Point>&)` should be used instead.
*/
template <typename Point, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_off(std::ostream& os, const Surface_mesh<Point>& sm, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename Point, typename CGAL_NP_TEMPLATE_PARAMETERS>
CGAL_DEPRECATED bool write_off(std::ostream& os, const Surface_mesh<Point>& sm, const CGAL_NP_CLASS& np = parameters::default_values())
{
return IO::write_OFF(os, sm, np);
}

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

@ -907,11 +907,11 @@ namespace IO {
///
/// \returns `true` if writing was successful, `false` otherwise.
template <typename P,
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os,
const Surface_mesh<P>& sm,
const std::string& comments,
const CGAL_BGL_NP_CLASS& np = parameters::default_values())
const CGAL_NP_CLASS& np = parameters::default_values())
{
typedef Surface_mesh<P> SMesh;
typedef typename SMesh::Vertex_index VIndex;
@ -1106,8 +1106,8 @@ bool write_PLY(std::ostream& os,
/// \cond SKIP_IN_MANUAL
template <typename P, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os, const Surface_mesh<P>& sm, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
template <typename P, typename CGAL_NP_TEMPLATE_PARAMETERS>
bool write_PLY(std::ostream& os, const Surface_mesh<P>& sm, const CGAL_NP_CLASS& np = parameters::default_values())
{
std::string unused_comment;
return write_PLY(os, sm, unused_comment, np);