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

Merge branch 'CGAL-named_function_parameters-4.14' into master 

Conflicts resolved by hand
This commit is contained in:
Sébastien Loriot 2019-07-28 22:57:14 +02:00
parent 7b1889b87e aa47744c36
commit 25a05e9f4c
91 changed files with 1202 additions and 1097 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Arrangement_on_surface_2/include/CGAL/graph_traits_Arrangement_2.h
View File

@ -33,7 +33,7 @@
*/
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <boost/graph/graph_concepts.hpp>
#include <CGAL/boost/iterator/counting_iterator.hpp>

2
Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_2.h
View File

@ -34,7 +34,7 @@
*/
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/Arrangement_2.h>
#include <CGAL/Arrangement_2/graph_traits_dual.h>

2
Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_2.h
View File

@ -34,7 +34,7 @@
*/
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/Arrangement_on_surface_2.h>
#include <CGAL/Arrangement_2/graph_traits_dual.h>

2
Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_on_surface_with_history_2.h
View File

@ -35,7 +35,7 @@
*/
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/Arrangement_on_surface_with_history_2.h>
#include <CGAL/Arrangement_2/graph_traits_dual.h>

2
Arrangement_on_surface_2/include/CGAL/graph_traits_dual_arrangement_with_history_2.h
View File

@ -35,7 +35,7 @@
*/
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/Arrangement_with_history_2.h>
#include <CGAL/Arrangement_2/graph_traits_dual.h>

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

@ -24,7 +24,7 @@
#include <CGAL/assertions.h>
#include <CGAL/boost/graph/properties.h>
#include <CGAL/boost/graph/iterator.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/Dynamic_property_map.h>
#include <CGAL/assertions.h>
@ -146,9 +146,9 @@ struct Face_filtered_graph
#endif
)
: _graph(const_cast<Graph&>(graph))
, fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph)))
, fimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph)))
{
set_selected_faces(selected_face_patch_indices, face_patch_index_map);
}
@ -201,9 +201,9 @@ struct Face_filtered_graph
const CGAL_BGL_NP_CLASS& np
)
: _graph(const_cast<Graph&>(graph))
, fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph)))
, fimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph)))
{
set_selected_faces(selected_face_patch_index, face_patch_index_map);
}
@ -246,9 +246,9 @@ struct Face_filtered_graph
const FaceRange& selected_faces,
const CGAL_BGL_NP_CLASS& np)
: _graph(const_cast<Graph&>(graph))
, fimap(boost::choose_param(get_param(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(boost::choose_param(get_param(np, boost::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(boost::choose_param(get_param(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph)))
, fimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(parameters::choose_parameter(parameters::get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph)))
{
set_selected_faces(selected_faces);
}

18
BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h
View File

@ -26,7 +26,7 @@
#include <CGAL/boost/graph/copy_face_graph.h>
#include <CGAL/boost/graph/Face_filtered_graph.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/assertions.h>
@ -51,8 +51,8 @@ void partition_dual_graph(const TriangleMesh& tm,
CGAL_precondition(CGAL::is_triangle_mesh(tm));
CGAL_precondition_msg(nparts > 1, ("Partitioning requires a number of parts > 1"));
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
@ -60,7 +60,7 @@ void partition_dual_graph(const TriangleMesh& tm,
// vertex index map
typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap<TriangleMesh, NamedParameters>::type Indices;
Indices indices = choose_param(get_param(np, internal_np::vertex_index),
Indices indices = choose_parameter(get_parameter(np, internal_np::vertex_index),
get_const_property_map(boost::vertex_index, tm));
idx_t nn = static_cast<idx_t>(num_vertices(tm));
@ -119,8 +119,8 @@ void partition_dual_graph(const TriangleMesh& tm,
Output_vertex_partition_ids vo;
Output_face_partition_ids fo;
vo(tm, indices, npart, get_param(np, internal_np::vertex_partition_id));
fo(tm, epart, get_param(np, internal_np::face_partition_id));
vo(tm, indices, npart, get_parameter(np, internal_np::vertex_partition_id));
fo(tm, epart, get_parameter(np, internal_np::face_partition_id));
delete[] eptr;
delete[] eind;
@ -131,7 +131,7 @@ void partition_dual_graph(const TriangleMesh& tm,
template<typename TriangleMesh, typename NamedParameters>
void partition_dual_graph(const TriangleMesh& tm, int nparts,
const boost::param_not_found, // no METIS options were passed
const internal_np::Param_not_found, // no METIS options were passed
const NamedParameters& np)
{
idx_t options[METIS_NOPTIONS];
@ -180,9 +180,9 @@ void partition_dual_graph(const TriangleMesh& tm, int nparts,
template<typename TriangleMesh, typename NamedParameters>
void partition_dual_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np)
{
using boost::get_param;
using parameters::get_parameter;
return partition_dual_graph(tm, nparts, get_param(np, internal_np::METIS_options), np);
return partition_dual_graph(tm, nparts, get_parameter(np, internal_np::METIS_options), np);
}
template<typename TriangleMesh>

22
BGL/include/CGAL/boost/graph/METIS/partition_graph.h
View File

@ -24,7 +24,7 @@
#include <CGAL/boost/graph/copy_face_graph.h>
#include <CGAL/boost/graph/Face_filtered_graph.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/assertions.h>
@ -44,7 +44,7 @@ struct Output_vertex_partition_ids
{
template<typename TriangleMesh, typename Indices>
void operator()(const TriangleMesh&, const Indices,
idx_t const * const, boost::param_not_found) { }
idx_t const * const, internal_np::Param_not_found) { }
template<typename TriangleMesh,
typename Indices,
@ -64,7 +64,7 @@ struct Output_face_partition_ids
{
template<typename TriangleMesh>
void operator()(const TriangleMesh&,
idx_t const * const, boost::param_not_found) { }
idx_t const * const, internal_np::Param_not_found) { }
template<typename TriangleMesh, typename FacePartitionIDPmap>
void operator()(const TriangleMesh& tm, idx_t const * const epart,
@ -86,8 +86,8 @@ void partition_graph(const TriangleMesh& tm,
CGAL_precondition(CGAL::is_triangle_mesh(tm));
CGAL_precondition_msg(nparts > 1, ("Partitioning requires a number of parts > 1"));
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
@ -95,7 +95,7 @@ void partition_graph(const TriangleMesh& tm,
//Vertex index map
typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap<TriangleMesh, NamedParameters>::type Indices;
Indices indices = choose_param(get_param(np, internal_np::vertex_index),
Indices indices = choose_parameter(get_parameter(np, internal_np::vertex_index),
get_const_property_map(boost::vertex_index, tm));
idx_t nn = static_cast<idx_t>(num_vertices(tm));
@ -151,8 +151,8 @@ void partition_graph(const TriangleMesh& tm,
Output_vertex_partition_ids vo;
Output_face_partition_ids fo;
vo(tm, indices, npart, get_param(np, internal_np::vertex_partition_id));
fo(tm, epart, get_param(np, internal_np::face_partition_id));
vo(tm, indices, npart, get_parameter(np, internal_np::vertex_partition_id));
fo(tm, epart, get_parameter(np, internal_np::face_partition_id));
delete[] eptr;
delete[] eind;
@ -163,7 +163,7 @@ void partition_graph(const TriangleMesh& tm,
template<typename TriangleMesh, typename NamedParameters>
void partition_graph(const TriangleMesh& tm, int nparts,
const boost::param_not_found, // no METIS options were passed
const internal_np::Param_not_found, // no METIS options were passed
const NamedParameters& np)
{
idx_t options[METIS_NOPTIONS];
@ -212,9 +212,9 @@ void partition_graph(const TriangleMesh& tm, int nparts,
template<typename TriangleMesh, typename NamedParameters>
void partition_graph(const TriangleMesh& tm, int nparts, const NamedParameters& np)
{
using boost::get_param;
using parameters::get_parameter;
return partition_graph(tm, nparts, get_param(np, internal_np::METIS_options), np);
return partition_graph(tm, nparts, get_parameter(np, internal_np::METIS_options), np);
}
template<typename TriangleMesh>

237
BGL/include/CGAL/boost/graph/Named_function_parameters.h Normal file
View File

@ -0,0 +1,237 @@
// Copyright (c) 2019 GeometryFactory (France). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3 of the License,
// or (at your option) any later version.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
// SPDX-License-Identifier: LGPL-3.0+
//
//
// Author(s) : Sebastien Loriot
#ifndef CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H
#define CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H
#include <CGAL/basic.h>
#include <boost/type_traits/is_same.hpp>
#include <boost/mpl/if.hpp>
#define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base
#define CGAL_BGL_NP_CLASS CGAL::Named_function_parameters<T,Tag,Base>
namespace CGAL {
namespace internal_np{
struct No_property {};
struct Param_not_found {};
enum all_default_t { all_default };
// define enum types and values for new named parameters
#define CGAL_add_named_parameter(X, Y, Z) \
enum X { Y };
#include <CGAL/boost/graph/parameters_interface.h>
#undef CGAL_add_named_parameter
template <typename T, typename Tag, typename Base>
struct Named_params_impl : Base
{
T v; // copy of the parameter
Named_params_impl(T v, const Base& b)
: Base(b)
, v(v)
{}
};
// partial specialization for base class of the recursive nesting
template <typename T, typename Tag>
struct Named_params_impl<T, Tag, No_property>
{
T v; // copy of the parameter
Named_params_impl(T v)
: v(v)
{}
};
// Helper class to get the type of a named parameter pack given a query tag
template <typename NP, typename Query_tag>
struct Get_param;
template< typename T, typename Tag, typename Query_tag>
struct Get_param< Named_params_impl<T, Tag, No_property>, Query_tag >
{
typedef Param_not_found type;
};
template< typename T, typename Tag, typename Base>
struct Get_param< Named_params_impl<T, Tag, Base>, Tag >
{
typedef T type;
};
template< typename T, typename Tag>
struct Get_param< Named_params_impl<T, Tag, No_property>, Tag >
{
typedef T type;
};
template< typename T, typename Tag, typename Base, typename Query_tag>
struct Get_param< Named_params_impl<T,Tag,Base>, Query_tag>
{
typedef typename Get_param<typename Base::base, Query_tag>::type type;
};
// helper to choose the default
template <typename Query_tag, typename NP, typename D>
struct Lookup_named_param_def
{
typedef typename internal_np::Get_param<typename NP::base, Query_tag>::type NP_type;
typedef typename boost::mpl::if_<
boost::is_same<NP_type, internal_np::Param_not_found>,
D, NP_type>::type
type;
};
// helper function to extract the value from a named parameter pack given a query tag
template <typename T, typename Tag, typename Base>
T get_parameter_impl(const Named_params_impl<T, Tag, Base>& np, Tag)
{
return np.v;
}
template< typename T, typename Tag, typename Query_tag>
Param_not_found get_parameter_impl(const Named_params_impl<T, Tag, No_property>&, Query_tag)
{
return Param_not_found();
}
template< typename T, typename Tag>
T get_parameter_impl(const Named_params_impl<T, Tag, No_property>& np, Tag)
{
return np.v;
};
template <typename T, typename Tag, typename Base, typename Query_tag>
typename Get_param<Named_params_impl<T, Tag, Base>, Query_tag>::type
get_parameter_impl(const Named_params_impl<T, Tag, Base>& np, Query_tag tag)
{
CGAL_static_assertion( (!boost::is_same<Query_tag, Tag>::value) );
return get_parameter_impl(static_cast<const typename Base::base&>(np), tag);
}
} // end of internal_np namespace
template <typename T, typename Tag, typename Base = internal_np::No_property>
struct Named_function_parameters
: internal_np::Named_params_impl<T, Tag, Base>
{
typedef internal_np::Named_params_impl<T, Tag, Base> base;
typedef Named_function_parameters<T, Tag, Base> self;
Named_function_parameters(T v = T()) : base(v) {}
Named_function_parameters(T v, const Base& b) : base(v, b) {}
Named_function_parameters<bool, internal_np::all_default_t, self>
all_default() const
{
typedef Named_function_parameters<bool, internal_np::all_default_t, self> Params;
return Params(*this);
}
// create the functions for new named parameters and the one imported boost
// used to concatenate several parameters
#define CGAL_add_named_parameter(X, Y, Z) \
template<typename K> \
Named_function_parameters<K, internal_np::X, self> \
Z(const K& k) const \
{ \
typedef Named_function_parameters<K, internal_np::X, self> Params;\
return Params(k, *this); \
}
#include <CGAL/boost/graph/parameters_interface.h>
#undef CGAL_add_named_parameter
};
namespace parameters {
Named_function_parameters<bool, internal_np::all_default_t>
inline all_default()
{
typedef Named_function_parameters<bool, internal_np::all_default_t> Params;
return Params();
}
template <typename T, typename Tag, typename Base>
Named_function_parameters<T,Tag,Base>
inline no_parameters(Named_function_parameters<T,Tag,Base>)
{
typedef Named_function_parameters<T,Tag,Base> Params;
return Params();
}
// define free functions for named parameters
#define CGAL_add_named_parameter(X, Y, Z) \
template <typename K> \
Named_function_parameters<K, internal_np::X> \
Z(K const& p) \
{ \
typedef Named_function_parameters<K, internal_np::X> Params;\
return Params(p); \
}
#include <CGAL/boost/graph/parameters_interface.h>
#undef CGAL_add_named_parameter
// function to extract a parameter
template <typename T, typename Tag, typename Base, typename Query_tag>
typename internal_np::Get_param<internal_np::Named_params_impl<T, Tag, Base>, Query_tag>::type
get_parameter(const Named_function_parameters<T, Tag, Base>& np, Query_tag tag)
{
return internal_np::get_parameter_impl(static_cast<const internal_np::Named_params_impl<T, Tag, Base>&>(np), tag);
}
template <typename D>
D choose_parameter(const internal_np::Param_not_found&, const D& d)
{
return d;
}
template <typename T, typename D>
const T&
choose_parameter(const T& t, const D&)
{
return t;
}
bool inline is_default_parameter(const internal_np::Param_not_found&)
{
return true;
}
template <class T>
bool is_default_parameter(const T&)
{
return false;
}
} // end of parameters namespace
} //namespace CGAL
#endif // CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP

23
BGL/include/CGAL/boost/graph/boost_parameters_interface.h
View File

@ -1,23 +0,0 @@
// Copyright (c) 2017 GeometryFactory (France). All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 3 of the License,
// or (at your option) any later version.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
// SPDX-License-Identifier: LGPL-3.0+
//
//
// Author(s) : Maxime Gimeno
// List the named parameters imported from boost we are using in CGAL
CGAL_add_named_parameter(vertex_index_t, vertex_index, vertex_index_map)
CGAL_add_named_parameter(graph_visitor_t, graph_visitor, visitor)

29
BGL/include/CGAL/boost/graph/copy_face_graph.h
View File

@ -29,7 +29,7 @@
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/graph/iterator.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/property_map.h>
#include <boost/unordered_map.hpp>
@ -248,7 +248,7 @@ boost::function_output_iterator<Output_iterator_functor<PMAP> > make_functor(PMA
return boost::make_function_output_iterator(Output_iterator_functor<PMAP>(map));
}
inline Emptyset_iterator make_functor(const boost::param_not_found&)
inline Emptyset_iterator make_functor(const internal_np::Param_not_found&)
{
return Emptyset_iterator();
}
@ -332,26 +332,27 @@ template <typename SourceMesh, typename TargetMesh,
>
void copy_face_graph(const SourceMesh& sm, TargetMesh& tm,
#ifndef DOXYGEN_RUNNING
const CGAL::cgal_bgl_named_params<T1,Tag1,Base1>& np1,
const CGAL::cgal_bgl_named_params<T2,Tag2,Base2>& np2
const CGAL::Named_function_parameters<T1,Tag1,Base1>& np1,
const CGAL::Named_function_parameters<T2,Tag2,Base2>& np2
#else
const NamedParameters1& np1,
const NamedParameters2& np2
#endif
)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
internal::copy_face_graph(sm, tm,
CGAL::graph_has_property<SourceMesh,boost::halfedge_index_t>(),
choose_param(get_param(np1, internal_np::vertex_to_vertex_output_iterator),
impl::make_functor(get_param(np1, internal_np::vertex_to_vertex_map))),
choose_param(get_param(np1, internal_np::halfedge_to_halfedge_output_iterator),
impl::make_functor(get_param(np1, internal_np::halfedge_to_halfedge_map))),
choose_param(get_param(np1, internal_np::face_to_face_output_iterator),
impl::make_functor(get_param(np1, internal_np::face_to_face_map))),
choose_param(get_param(np1, internal_np::vertex_point),
choose_parameter(get_parameter(np1, internal_np::vertex_to_vertex_output_iterator),
impl::make_functor(get_parameter(np1, internal_np::vertex_to_vertex_map))),
choose_parameter(get_parameter(np1, internal_np::halfedge_to_halfedge_output_iterator),
impl::make_functor(get_parameter(np1, internal_np::halfedge_to_halfedge_map))),
choose_parameter(get_parameter(np1, internal_np::face_to_face_output_iterator),
impl::make_functor(get_parameter(np1, internal_np::face_to_face_map))),
choose_parameter(get_parameter(np1, internal_np::vertex_point),
get(vertex_point, sm)),
choose_param(get_param(np2, internal_np::vertex_point),
choose_parameter(get_parameter(np2, internal_np::vertex_point),
get(vertex_point, tm)));
}
@ -364,7 +365,7 @@ void copy_face_graph(const SourceMesh& sm, TargetMesh& tm)
template <typename SourceMesh, typename TargetMesh,
typename T, typename Tag, typename Base >
void copy_face_graph(const SourceMesh& sm, TargetMesh& tm,
const CGAL::cgal_bgl_named_params<T,Tag,Base>& np)
const CGAL::Named_function_parameters<T,Tag,Base>& np)
{
copy_face_graph(sm, tm, np, parameters::all_default());
}

2
BGL/include/CGAL/boost/graph/dijkstra_shortest_paths.h
View File

@ -23,7 +23,7 @@
#define CGAL_BOOST_GRAPH_DIJKSTRA_SHORTEST_PATHS_H
// This will push/pop a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <boost/version.hpp>
#include <climits>

2
BGL/include/CGAL/boost/graph/graph_traits_OpenMesh.h
View File

@ -19,7 +19,7 @@
// Author(s) : Andreas Fabri, Philipp Moeller
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>

55
BGL/include/CGAL/boost/graph/io.h
View File

@ -32,7 +32,7 @@
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/IO/write_vtk.h>
namespace CGAL {
@ -54,10 +54,13 @@ bool write_wrl(std::ostream& os,
typedef typename boost::graph_traits<FaceGraph>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<FaceGraph>::face_descriptor face_descriptor;
typedef typename boost::graph_traits<FaceGraph>::vertices_size_type vertices_size_type;
using parameters::get_parameter;
using parameters::choose_parameter;
typename Polygon_mesh_processing::GetVertexPointMap<FaceGraph, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
boost::container::flat_map<vertex_descriptor,vertices_size_type> reindex;
int n = 0;
@ -142,9 +145,12 @@ bool write_off(std::ostream& os,
typedef typename boost::graph_traits<FaceGraph>::vertices_size_type vertices_size_type;
typedef typename boost::graph_traits<FaceGraph>::faces_size_type faces_size_type;
using parameters::choose_parameter;
using parameters::get_parameter;
typename Polygon_mesh_processing::GetVertexPointMap<FaceGraph, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
vertices_size_type nv = static_cast<vertices_size_type>(std::distance(vertices(g).first, vertices(g).second));
faces_size_type nf = static_cast<faces_size_type>(std::distance(faces(g).first, faces(g).second));
@ -258,6 +264,8 @@ bool read_off(std::istream& is,
NamedParameters np)
{
using namespace internal::read_off_tools;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::graph_traits<FaceGraph>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<FaceGraph>::vertices_size_type vertices_size_type;
@ -266,8 +274,8 @@ bool read_off(std::istream& is,
typedef typename Polygon_mesh_processing::GetVertexPointMap<FaceGraph, NamedParameters>::type Vpm;
typedef typename boost::property_traits<Vpm>::value_type Point_3;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, g));
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, g));
vertices_size_type nv, nvf;
faces_size_type nf;
int ignore;
@ -369,8 +377,11 @@ bool write_inp(std::ostream& os,
typedef typename Polygon_mesh_processing::GetVertexPointMap<FaceGraph, NamedParameters>::const_type VPM;
typedef typename boost::property_traits<VPM>::value_type Point_3;
VPM vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
using parameters::choose_parameter;
using parameters::get_parameter;
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
os << "*Part, name=" << name << "\n*Node\n";
boost::container::flat_map<vertex_descriptor,vertices_size_type> reindex;
@ -416,8 +427,10 @@ write_polys(std::ostream& os,
typedef typename boost::graph_traits<Mesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<Mesh>::face_iterator face_iterator;
typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap<Mesh, NamedParameters>::type Vimap;
Vimap V = choose_param(get_param(np, CGAL::internal_np::vertex_index),
get_const_property_map(CGAL::internal_np::vertex_index, mesh));
using parameters::get_parameter;
using parameters::choose_parameter;
Vimap V = choose_parameter(get_parameter(np, internal_np::vertex_index),
get_const_property_map(boost::vertex_index, mesh));
std::vector<std::size_t> connectivity_table;
std::vector<std::size_t> offsets;
@ -451,8 +464,10 @@ write_polys_tag(std::ostream& os,
typedef typename boost::graph_traits<Mesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<Mesh>::face_iterator face_iterator;
typedef typename CGAL::Polygon_mesh_processing::GetVertexIndexMap<Mesh, NamedParameters>::type Vimap;
Vimap V = choose_param(get_param(np, CGAL::internal_np::vertex_index),
get_const_property_map(CGAL::internal_np::vertex_index, mesh));
using parameters::get_parameter;
using parameters::choose_parameter;
Vimap V = choose_parameter(get_parameter(np, internal_np::vertex_index),
get_const_property_map(boost::vertex_index, mesh));
std::string formatattribute =
binary ? " format=\"appended\"" : " format=\"ascii\"";
@ -540,8 +555,10 @@ write_points_tag(std::ostream& os,
{
typedef typename boost::graph_traits<Mesh>::vertex_iterator vertex_iterator;
typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Mesh, NamedParameters>::const_type Vpmap;
Vpmap vpm = choose_param(get_param(np, CGAL::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
using parameters::get_parameter;
using parameters::choose_parameter;
Vpmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
typedef typename boost::property_traits<Vpmap>::value_type Point_t;
typedef typename CGAL::Kernel_traits<Point_t>::Kernel Gt;
typedef typename Gt::FT FT;
@ -583,8 +600,10 @@ write_polys_points(std::ostream& os,
{
typedef typename boost::graph_traits<Mesh>::vertex_iterator vertex_iterator;
typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Mesh, NamedParameters>::const_type Vpmap;
Vpmap vpm = choose_param(get_param(np, CGAL::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
using parameters::get_parameter;
using parameters::choose_parameter;
Vpmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
typedef typename boost::property_traits<Vpmap>::value_type Point_t;
typedef typename CGAL::Kernel_traits<Point_t>::Kernel Gt;
typedef typename Gt::FT FT;
@ -653,7 +672,7 @@ void write_vtp(std::ostream& os,
os << " <Piece NumberOfPoints=\"" << num_vertices(mesh)
<< "\" NumberOfPolys=\"" << num_faces(mesh) << "\">\n";
std::size_t offset = 0;
const bool binary = boost::choose_param(boost::get_param(np, internal_np::use_binary_mode), true);
const bool binary = parameters::choose_parameter(parameters::get_parameter(np, internal_np::use_binary_mode), true);
internal::write_vtp::write_points_tag(os,mesh,binary,offset, np);
internal::write_vtp::write_polys_tag(os,mesh,binary,offset, np);
os << " </Piece>\n"

205
BGL/include/CGAL/boost/graph/named_function_params.h
View File

@ -1,205 +0,0 @@
//=======================================================================
// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
//
// This file is part of the Boost Graph Library
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// https://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
// Copyright (c) 2007 GeometryFactory (France). All rights reserved.
//
// $URL$
// $Id$
// SPDX-License-Identifier: BSL-1.0
//
// Author(s) : Andreas Fabri, Fernando Cacciola
#ifndef CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H
#define CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_H
#include <CGAL/disable_warnings.h>
#include <CGAL/basic.h>
#include <CGAL/boost/graph/properties.h>
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable:4172) // returning address of local variable or temporary
#endif
#include <boost/graph/named_function_params.hpp>
#if defined(BOOST_MSVC)
# pragma warning(pop)
#endif
#include <boost/type_traits/is_same.hpp>
#include <boost/version.hpp>
// An explanation about the version hackery below: There is no real
// API to introduce custom properties to the Graph API and the
// internals have changed with Boost Version 1.51 and changes aren't
// backward compatible. To work around that we carry around two
// versions of cgal_bgl_named_params. One imitates the pre 1.51
// bgl_named_params, the newer one hooks into the API through
// inheritance and addition of the some partial specializations.
#if BOOST_VERSION < 105100
namespace boost{
typedef detail::error_property_not_found param_not_found;
template <typename Tag, typename Args, typename Def>
struct lookup_named_param_def {
typedef Def type;
static const Def& get(const Args&, const Def& def) {return def;}
};
template <typename T, typename Tag, typename Base, typename Def>
struct lookup_named_param_def<Tag, bgl_named_params<T, Tag, Base>, Def> {
typedef T type;
static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def&) {
return p.m_value;
}
};
template <typename Tag1, typename T, typename Tag, typename Base, typename Def>
struct lookup_named_param_def<Tag1, bgl_named_params<T, Tag, Base>, Def> {
typedef typename lookup_named_param_def<Tag1, Base, Def>::type type;
static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def& def) {
return lookup_named_param_def<Tag1, Base, Def>::get(p.m_base, def);
}
};
} //end of namespace boost
#endif
#define CGAL_BGL_NP_TEMPLATE_PARAMETERS T, typename Tag, typename Base
#define CGAL_BGL_NP_CLASS CGAL::cgal_bgl_named_params<T,Tag,Base>
namespace CGAL {
namespace internal_np{
enum all_default_t { all_default }; //cannot use macro because it takes no argument
// for uniformity we import them in this namespace. Note that
// it is an import so that if we use the named parameter function
// from boost it will work
using boost::vertex_index_t;
using boost::vertex_index;
using boost::graph_visitor_t;
using boost::graph_visitor;
// define enum types and values for new named parameters
#define CGAL_add_named_parameter(X, Y, Z) \
enum X { Y };
#include <CGAL/boost/graph/parameters_interface.h>
#undef CGAL_add_named_parameter
}//internal_np
template <typename T, typename Tag, typename Base = boost::no_property>
struct cgal_bgl_named_params : boost::bgl_named_params<T, Tag, Base>
{
typedef boost::bgl_named_params<T, Tag, Base> base;
typedef cgal_bgl_named_params self;
cgal_bgl_named_params(T v = T()) : base(v) {}
cgal_bgl_named_params(T v, const Base& b) : base(v, b) {}
cgal_bgl_named_params<bool, internal_np::all_default_t, self>
all_default() const
{
typedef cgal_bgl_named_params<bool, internal_np::all_default_t, self> Params;
return Params(*this);
}
// create the functions for new named parameters and the one imported boost
// used to concatenate several parameters
#define CGAL_add_named_parameter(X, Y, Z) \
template<typename K> \
cgal_bgl_named_params<K, internal_np::X, self> \
Z(const K& k) const \
{ \
typedef cgal_bgl_named_params<K, internal_np::X, self> Params;\
return Params(k, *this); \
}
#include <CGAL/boost/graph/parameters_interface.h>
#include <CGAL/boost/graph/boost_parameters_interface.h>
#undef CGAL_add_named_parameter
};
namespace parameters {
cgal_bgl_named_params<bool, internal_np::all_default_t>
inline all_default()
{
typedef cgal_bgl_named_params<bool, internal_np::all_default_t> Params;
return Params();
}
template <typename T, typename Tag, typename Base>
cgal_bgl_named_params<T,Tag,Base>
inline no_parameters(cgal_bgl_named_params<T,Tag,Base>)
{
typedef cgal_bgl_named_params<T,Tag,Base> Params;
return Params();
}
// define free functions for named parameters
#define CGAL_add_named_parameter(X, Y, Z) \
template <typename K> \
cgal_bgl_named_params<K, internal_np::X> \
Z(K const& p) \
{ \
typedef cgal_bgl_named_params<K, internal_np::X> Params;\
return Params(p); \
}
#include <CGAL/boost/graph/parameters_interface.h>
#include <CGAL/boost/graph/boost_parameters_interface.h>
#undef CGAL_add_named_parameter
} // namespace parameters
} //namespace CGAL
// partial specializations hate inheritance and we need to repeat
// those here. this is rather fragile.
namespace boost {
#if BOOST_VERSION < 105100
template <class Tag1, class Tag2, class T1, class Base>
inline
typename property_value< CGAL::cgal_bgl_named_params<T1,Tag1,Base>, Tag2>::type
get_param(const CGAL::cgal_bgl_named_params<T1,Tag1,Base>& p, Tag2 tag2)
{
enum { match = detail::same_property<Tag1,Tag2>::value };
typedef typename
boost::property_value< CGAL::cgal_bgl_named_params<T1,Tag1,Base>, Tag2>::type T2;
T2* t2 = 0;
typedef detail::property_value_dispatch<match> Dispatcher;
return Dispatcher::const_get_value(p, t2, tag2);
}
#endif
template <typename T, typename Tag, typename Base, typename Def>
struct lookup_named_param_def<Tag, CGAL::cgal_bgl_named_params<T, Tag, Base>, Def> {
typedef T type;
static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def&) {
return p.m_value;
}
};
template <typename Tag1, typename T, typename Tag, typename Base, typename Def>
struct lookup_named_param_def<Tag1, CGAL::cgal_bgl_named_params<T, Tag, Base>, Def> {
typedef typename lookup_named_param_def<Tag1, Base, Def>::type type;
static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def& def) {
return lookup_named_param_def<Tag1, Base, Def>::get(p.m_base, def);
}
};
} // boost
#include <CGAL/enable_warnings.h>
#endif // CGAL_BOOST_GRAPH_NAMED_FUNCTION_PARAMS_HPP

54
BGL/include/CGAL/boost/graph/named_params_helper.h
View File

@ -19,7 +19,7 @@
#ifndef CGAL_BOOST_GRAPH_NAMED_PARAMETERS_HELPERS_H
#define CGAL_BOOST_GRAPH_NAMED_PARAMETERS_HELPERS_H
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/Kernel_traits.h>
#include <CGAL/Origin.h>
@ -30,7 +30,7 @@
#include <boost/mpl/has_xxx.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/version.hpp>
namespace CGAL {
@ -123,12 +123,12 @@ namespace CGAL {
typedef typename property_map_selector<PolygonMesh, boost::vertex_point_t>::type
DefaultVPMap;
public:
typedef typename boost::lookup_named_param_def<
typedef typename internal_np::Lookup_named_param_def<
internal_np::vertex_point_t,
NamedParameters,
DefaultVPMap
> ::type type;
typedef typename boost::lookup_named_param_def<
typedef typename internal_np::Lookup_named_param_def<
internal_np::vertex_point_t,
NamedParameters,
DefaultVPMap_const
@ -146,28 +146,28 @@ namespace CGAL {
};
template<typename PolygonMesh,
typename NamedParametersGT = cgal_bgl_named_params<bool, internal_np::all_default_t>,
typename NamedParametersGT = Named_function_parameters<bool, internal_np::all_default_t>,
typename NamedParametersVPM = NamedParametersGT >
class GetGeomTraits
{
typedef typename CGAL::graph_has_property<PolygonMesh, boost::vertex_point_t>::type
Has_internal_pmap;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::vertex_point_t,
NamedParametersVPM,
boost::param_not_found
internal_np::Param_not_found
> ::type NP_vpm;
struct Fake_GT {};//to be used if there is no internal vertex_point_map in PolygonMesh
typedef typename boost::mpl::if_c< Has_internal_pmap::value || !boost::is_same<boost::param_not_found, NP_vpm>::value
typedef typename boost::mpl::if_c< Has_internal_pmap::value || !boost::is_same<internal_np::Param_not_found, NP_vpm>::value
, typename GetK<PolygonMesh, NamedParametersVPM>::Kernel
, Fake_GT
>::type DefaultKernel;
public:
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::geom_traits_t,
NamedParametersGT,
DefaultKernel
@ -180,12 +180,12 @@ namespace CGAL {
typedef typename property_map_selector<PolygonMesh, boost::face_index_t>::type DefaultMap;
typedef typename property_map_selector<PolygonMesh, boost::face_index_t>::const_type DefaultMap_const;
public:
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::face_index_t,
NamedParameters,
DefaultMap
> ::type type;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::face_index_t,
NamedParameters,
DefaultMap_const
@ -199,7 +199,7 @@ namespace CGAL {
{
typedef typename property_map_selector<PolygonMesh, boost::vertex_index_t>::type DefaultMap;
public:
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::vertex_index_t,
NamedParameters,
DefaultMap
@ -222,7 +222,7 @@ namespace CGAL {
public:
typedef DummyNormalPmap NoMap;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::face_normal_t,
NamedParameters,
DummyNormalPmap//default
@ -249,7 +249,7 @@ namespace CGAL {
namespace parameters
{
template <typename PointRange>
cgal_bgl_named_params<bool, internal_np::all_default_t>
Named_function_parameters<bool, internal_np::all_default_t>
inline all_default(const PointRange&)
{
return CGAL::parameters::all_default();
@ -268,13 +268,13 @@ namespace CGAL {
typedef typename CGAL::Identity_property_map<Point> DefaultPMap;
public:
typedef typename boost::lookup_named_param_def<
typedef typename internal_np::Lookup_named_param_def<
internal_np::point_t,
NamedParameters,
DefaultPMap
> ::type type;
typedef typename boost::lookup_named_param_def<
typedef typename internal_np::Lookup_named_param_def<
internal_np::point_t,
NamedParameters,
DefaultPMap
@ -309,13 +309,13 @@ namespace CGAL {
typedef typename CGAL::Identity_property_map<Point> DefaultPMap;
public:
typedef typename boost::lookup_named_param_def<
typedef typename internal_np::Lookup_named_param_def<
internal_np::query_point_t,
NamedParameters,
DefaultPMap
> ::type type;
typedef typename boost::lookup_named_param_def<
typedef typename internal_np::Lookup_named_param_def<
internal_np::query_point_t,
NamedParameters,
DefaultPMap
@ -331,7 +331,7 @@ namespace CGAL {
>::Kernel Default_kernel;
public:
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::geom_traits_t,
NamedParameters,
Default_kernel
@ -355,7 +355,7 @@ namespace CGAL {
public:
typedef DummyNormalMap NoMap;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::normal_t,
NamedParameters,
DummyNormalMap//default
@ -369,13 +369,13 @@ namespace CGAL {
typedef typename CGAL::Identity_property_map<Plane> DefaultPMap;
public:
typedef typename boost::lookup_named_param_def<
typedef typename internal_np::Lookup_named_param_def<
internal_np::plane_t,
NamedParameters,
DefaultPMap
> ::type type;
typedef typename boost::lookup_named_param_def<
typedef typename internal_np::Lookup_named_param_def<
internal_np::plane_t,
NamedParameters,
DefaultPMap
@ -398,7 +398,7 @@ namespace CGAL {
public:
typedef DummyPlaneIndexMap NoMap;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::plane_index_t,
NamedParameters,
DummyPlaneIndexMap//default
@ -421,7 +421,7 @@ namespace CGAL {
public:
typedef DummyConstrainedMap NoMap;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::point_is_constrained_t,
NamedParameters,
DummyConstrainedMap //default
@ -434,7 +434,7 @@ namespace CGAL {
class GetSolver
{
public:
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::sparse_linear_solver_t,
NamedParameters,
DefaultSolver
@ -445,7 +445,7 @@ namespace CGAL {
class GetDiagonalizeTraits
{
public:
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::diagonalize_traits_t,
NamedParameters,
Default_diagonalize_traits<FT, dim>
@ -466,7 +466,7 @@ namespace CGAL {
public:
typedef DummySvdTraits NoTraits;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::svd_traits_t,
NamedParameters,
#if defined(CGAL_EIGEN3_ENABLED)

2
BGL/include/CGAL/boost/graph/parameters_interface.h
View File

@ -23,6 +23,8 @@ CGAL_add_named_parameter(vertex_point_t, vertex_point, vertex_point_map)
CGAL_add_named_parameter(halfedge_index_t, halfedge_index, halfedge_index_map)
CGAL_add_named_parameter(edge_index_t, edge_index, edge_index_map)
CGAL_add_named_parameter(face_index_t, face_index, face_index_map)
CGAL_add_named_parameter(vertex_index_t, vertex_index, vertex_index_map)
CGAL_add_named_parameter(graph_visitor_t, graph_visitor, visitor)
CGAL_add_named_parameter(edge_is_constrained_t, edge_is_constrained, edge_is_constrained_map)
CGAL_add_named_parameter(first_index_t, first_index, first_index)

280
BGL/test/BGL/test_cgal_bgl_named_params.cpp
View File

@ -1,4 +1,4 @@
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/assertions.h>
#include <boost/type_traits/is_same.hpp>
@ -22,181 +22,177 @@ void check_same_type(T)
template<class NamedParameters>
void test(const NamedParameters& np)
{
using boost::get_param;
using CGAL::parameters::get_parameter;
// Test values
// Named parameters from Boost
assert(get_param(np, boost::vertex_index).v == 0);
assert(get_param(np, boost::graph_visitor).v == 1);
// Named parameters that we use in CGAL
assert(get_param(np, CGAL::internal_np::vertex_point).v == 2);
assert(get_param(np, CGAL::internal_np::halfedge_index).v == 3);
assert(get_param(np, CGAL::internal_np::edge_index).v == 4);
assert(get_param(np, CGAL::internal_np::face_index).v == 5);
assert(get_parameter(np, CGAL::internal_np::vertex_index).v == 0);
assert(get_parameter(np, CGAL::internal_np::graph_visitor).v == 1);
assert(get_parameter(np, CGAL::internal_np::vertex_point).v == 2);
assert(get_parameter(np, CGAL::internal_np::halfedge_index).v == 3);
assert(get_parameter(np, CGAL::internal_np::edge_index).v == 4);
assert(get_parameter(np, CGAL::internal_np::face_index).v == 5);
assert(get_param(np, CGAL::internal_np::edge_is_constrained).v == 6);
assert(get_param(np, CGAL::internal_np::first_index).v == 7);
assert(get_param(np, CGAL::internal_np::number_of_iterations).v == 8);
assert(get_parameter(np, CGAL::internal_np::edge_is_constrained).v == 6);
assert(get_parameter(np, CGAL::internal_np::first_index).v == 7);
assert(get_parameter(np, CGAL::internal_np::number_of_iterations).v == 8);
assert(get_param(np, CGAL::internal_np::METIS_options).v == 800000001);
assert(get_param(np, CGAL::internal_np::vertex_partition_id).v == 800000002);
assert(get_param(np, CGAL::internal_np::face_partition_id).v == 800000003);
assert(get_parameter(np, CGAL::internal_np::METIS_options).v == 800000001);
assert(get_parameter(np, CGAL::internal_np::vertex_partition_id).v == 800000002);
assert(get_parameter(np, CGAL::internal_np::face_partition_id).v == 800000003);
assert(get_param(np, CGAL::internal_np::vertex_to_vertex_output_iterator).v == 800000004);
assert(get_param(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator).v == 800000005);
assert(get_param(np, CGAL::internal_np::face_to_face_output_iterator).v == 800000006);
assert(get_parameter(np, CGAL::internal_np::vertex_to_vertex_output_iterator).v == 800000004);
assert(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator).v == 800000005);
assert(get_parameter(np, CGAL::internal_np::face_to_face_output_iterator).v == 800000006);
assert(get_param(np, CGAL::internal_np::vertex_to_vertex_map).v == 800000007);
assert(get_param(np, CGAL::internal_np::halfedge_to_halfedge_map).v == 800000008);
assert(get_param(np, CGAL::internal_np::face_to_face_map).v == 800000009);
assert(get_parameter(np, CGAL::internal_np::vertex_to_vertex_map).v == 800000007);
assert(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_map).v == 800000008);
assert(get_parameter(np, CGAL::internal_np::face_to_face_map).v == 800000009);
// Named parameters that we use in the package 'Mesh_3'
assert(get_param(np, CGAL::internal_np::vertex_feature_degree).v == 9);
assert(get_parameter(np, CGAL::internal_np::vertex_feature_degree).v == 9);
// Named parameters used in the package 'Polygon Mesh Processing'
assert(get_param(np, CGAL::internal_np::geom_traits).v == 10);
assert(get_param(np, CGAL::internal_np::vertex_incident_patches).v == 11);
assert(get_param(np, CGAL::internal_np::density_control_factor).v == 12);
assert(get_param(np, CGAL::internal_np::use_delaunay_triangulation).v == 13);
assert(get_param(np, CGAL::internal_np::fairing_continuity).v == 14);
assert(get_param(np, CGAL::internal_np::sparse_linear_solver).v == 15);
assert(get_param(np, CGAL::internal_np::number_of_relaxation_steps).v == 16);
assert(get_param(np, CGAL::internal_np::protect_constraints).v == 17);
assert(get_param(np, CGAL::internal_np::relax_constraints).v == 18);
assert(get_param(np, CGAL::internal_np::collapse_constraints).v == 43);
assert(get_param(np, CGAL::internal_np::vertex_is_constrained).v == 19);
assert(get_param(np, CGAL::internal_np::face_patch).v == 20);
assert(get_param(np, CGAL::internal_np::random_uniform_sampling).v == 21);
assert(get_param(np, CGAL::internal_np::grid_sampling).v == 22);
assert(get_param(np, CGAL::internal_np::monte_carlo_sampling).v == 23);
assert(get_param(np, CGAL::internal_np::do_sample_edges).v == 24);
assert(get_param(np, CGAL::internal_np::do_sample_vertices).v == 25);
assert(get_param(np, CGAL::internal_np::do_sample_faces).v == 26);
assert(get_param(np, CGAL::internal_np::number_of_points_on_faces).v == 27);
assert(get_param(np, CGAL::internal_np::number_of_points_per_face).v == 28);
assert(get_param(np, CGAL::internal_np::grid_spacing).v == 29);
assert(get_param(np, CGAL::internal_np::number_of_points_per_edge).v == 30);
assert(get_param(np, CGAL::internal_np::number_of_points_on_edges).v == 31);
assert(get_param(np, CGAL::internal_np::nb_points_per_area_unit).v == 32);
assert(get_param(np, CGAL::internal_np::nb_points_per_distance_unit).v == 33);
assert(get_param(np, CGAL::internal_np::throw_on_self_intersection).v == 43);
assert(get_param(np, CGAL::internal_np::clip_volume).v == 44);
assert(get_param(np, CGAL::internal_np::use_compact_clipper).v == 45);
assert(get_param(np, CGAL::internal_np::erase_all_duplicates).v == 48);
assert(get_param(np, CGAL::internal_np::require_same_orientation).v == 49);
assert(get_param(np, CGAL::internal_np::use_bool_op_to_clip_surface).v == 50);
assert(get_param(np, CGAL::internal_np::face_size_map).v == 52);
assert(get_param(np, CGAL::internal_np::snapping_tolerance).v == 57);
assert(get_param(np, CGAL::internal_np::use_angle_smoothing).v == 53);
assert(get_param(np, CGAL::internal_np::use_area_smoothing).v == 54);
assert(get_param(np, CGAL::internal_np::use_Delaunay_flips).v == 55);
assert(get_param(np, CGAL::internal_np::use_safety_constraints).v == 56);
assert(get_parameter(np, CGAL::internal_np::geom_traits).v == 10);
assert(get_parameter(np, CGAL::internal_np::vertex_incident_patches).v == 11);
assert(get_parameter(np, CGAL::internal_np::density_control_factor).v == 12);
assert(get_parameter(np, CGAL::internal_np::use_delaunay_triangulation).v == 13);
assert(get_parameter(np, CGAL::internal_np::fairing_continuity).v == 14);
assert(get_parameter(np, CGAL::internal_np::sparse_linear_solver).v == 15);
assert(get_parameter(np, CGAL::internal_np::number_of_relaxation_steps).v == 16);
assert(get_parameter(np, CGAL::internal_np::protect_constraints).v == 17);
assert(get_parameter(np, CGAL::internal_np::relax_constraints).v == 18);
assert(get_parameter(np, CGAL::internal_np::collapse_constraints).v == 43);
assert(get_parameter(np, CGAL::internal_np::vertex_is_constrained).v == 19);
assert(get_parameter(np, CGAL::internal_np::face_patch).v == 20);
assert(get_parameter(np, CGAL::internal_np::random_uniform_sampling).v == 21);
assert(get_parameter(np, CGAL::internal_np::grid_sampling).v == 22);
assert(get_parameter(np, CGAL::internal_np::monte_carlo_sampling).v == 23);
assert(get_parameter(np, CGAL::internal_np::do_sample_edges).v == 24);
assert(get_parameter(np, CGAL::internal_np::do_sample_vertices).v == 25);
assert(get_parameter(np, CGAL::internal_np::do_sample_faces).v == 26);
assert(get_parameter(np, CGAL::internal_np::number_of_points_on_faces).v == 27);
assert(get_parameter(np, CGAL::internal_np::number_of_points_per_face).v == 28);
assert(get_parameter(np, CGAL::internal_np::grid_spacing).v == 29);
assert(get_parameter(np, CGAL::internal_np::number_of_points_per_edge).v == 30);
assert(get_parameter(np, CGAL::internal_np::number_of_points_on_edges).v == 31);
assert(get_parameter(np, CGAL::internal_np::nb_points_per_area_unit).v == 32);
assert(get_parameter(np, CGAL::internal_np::nb_points_per_distance_unit).v == 33);
assert(get_parameter(np, CGAL::internal_np::throw_on_self_intersection).v == 43);
assert(get_parameter(np, CGAL::internal_np::clip_volume).v == 44);
assert(get_parameter(np, CGAL::internal_np::use_compact_clipper).v == 45);
assert(get_parameter(np, CGAL::internal_np::erase_all_duplicates).v == 48);
assert(get_parameter(np, CGAL::internal_np::require_same_orientation).v == 49);
assert(get_parameter(np, CGAL::internal_np::use_bool_op_to_clip_surface).v == 50);
assert(get_parameter(np, CGAL::internal_np::face_size_map).v == 52);
assert(get_parameter(np, CGAL::internal_np::snapping_tolerance).v == 57);
assert(get_parameter(np, CGAL::internal_np::use_angle_smoothing).v == 53);
assert(get_parameter(np, CGAL::internal_np::use_area_smoothing).v == 54);
assert(get_parameter(np, CGAL::internal_np::use_Delaunay_flips).v == 55);
assert(get_parameter(np, CGAL::internal_np::use_safety_constraints).v == 56);
// Named parameters that we use in the package 'Surface Mesh Simplification'
assert(get_param(np, CGAL::internal_np::get_cost_policy).v == 34);
assert(get_param(np, CGAL::internal_np::get_placement_policy).v == 35);
assert(get_parameter(np, CGAL::internal_np::get_cost_policy).v == 34);
assert(get_parameter(np, CGAL::internal_np::get_placement_policy).v == 35);
// To-be-documented named parameters
assert(get_param(np, CGAL::internal_np::face_normal).v == 36);
assert(get_param(np, CGAL::internal_np::random_seed).v == 37);
assert(get_param(np, CGAL::internal_np::do_project).v == 38);
assert(get_parameter(np, CGAL::internal_np::face_normal).v == 36);
assert(get_parameter(np, CGAL::internal_np::random_seed).v == 37);
assert(get_parameter(np, CGAL::internal_np::do_project).v == 38);
// Internal named parameters
assert(get_param(np, CGAL::internal_np::weight_calculator).v == 39);
assert(get_param(np, CGAL::internal_np::preserve_genus).v == 40);
assert(get_param(np, CGAL::internal_np::verbosity_level).v == 41);
assert(get_param(np, CGAL::internal_np::use_binary_mode).v == 51);
assert(get_param(np, CGAL::internal_np::projection_functor).v == 42);
assert(get_param(np, CGAL::internal_np::apply_per_connected_component).v == 46);
assert(get_param(np, CGAL::internal_np::output_iterator).v == 47);
assert(get_parameter(np, CGAL::internal_np::weight_calculator).v == 39);
assert(get_parameter(np, CGAL::internal_np::preserve_genus).v == 40);
assert(get_parameter(np, CGAL::internal_np::verbosity_level).v == 41);
assert(get_parameter(np, CGAL::internal_np::use_binary_mode).v == 51);
assert(get_parameter(np, CGAL::internal_np::projection_functor).v == 42);
assert(get_parameter(np, CGAL::internal_np::apply_per_connected_component).v == 46);
assert(get_parameter(np, CGAL::internal_np::output_iterator).v == 47);
// Test types
// Named parameters from Boost
check_same_type<0>(get_param(np, boost::vertex_index));
check_same_type<1>(get_param(np, boost::graph_visitor));
// Named parameters that we use in CGAL
check_same_type<2>(get_param(np, CGAL::internal_np::vertex_point));
check_same_type<3>(get_param(np, CGAL::internal_np::halfedge_index));
check_same_type<4>(get_param(np, CGAL::internal_np::edge_index));
check_same_type<5>(get_param(np, CGAL::internal_np::face_index));
check_same_type<0>(get_parameter(np, CGAL::internal_np::vertex_index));
check_same_type<1>(get_parameter(np, CGAL::internal_np::graph_visitor));
check_same_type<2>(get_parameter(np, CGAL::internal_np::vertex_point));
check_same_type<3>(get_parameter(np, CGAL::internal_np::halfedge_index));
check_same_type<4>(get_parameter(np, CGAL::internal_np::edge_index));
check_same_type<5>(get_parameter(np, CGAL::internal_np::face_index));
check_same_type<6>(get_param(np, CGAL::internal_np::edge_is_constrained));
check_same_type<7>(get_param(np, CGAL::internal_np::first_index));
check_same_type<8>(get_param(np, CGAL::internal_np::number_of_iterations));
check_same_type<6>(get_parameter(np, CGAL::internal_np::edge_is_constrained));
check_same_type<7>(get_parameter(np, CGAL::internal_np::first_index));
check_same_type<8>(get_parameter(np, CGAL::internal_np::number_of_iterations));
check_same_type<800000001>(get_param(np, CGAL::internal_np::METIS_options));
check_same_type<800000002>(get_param(np, CGAL::internal_np::vertex_partition_id));
check_same_type<800000003>(get_param(np, CGAL::internal_np::face_partition_id));
check_same_type<800000004>(get_param(np, CGAL::internal_np::vertex_to_vertex_output_iterator));
check_same_type<800000005>(get_param(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator));
check_same_type<800000006>(get_param(np, CGAL::internal_np::face_to_face_output_iterator));
check_same_type<800000007>(get_param(np, CGAL::internal_np::vertex_to_vertex_map));
check_same_type<800000008>(get_param(np, CGAL::internal_np::halfedge_to_halfedge_map));
check_same_type<800000009>(get_param(np, CGAL::internal_np::face_to_face_map));
check_same_type<800000001>(get_parameter(np, CGAL::internal_np::METIS_options));
check_same_type<800000002>(get_parameter(np, CGAL::internal_np::vertex_partition_id));
check_same_type<800000003>(get_parameter(np, CGAL::internal_np::face_partition_id));
check_same_type<800000004>(get_parameter(np, CGAL::internal_np::vertex_to_vertex_output_iterator));
check_same_type<800000005>(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_output_iterator));
check_same_type<800000006>(get_parameter(np, CGAL::internal_np::face_to_face_output_iterator));
check_same_type<800000007>(get_parameter(np, CGAL::internal_np::vertex_to_vertex_map));
check_same_type<800000008>(get_parameter(np, CGAL::internal_np::halfedge_to_halfedge_map));
check_same_type<800000009>(get_parameter(np, CGAL::internal_np::face_to_face_map));
// Named parameters that we use in the package 'Mesh_3'
check_same_type<9>(get_param(np, CGAL::internal_np::vertex_feature_degree));
check_same_type<9>(get_parameter(np, CGAL::internal_np::vertex_feature_degree));
// Named parameters used in the package 'Polygon Mesh Processing'
check_same_type<10>(get_param(np, CGAL::internal_np::geom_traits));
check_same_type<11>(get_param(np, CGAL::internal_np::vertex_incident_patches));
check_same_type<12>(get_param(np, CGAL::internal_np::density_control_factor));
check_same_type<13>(get_param(np, CGAL::internal_np::use_delaunay_triangulation));
check_same_type<14>(get_param(np, CGAL::internal_np::fairing_continuity));
check_same_type<15>(get_param(np, CGAL::internal_np::sparse_linear_solver));
check_same_type<16>(get_param(np, CGAL::internal_np::number_of_relaxation_steps));
check_same_type<17>(get_param(np, CGAL::internal_np::protect_constraints));
check_same_type<18>(get_param(np, CGAL::internal_np::relax_constraints));
check_same_type<43>(get_param(np, CGAL::internal_np::collapse_constraints));
check_same_type<19>(get_param(np, CGAL::internal_np::vertex_is_constrained));
check_same_type<20>(get_param(np, CGAL::internal_np::face_patch));
check_same_type<21>(get_param(np, CGAL::internal_np::random_uniform_sampling));
check_same_type<22>(get_param(np, CGAL::internal_np::grid_sampling));
check_same_type<23>(get_param(np, CGAL::internal_np::monte_carlo_sampling));
check_same_type<24>(get_param(np, CGAL::internal_np::do_sample_edges));
check_same_type<25>(get_param(np, CGAL::internal_np::do_sample_vertices));
check_same_type<26>(get_param(np, CGAL::internal_np::do_sample_faces));
check_same_type<27>(get_param(np, CGAL::internal_np::number_of_points_on_faces));
check_same_type<28>(get_param(np, CGAL::internal_np::number_of_points_per_face));
check_same_type<29>(get_param(np, CGAL::internal_np::grid_spacing));
check_same_type<30>(get_param(np, CGAL::internal_np::number_of_points_per_edge));
check_same_type<31>(get_param(np, CGAL::internal_np::number_of_points_on_edges));
check_same_type<32>(get_param(np, CGAL::internal_np::nb_points_per_area_unit));
check_same_type<33>(get_param(np, CGAL::internal_np::nb_points_per_distance_unit));
check_same_type<43>(get_param(np, CGAL::internal_np::throw_on_self_intersection));
check_same_type<44>(get_param(np, CGAL::internal_np::clip_volume));
check_same_type<45>(get_param(np, CGAL::internal_np::use_compact_clipper));
check_same_type<48>(get_param(np, CGAL::internal_np::erase_all_duplicates));
check_same_type<49>(get_param(np, CGAL::internal_np::require_same_orientation));
check_same_type<50>(get_param(np, CGAL::internal_np::use_bool_op_to_clip_surface));
check_same_type<52>(get_param(np, CGAL::internal_np::face_size_map));
check_same_type<57>(get_param(np, CGAL::internal_np::snapping_tolerance));
check_same_type<53>(get_param(np, CGAL::internal_np::use_angle_smoothing));
check_same_type<54>(get_param(np, CGAL::internal_np::use_area_smoothing));
check_same_type<55>(get_param(np, CGAL::internal_np::use_Delaunay_flips));
check_same_type<56>(get_param(np, CGAL::internal_np::use_safety_constraints));
check_same_type<10>(get_parameter(np, CGAL::internal_np::geom_traits));
check_same_type<11>(get_parameter(np, CGAL::internal_np::vertex_incident_patches));
check_same_type<12>(get_parameter(np, CGAL::internal_np::density_control_factor));
check_same_type<13>(get_parameter(np, CGAL::internal_np::use_delaunay_triangulation));
check_same_type<14>(get_parameter(np, CGAL::internal_np::fairing_continuity));
check_same_type<15>(get_parameter(np, CGAL::internal_np::sparse_linear_solver));
check_same_type<16>(get_parameter(np, CGAL::internal_np::number_of_relaxation_steps));
check_same_type<17>(get_parameter(np, CGAL::internal_np::protect_constraints));
check_same_type<18>(get_parameter(np, CGAL::internal_np::relax_constraints));
check_same_type<43>(get_parameter(np, CGAL::internal_np::collapse_constraints));
check_same_type<19>(get_parameter(np, CGAL::internal_np::vertex_is_constrained));
check_same_type<20>(get_parameter(np, CGAL::internal_np::face_patch));
check_same_type<21>(get_parameter(np, CGAL::internal_np::random_uniform_sampling));
check_same_type<22>(get_parameter(np, CGAL::internal_np::grid_sampling));
check_same_type<23>(get_parameter(np, CGAL::internal_np::monte_carlo_sampling));
check_same_type<24>(get_parameter(np, CGAL::internal_np::do_sample_edges));
check_same_type<25>(get_parameter(np, CGAL::internal_np::do_sample_vertices));
check_same_type<26>(get_parameter(np, CGAL::internal_np::do_sample_faces));
check_same_type<27>(get_parameter(np, CGAL::internal_np::number_of_points_on_faces));
check_same_type<28>(get_parameter(np, CGAL::internal_np::number_of_points_per_face));
check_same_type<29>(get_parameter(np, CGAL::internal_np::grid_spacing));
check_same_type<30>(get_parameter(np, CGAL::internal_np::number_of_points_per_edge));
check_same_type<31>(get_parameter(np, CGAL::internal_np::number_of_points_on_edges));
check_same_type<32>(get_parameter(np, CGAL::internal_np::nb_points_per_area_unit));
check_same_type<33>(get_parameter(np, CGAL::internal_np::nb_points_per_distance_unit));
check_same_type<43>(get_parameter(np, CGAL::internal_np::throw_on_self_intersection));
check_same_type<44>(get_parameter(np, CGAL::internal_np::clip_volume));
check_same_type<45>(get_parameter(np, CGAL::internal_np::use_compact_clipper));
check_same_type<48>(get_parameter(np, CGAL::internal_np::erase_all_duplicates));
check_same_type<49>(get_parameter(np, CGAL::internal_np::require_same_orientation));
check_same_type<50>(get_parameter(np, CGAL::internal_np::use_bool_op_to_clip_surface));
check_same_type<52>(get_parameter(np, CGAL::internal_np::face_size_map));
check_same_type<57>(get_parameter(np, CGAL::internal_np::snapping_tolerance));
check_same_type<53>(get_parameter(np, CGAL::internal_np::use_angle_smoothing));
check_same_type<54>(get_parameter(np, CGAL::internal_np::use_area_smoothing));
check_same_type<55>(get_parameter(np, CGAL::internal_np::use_Delaunay_flips));
check_same_type<56>(get_parameter(np, CGAL::internal_np::use_safety_constraints));
// Named parameters that we use in the package 'Surface Mesh Simplification'
check_same_type<34>(get_param(np, CGAL::internal_np::get_cost_policy));
check_same_type<35>(get_param(np, CGAL::internal_np::get_placement_policy));
check_same_type<34>(get_parameter(np, CGAL::internal_np::get_cost_policy));
check_same_type<35>(get_parameter(np, CGAL::internal_np::get_placement_policy));
// To-be-documented named parameters
check_same_type<36>(get_param(np, CGAL::internal_np::face_normal));
check_same_type<37>(get_param(np, CGAL::internal_np::random_seed));
check_same_type<38>(get_param(np, CGAL::internal_np::do_project));
check_same_type<36>(get_parameter(np, CGAL::internal_np::face_normal));
check_same_type<37>(get_parameter(np, CGAL::internal_np::random_seed));
check_same_type<38>(get_parameter(np, CGAL::internal_np::do_project));
// Internal named parameters
check_same_type<39>(get_param(np, CGAL::internal_np::weight_calculator));
check_same_type<40>(get_param(np, CGAL::internal_np::preserve_genus));
check_same_type<41>(get_param(np, CGAL::internal_np::verbosity_level));
check_same_type<51>(get_param(np, CGAL::internal_np::use_binary_mode));
check_same_type<42>(get_param(np, CGAL::internal_np::projection_functor));
check_same_type<46>(get_param(np, CGAL::internal_np::apply_per_connected_component));
check_same_type<47>(get_param(np, CGAL::internal_np::output_iterator));
check_same_type<39>(get_parameter(np, CGAL::internal_np::weight_calculator));
check_same_type<40>(get_parameter(np, CGAL::internal_np::preserve_genus));
check_same_type<41>(get_parameter(np, CGAL::internal_np::verbosity_level));
check_same_type<51>(get_parameter(np, CGAL::internal_np::use_binary_mode));
check_same_type<42>(get_parameter(np, CGAL::internal_np::projection_functor));
check_same_type<46>(get_parameter(np, CGAL::internal_np::apply_per_connected_component));
check_same_type<47>(get_parameter(np, CGAL::internal_np::output_iterator));
}
int main()

1
Classification/include/CGAL/Classification/classify.h
View File

@ -27,6 +27,7 @@
#include <CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h>
#include <CGAL/Bbox_3.h>
#include <CGAL/Classification/Label_set.h>
#include <CGAL/property_map.h>
#ifdef CGAL_LINKED_WITH_TBB
#include <tbb/parallel_for.h>

2
HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS.h
View File

@ -24,7 +24,7 @@
#include <functional>
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <boost/config.hpp>
#include <boost/iterator/iterator_adaptor.hpp>

1
HalfedgeDS/include/CGAL/boost/graph/graph_traits_HalfedgeDS_default.h
View File

@ -22,6 +22,7 @@
#define CGAL_GRAPH_TRAITS_HALFEDGEDS_DEFAULT_H
#include <CGAL/boost/graph/graph_traits_HalfedgeDS.h>
#include <CGAL/boost/graph/properties.h>
#include <CGAL/Iterator_range.h>
#include <CGAL/HalfedgeDS_decorator.h>
#include <CGAL/HalfedgeDS_default.h>

6
Linear_cell_complex/benchmark/Linear_cell_complex_2/surface_mesh/IO_off.cpp
View File

@ -24,7 +24,7 @@
#include "IO.h"
#include <stdio.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
//== IMPLEMENTATION ===========================================================
@ -55,7 +55,7 @@ bool read_off_ascii(Surface_mesh& mesh,
Vec2f t;
Surface_mesh::Vertex v;
typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Surface_mesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, CGAL::boost::internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, CGAL::boost::internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));
@ -177,7 +177,7 @@ bool read_off_binary(Surface_mesh& mesh,
if (has_normals) normals = mesh.vertex_property<Normal>("v:normal");
if (has_texcoords) texcoords = mesh.vertex_property<Texture_coordinate>("v:texcoord");
typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Surface_mesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, CGAL::boost::internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, CGAL::boost::internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, mesh));

14
Point_set_3/include/CGAL/Point_set_3.h
View File

@ -31,7 +31,7 @@
#include <CGAL/demangle.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
@ -959,13 +959,13 @@ public:
#ifdef DOXYGEN_RUNNING
unspecified_type
#else
cgal_bgl_named_params
Named_function_parameters
<typename Kernel_traits<Point>::Kernel,
internal_np::geom_traits_t,
cgal_bgl_named_params
Named_function_parameters
<typename CGAL::Point_set_3<Point, Vector>::template Property_map<Vector>,
internal_np::normal_t,
cgal_bgl_named_params
Named_function_parameters
<typename CGAL::Point_set_3<Point, Vector>::template Property_map<Point>,
internal_np::point_t> > >
#endif
@ -1303,13 +1303,13 @@ namespace Point_set_processing_3
namespace parameters
{
template <typename Point, typename Vector>
cgal_bgl_named_params
Named_function_parameters
<typename Kernel_traits<Point>::Kernel,
internal_np::geom_traits_t,
cgal_bgl_named_params
Named_function_parameters
<typename CGAL::Point_set_3<Point, Vector>::template Property_map<Vector>,
internal_np::normal_t,
cgal_bgl_named_params
Named_function_parameters
<typename CGAL::Point_set_3<Point, Vector>::template Property_map<Point>,
internal_np::point_t> > >
inline all_default(const CGAL::Point_set_3<Point, Vector>& ps)

4
Point_set_processing_3/doc/Point_set_processing_3/Doxyfile.in
View File

@ -14,4 +14,6 @@ ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"p
ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
ALIASES += "cgalNPEnd=</td></tr>"
EXPAND_AS_DEFINED = CGAL_BGL_NP_TEMPLATE_PARAMETERS \
CGAL_BGL_NP_CLASS

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

@ -32,7 +32,7 @@
#include <CGAL/point_set_processing_assertions.h>
#include <CGAL/Kernel_traits.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <boost/version.hpp>
@ -465,12 +465,13 @@ bool read_las_points(std::istream& stream,
const CGAL_BGL_NP_CLASS& np)
#endif
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef Point_set_processing_3::Fake_point_range<OutputIteratorValueType> PointRange;
typedef typename Point_set_processing_3::GetPointMap<PointRange, CGAL_BGL_NP_CLASS>::type PointMap;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
return read_las_points_with_properties (stream, output,
make_las_point_reader (point_map));

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

@ -31,7 +31,7 @@
#include <CGAL/point_set_processing_assertions.h>
#include <CGAL/Kernel_traits.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iostream>
@ -85,7 +85,8 @@ read_off_points(
const CGAL_BGL_NP_CLASS& np)
#endif
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef Point_set_processing_3::Fake_point_range<OutputIteratorValueType> PointRange;
@ -97,8 +98,8 @@ read_off_points(
bool has_normals = !(boost::is_same<NormalMap,
typename Point_set_processing_3::GetNormalMap<PointRange, CGAL_BGL_NP_CLASS>::NoMap>::value);
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
// value_type_traits is a workaround as back_insert_iterator's value_type is void
// typedef typename value_type_traits<OutputIterator>::type Enriched_point;

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

@ -34,7 +34,7 @@
#include <CGAL/Kernel_traits.h>
#include <CGAL/IO/io.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <boost/version.hpp>
@ -241,7 +241,8 @@ bool read_ply_points(std::istream& stream,
const CGAL_BGL_NP_CLASS& np)
#endif
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef Point_set_processing_3::Fake_point_range<OutputIteratorValueType> PointRange;
@ -252,8 +253,8 @@ bool read_ply_points(std::istream& stream,
bool has_normals = !(boost::is_same<NormalMap,
typename Point_set_processing_3::GetNormalMap<PointRange, CGAL_BGL_NP_CLASS>::NoMap>::value);
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
if (has_normals)
return read_ply_points_with_properties (stream, output,

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

@ -30,7 +30,7 @@
#include <CGAL/Origin.h>
#include <CGAL/Kernel_traits.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iostream>
@ -84,7 +84,8 @@ read_xyz_points(
const CGAL_BGL_NP_CLASS& np)
#endif
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef Point_set_processing_3::Fake_point_range<OutputIteratorValueType> PointRange;
@ -96,8 +97,8 @@ read_xyz_points(
bool has_normals = !(boost::is_same<NormalMap,
typename Point_set_processing_3::GetNormalMap<PointRange, CGAL_BGL_NP_CLASS>::NoMap>::value);
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
// value_type_traits is a workaround as back_insert_iterator's value_type is void
//typedef typename value_type_traits<OutputIterator>::type Enriched_point;

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

@ -282,10 +282,11 @@ write_las_points(
const PointRange& points,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
return write_las_points_with_properties (stream, points, make_las_point_writer(point_map));
}

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

@ -71,7 +71,8 @@ write_off_points(
const PointRange& points,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -80,8 +81,8 @@ write_off_points(
bool has_normals = !(boost::is_same<NormalMap,
typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value);
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
CGAL_point_set_processing_precondition(points.begin() != points.end());

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

@ -32,7 +32,7 @@
#include <CGAL/point_set_processing_assertions.h>
#include <CGAL/Iterator_range.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <boost/version.hpp>
@ -189,7 +189,8 @@ write_ply_points(
const PointRange& points,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -198,8 +199,8 @@ write_ply_points(
bool has_normals = !(boost::is_same<NormalMap,
typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value);
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
if (has_normals)
return write_ply_points_with_properties(

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

@ -29,7 +29,7 @@
#include <CGAL/Kernel_traits.h>
#include <CGAL/Iterator_range.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iostream>
@ -71,7 +71,8 @@ write_xyz_points(
const PointRange& points,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -80,8 +81,8 @@ write_xyz_points(
bool has_normals = !(boost::is_same<NormalMap,
typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value);
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
CGAL_point_set_processing_precondition(points.begin() != points.end());

17
Point_set_processing_3/include/CGAL/bilateral_smooth_point_set.h
View File

@ -34,7 +34,7 @@
#include <CGAL/squared_distance_3.h>
#include <functional>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -404,7 +404,8 @@ bilateral_smooth_point_set(
unsigned int k,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -419,9 +420,9 @@ bilateral_smooth_point_set(
typedef typename std::vector<Pwn,CGAL_PSP3_DEFAULT_ALLOCATOR<Pwn> > Pwns;
typedef typename Kernel::FT FT;
double sharpness_angle = choose_param(get_param(np, internal_np::sharpness_angle), 30.);
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
std::function<bool(double)>());
double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.);
const std::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
std::function<bool(double)>());
CGAL_point_set_processing_precondition(points.begin() != points.end());
CGAL_point_set_processing_precondition(k > 1);
@ -433,9 +434,9 @@ bilateral_smooth_point_set(
typedef CGAL::Orthogonal_k_neighbor_search<Tree_traits> Neighbor_search;
typedef typename Neighbor_search::Tree Tree;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), FT(0));
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), FT(0));
// copy points and normals
Pwns pwns;

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

@ -33,7 +33,7 @@
#include <CGAL/assertions.h>
#include <functional>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -46,6 +46,11 @@
#include <tbb/scalable_allocator.h>
#endif // CGAL_LINKED_WITH_TBB
#ifdef DOXYGEN_RUNNING
#define CGAL_BGL_NP_TEMPLATE_PARAMETERS NamedParameters
#define CGAL_BGL_NP_CLASS NamedParameters
#endif
namespace CGAL {
@ -184,29 +189,30 @@ compute_average_spacing(const typename Kernel::Point_3& query, ///< 3D point who
*/
template <typename ConcurrencyTag,
typename PointRange,
typename NamedParameters
typename CGAL_BGL_NP_TEMPLATE_PARAMETERS
>
#ifdef DOXYGEN_RUNNING
FT
#else
typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel::FT
typename Point_set_processing_3::GetK<PointRange, CGAL_BGL_NP_CLASS>::Kernel::FT
#endif
compute_average_spacing(
const PointRange& points,
unsigned int k,
const NamedParameters& np)
const CGAL_BGL_NP_CLASS& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::const_type PointMap;
typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
typedef typename Point_set_processing_3::GetPointMap<PointRange, CGAL_BGL_NP_CLASS>::const_type PointMap;
typedef typename Point_set_processing_3::GetK<PointRange, CGAL_BGL_NP_CLASS>::Kernel Kernel;
typedef typename Kernel::Point_3 Point;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
std::function<bool(double)>());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
const std::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
std::function<bool(double)>());
// types for K nearest neighbors search structure
typedef typename Kernel::FT FT;

17
Point_set_processing_3/include/CGAL/edge_aware_upsample_point_set.h
View File

@ -32,7 +32,7 @@
#include <CGAL/Memory_sizer.h>
#include <CGAL/compute_average_spacing.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -328,7 +328,8 @@ edge_aware_upsample_point_set(
OutputIterator output,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -344,12 +345,12 @@ edge_aware_upsample_point_set(
typedef typename Kernel::FT FT;
typedef typename rich_grid_internal::Rich_point<Kernel> Rich_point;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
double sharpness_angle = choose_param(get_param(np, internal_np::sharpness_angle), 30.);
double edge_sensitivity = choose_param(get_param(np, internal_np::edge_sensitivity), 1);
double neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), -1);
std::size_t number_of_output_points = choose_param(get_param(np, internal_np::number_of_output_points), 1000);
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.);
double edge_sensitivity = choose_parameter(get_parameter(np, internal_np::edge_sensitivity), 1);
double neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), -1);
std::size_t number_of_output_points = choose_parameter(get_parameter(np, internal_np::number_of_output_points), 1000);
std::cerr << sharpness_angle << " " << edge_sensitivity << " " << neighbor_radius
<< " " << number_of_output_points << std::endl;

30
Point_set_processing_3/include/CGAL/estimate_scale.h
View File

@ -36,7 +36,7 @@
#include <CGAL/random_simplify_point_set.h>
#include <CGAL/Point_set_2.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <fstream>
@ -494,15 +494,17 @@ estimate_local_k_neighbor_scales(
OutputIterator output,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::const_type PointMap;
typedef typename Point_set_processing_3::GetQueryPointMap<QueryPointRange, NamedParameters>::const_type QueryPointMap;
typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
typedef typename boost::property_traits<PointMap>::value_type Point_d;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
QueryPointMap query_point_map = choose_param(get_param(np, internal_np::query_point_map), QueryPointMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
QueryPointMap query_point_map = choose_parameter(get_parameter(np, internal_np::query_point_map), QueryPointMap());
// Build multi-scale KD-tree
internal::Quick_multiscale_approximate_knn_distance<Kernel, Point_d> kdtree (points.begin(),
@ -570,9 +572,11 @@ estimate_global_k_neighbor_scale(
const PointRange& points,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::const_type PointMap;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
std::vector<std::size_t> scales;
estimate_local_k_neighbor_scales (points, points, std::back_inserter (scales), np.query_point_map(point_map));
std::sort (scales.begin(), scales.end());
@ -643,15 +647,17 @@ estimate_local_range_scales(
OutputIterator output,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::const_type PointMap;
typedef typename Point_set_processing_3::GetQueryPointMap<QueryPointRange, NamedParameters>::const_type QueryPointMap;
typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
typedef typename boost::property_traits<PointMap>::value_type Point_d;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
QueryPointMap query_point_map = choose_param(get_param(np, internal_np::query_point_map), QueryPointMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
QueryPointMap query_point_map = choose_parameter(get_parameter(np, internal_np::query_point_map), QueryPointMap());
// Build multi-scale KD-tree
internal::Quick_multiscale_approximate_knn_distance<Kernel, Point_d> kdtree (points.begin(),
@ -726,10 +732,12 @@ estimate_global_range_scale(
const PointRange& points,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
std::vector<double> scales;
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::const_type PointMap;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
estimate_local_range_scales (points, points, std::back_inserter (scales), np.query_point_map(point_map));
std::sort (scales.begin(), scales.end());
return std::sqrt (scales[scales.size() / 2]);

11
Point_set_processing_3/include/CGAL/grid_simplify_point_set.h
View File

@ -32,7 +32,7 @@
#include <functional>
#include <boost/functional/hash.hpp>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -208,12 +208,13 @@ grid_simplify_point_set(
double epsilon,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::const_type PointMap;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
std::function<bool(double)>());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
const std::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
std::function<bool(double)>());
// actual type of input points
typedef typename std::iterator_traits<typename PointRange::iterator>::value_type Enriched_point;

15
Point_set_processing_3/include/CGAL/hierarchy_simplify_point_set.h
View File

@ -41,7 +41,7 @@
#include <CGAL/Iterator_range.h>
#include <functional>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
namespace CGAL {
@ -161,7 +161,8 @@ namespace CGAL {
hierarchy_simplify_point_set (PointRange& points,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -172,11 +173,11 @@ namespace CGAL {
typedef typename Kernel::Vector_3 Vector;
typedef typename Kernel::FT FT;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
unsigned int size = choose_param(get_param(np, internal_np::size), 10);
double var_max = choose_param(get_param(np, internal_np::maximum_variation), 1./3.);
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
std::function<bool(double)>());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
unsigned int size = choose_parameter(get_parameter(np, internal_np::size), 10);
double var_max = choose_parameter(get_parameter(np, internal_np::maximum_variation), 1./3.);
const std::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
std::function<bool(double)>());
typedef typename std::iterator_traits<typename PointRange::iterator>::value_type Input_type;

13
Point_set_processing_3/include/CGAL/jet_estimate_normals.h
View File

@ -35,7 +35,7 @@
#include <CGAL/Memory_sizer.h>
#include <functional>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -206,7 +206,8 @@ jet_estimate_normals(
unsigned int k,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_TRACE("Calls jet_estimate_normals()\n");
@ -224,10 +225,10 @@ jet_estimate_normals(
typename GetSvdTraits<NamedParameters>::NoTraits>::value),
"Error: no SVD traits");
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2);
FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), FT(0));
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
unsigned int degree_fitting = choose_parameter(get_parameter(np, internal_np::degree_fitting), 2);
FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), FT(0));
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
std::function<bool(double)>());

17
Point_set_processing_3/include/CGAL/jet_smooth_point_set.h
View File

@ -34,7 +34,7 @@
#include <CGAL/point_set_processing_assertions.h>
#include <functional>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -210,7 +210,8 @@ jet_smooth_point_set(
unsigned int k,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -221,12 +222,12 @@ jet_smooth_point_set(
typename GetSvdTraits<NamedParameters>::NoTraits>::value),
"Error: no SVD traits");
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
typename Kernel::FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius),
typename Kernel::FT(0));
unsigned int degree_fitting = choose_param(get_param(np, internal_np::degree_fitting), 2);
unsigned int degree_monge = choose_param(get_param(np, internal_np::degree_monge), 2);
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
typename Kernel::FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius),
typename Kernel::FT(0));
unsigned int degree_fitting = choose_parameter(get_parameter(np, internal_np::degree_fitting), 2);
unsigned int degree_monge = choose_parameter(get_parameter(np, internal_np::degree_monge), 2);
const std::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
std::function<bool(double)>());
typedef typename Kernel::Point_3 Point;

10
Point_set_processing_3/include/CGAL/mst_orient_normals.h
View File

@ -36,7 +36,7 @@
#include <CGAL/point_set_processing_assertions.h>
#include <CGAL/use.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -613,7 +613,9 @@ mst_orient_normals(
unsigned int k,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_TRACE("Calls mst_orient_normals()\n");
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -625,8 +627,8 @@ mst_orient_normals(
typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value),
"Error: no normal map");
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
typename Kernel::FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius),
typename Kernel::FT(0));
ConstrainedMap constrained_map = choose_param(get_param(np, internal_np::point_is_constrained), ConstrainedMap());

16
Point_set_processing_3/include/CGAL/pca_estimate_normals.h
View File

@ -36,7 +36,7 @@
#include <CGAL/Memory_sizer.h>
#include <functional>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -195,7 +195,9 @@ pca_estimate_normals(
unsigned int k,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_TRACE("Calls pca_estimate_normals()\n");
// basic geometric types
@ -208,11 +210,11 @@ pca_estimate_normals(
typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value),
"Error: no normal map");
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius), FT(0));
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
std::function<bool(double)>());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), FT(0));
const std::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
std::function<bool(double)>());
typedef typename Kernel::Point_3 Point;

2
Point_set_processing_3/include/CGAL/random_simplify_point_set.h
View File

@ -31,7 +31,7 @@
#include <CGAL/point_set_processing_assertions.h>
#include <CGAL/Iterator_range.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>

15
Point_set_processing_3/include/CGAL/remove_outliers.h
View File

@ -32,7 +32,7 @@
#include <CGAL/point_set_processing_assertions.h>
#include <functional>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <iterator>
@ -153,17 +153,18 @@ remove_outliers(
unsigned int k,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
typename Kernel::FT neighbor_radius = choose_param(get_param(np, internal_np::neighbor_radius),
typename Kernel::FT(0));
double threshold_percent = choose_param(get_param(np, internal_np::threshold_percent), 10.);
double threshold_distance = choose_param(get_param(np, internal_np::threshold_distance), 0.);
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
typename Kernel::FT neighbor_radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius),
typename Kernel::FT(0));
double threshold_percent = choose_parameter(get_parameter(np, internal_np::threshold_percent), 10.);
double threshold_distance = choose_parameter(get_parameter(np, internal_np::threshold_distance), 0.);
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
std::function<bool(double)>());

18
Point_set_processing_3/include/CGAL/structure_point_set.h
View File

@ -42,7 +42,7 @@
#include <CGAL/Delaunay_triangulation_3.h>
#include <CGAL/Triangulation_vertex_base_with_info_3.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <boost/iterator/counting_iterator.hpp>
@ -211,7 +211,8 @@ public:
double epsilon,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
@ -226,11 +227,11 @@ public:
typename Point_set_processing_3::GetPlaneIndexMap<NamedParameters>::NoMap>::value),
"Error: no plane index map");
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PlaneMap plane_map = choose_param(get_param(np, internal_np::plane_map), PlaneMap());
PlaneIndexMap index_map = choose_param(get_param(np, internal_np::plane_index_map), PlaneIndexMap());
double attraction_factor = choose_param(get_param(np, internal_np::attraction_factor), 3.);
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
PlaneMap plane_map = choose_parameter(get_parameter(np, internal_np::plane_map), PlaneMap());
PlaneIndexMap index_map = choose_parameter(get_parameter(np, internal_np::plane_index_map), PlaneIndexMap());
double attraction_factor = choose_parameter(get_parameter(np, internal_np::attraction_factor), 3.);
m_points.reserve(points.size());
m_normals.reserve(points.size());
@ -1529,7 +1530,8 @@ structure_point_set (const PointRange& points,
double epsilon,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;

16
Point_set_processing_3/include/CGAL/vcm_estimate_normals.h
View File

@ -38,7 +38,7 @@
#include <CGAL/Orthogonal_k_neighbor_search.h>
#include <CGAL/Fuzzy_sphere.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/Default_diagonalize_traits.h>
@ -265,12 +265,14 @@ compute_vcm (const PointRange& points,
double convolution_radius,
const NamedParameters& np)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
Kernel kernel;
// First, compute the VCM for each point
@ -323,7 +325,9 @@ vcm_estimate_normals_internal (PointRange& points,
int nb_neighbors_convolve = -1 ///< number of neighbors used during the convolution.
)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
typedef typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::type NormalMap;
@ -334,8 +338,8 @@ vcm_estimate_normals_internal (PointRange& points,
typename Point_set_processing_3::GetNormalMap<PointRange, NamedParameters>::NoMap>::value),
"Error: no normal map");
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_param(get_param(np, internal_np::normal_map), NormalMap());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
typedef std::array<double, 6> Covariance;

19
Point_set_processing_3/include/CGAL/wlop_simplify_and_regularize_point_set.h
View File

@ -32,7 +32,7 @@
#include <CGAL/Memory_sizer.h>
#include <CGAL/compute_average_spacing.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/algorithm.h>
#include <iterator>
@ -470,19 +470,20 @@ wlop_simplify_and_regularize_point_set(
const NamedParameters& np
)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// basic geometric types
typedef typename Point_set_processing_3::GetPointMap<PointRange, NamedParameters>::type PointMap;
typedef typename Point_set_processing_3::GetK<PointRange, NamedParameters>::Kernel Kernel;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
double select_percentage = choose_param(get_param(np, internal_np::select_percentage), 5.);
double radius = choose_param(get_param(np, internal_np::neighbor_radius), -1);
unsigned int iter_number = choose_param(get_param(np, internal_np::number_of_iterations), 35);
bool require_uniform_sampling = choose_param(get_param(np, internal_np::require_uniform_sampling), false);
const std::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
std::function<bool(double)>());
PointMap point_map = choose_parameter(get_parameter(np, internal_np::point_map), PointMap());
double select_percentage = choose_parameter(get_parameter(np, internal_np::select_percentage), 5.);
double radius = choose_parameter(get_parameter(np, internal_np::neighbor_radius), -1);
unsigned int iter_number = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 35);
bool require_uniform_sampling = choose_parameter(get_parameter(np, internal_np::require_uniform_sampling), false);
const std::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
std::function<bool(double)>());
typedef typename Kernel::Point_3 Point;
typedef typename Kernel::FT FT;

32
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h
View File

@ -65,14 +65,14 @@ namespace CGAL {
CGAL::Bbox_3 bbox(const PolygonMesh& pmesh,
const CGAL_PMP_NP_CLASS& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typename GetVertexPointMap<PolygonMesh, CGAL_PMP_NP_CLASS>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
typedef typename GetGeomTraits<PolygonMesh, CGAL_PMP_NP_CLASS>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
typedef typename boost::graph_traits<PolygonMesh>::vertex_descriptor vertex_descriptor;
@ -115,14 +115,14 @@ namespace CGAL {
const PolygonMesh& pmesh,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
return get_bbox( get(vpm, vd) );
@ -158,14 +158,14 @@ namespace CGAL {
const PolygonMesh& pmesh,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
return get_bbox( get(vpm, source(ed, pmesh)) ) +
@ -202,14 +202,14 @@ namespace CGAL {
const PolygonMesh& pmesh,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;

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

@ -199,8 +199,8 @@ namespace Polygon_mesh_processing {
}
//face index map given as a named parameter, or as an internal property map
FIMap fim = boost::choose_param(get_param(np, internal_np::face_index),
get_const_property_map(CGAL::face_index, pmesh));
FIMap fim = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
get_const_property_map(CGAL::face_index, pmesh));
return internal::border_halfedges_impl(faces, fim, out, pmesh, np);
}

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

@ -71,7 +71,7 @@ clip_to_bbox(const Plane_3& plane,
typedef typename GetVertexPointMap<TriangleMesh,
NamedParameters>::type Vpm;
Vpm vpm_out = boost::choose_param(boost::get_param(np, internal_np::vertex_point),
Vpm vpm_out = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm_out));
@ -334,7 +334,7 @@ clip( TriangleMesh& tm,
const NamedParameters2& np_c)
{
const bool clip_volume =
boost::choose_param(boost::get_param(np_tm, internal_np::clip_volume), false);
parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::clip_volume), false);
if (clip_volume && is_closed(tm))
return corefine_and_compute_intersection(tm, clipper, tm, np_tm, np_c);

17
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/compute_normal.h
View File

@ -137,14 +137,14 @@ compute_face_normal(typename boost::graph_traits<PolygonMesh>::face_descriptor f
, const PolygonMesh& pmesh
, const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT traits = choose_param(get_param(np, internal_np::geom_traits), GT());
GT traits = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VPMap;
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
typedef typename GT::Point_3 Point;
@ -234,18 +234,19 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
const NamedParameters& np
)
{
using boost::choose_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
typedef typename GT::Vector_3 Vector;
GT traits = choose_param(get_param(np, internal_np::geom_traits), GT());
GT traits = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typedef typename GetFaceNormalMap<PolygonMesh, NamedParameters>::NoMap DefaultMap;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::face_normal_t,
NamedParameters,
DefaultMap> ::type FaceNormalMap;
FaceNormalMap fnmap = choose_param(get_param(np, internal_np::face_normal), DefaultMap());
FaceNormalMap fnmap = choose_parameter(get_parameter(np, internal_np::face_normal), DefaultMap());
bool fnmap_valid
= !boost::is_same<FaceNormalMap,
DefaultMap

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

@ -29,7 +29,7 @@
#include<set>
#include<vector>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/helpers.h>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/filtered_graph.hpp>
@ -132,16 +132,16 @@ connected_component(typename boost::graph_traits<PolygonMesh>::face_descriptor s
, FaceOutputIterator out
, const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters,
internal::No_constraint<PolygonMesh>//default
> ::type EdgeConstraintMap;
EdgeConstraintMap ecmap
= choose_param(get_param(np, internal_np::edge_is_constrained),
= choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
internal::No_constraint<PolygonMesh>());
typedef typename boost::graph_traits<PolygonMesh>::face_descriptor face_descriptor;
@ -212,16 +212,16 @@ connected_components(const PolygonMesh& pmesh,
FaceComponentMap fcm,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters,
internal::No_constraint<PolygonMesh>//default
> ::type EdgeConstraintMap;
EdgeConstraintMap ecmap
= choose_param(get_param(np, internal_np::edge_is_constrained),
= choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
internal::No_constraint<PolygonMesh>());
typedef Dual<PolygonMesh> Dual;
@ -233,7 +233,7 @@ connected_components(const PolygonMesh& pmesh,
internal::No_border<PolygonMesh, EdgeConstraintMap>(pmesh, ecmap));
typename GetFaceIndexMap<PolygonMesh, NamedParameters>::const_type
fimap = choose_param(get_param(np, internal_np::face_index),
fimap = choose_parameter(get_parameter(np, internal_np::face_index),
get_const_property_map(boost::face_index, pmesh));
return boost::connected_components(finite_dual,
@ -304,13 +304,13 @@ std::size_t keep_largest_connected_components(PolygonMesh& pmesh,
typedef PolygonMesh PM;
typedef typename boost::graph_traits<PM>::face_descriptor face_descriptor;
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// FaceIndexMap
typedef typename GetFaceIndexMap<PM, NamedParameters>::type FaceIndexMap;
FaceIndexMap fimap = choose_param(get_param(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
FaceIndexMap fimap = choose_parameter(get_parameter(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
// FaceSizeMap
typedef typename boost::lookup_named_param_def<internal_np::face_size_map_t,
@ -411,13 +411,13 @@ std::size_t keep_large_connected_components(PolygonMesh& pmesh,
typedef PolygonMesh PM;
typedef typename boost::graph_traits<PM>::face_descriptor face_descriptor;
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
// FaceIndexMap
typedef typename GetFaceIndexMap<PM, NamedParameters>::type FaceIndexMap;
FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
typedef typename boost::lookup_named_param_def<internal_np::face_size_map_t,
NamedParameters,
@ -477,8 +477,8 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
, const NamedParameters& np)
{
typedef PolygonMesh PM;
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::graph_traits<PolygonMesh>::face_descriptor face_descriptor;
typedef typename boost::graph_traits<PolygonMesh>::face_iterator face_iterator;
@ -490,7 +490,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
//VertexIndexMap
typedef typename GetVertexIndexMap<PM, NamedParameters>::type VertexIndexMap;
VertexIndexMap vim = choose_param(get_param(np, internal_np::vertex_index),
VertexIndexMap vim = choose_parameter(get_parameter(np, internal_np::vertex_index),
get_const_property_map(boost::vertex_index, pmesh));
std::set<std::size_t> cc_to_keep;
@ -727,12 +727,12 @@ void remove_connected_components(PolygonMesh& pmesh
if (components_to_remove.empty()) return;
typedef PolygonMesh PM;
typedef typename boost::graph_traits<PM>::face_descriptor face_descriptor;
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
//FaceIndexMap
typedef typename GetFaceIndexMap<PM, CGAL_PMP_NP_CLASS>::type FaceIndexMap;
FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index),
FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
//vector_property_map
@ -785,12 +785,12 @@ void keep_connected_components(PolygonMesh& pmesh
typedef PolygonMesh PM;
typedef typename boost::graph_traits<PM>::face_descriptor face_descriptor;
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
//FaceIndexMap
typedef typename GetFaceIndexMap<PM, CGAL_PMP_NP_CLASS>::type FaceIndexMap;
FaceIndexMap fim = choose_param(get_param(np, internal_np::face_index),
FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
//vector_property_map

76
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h
View File

@ -193,10 +193,10 @@ bool does_bound_a_volume(const TriangleMesh& tm, const NamedParameters& np)
if (!is_closed(tm)) return false;
if (!is_triangle_mesh(tm)) return false;
Vpm vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point),
Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm));
Fid_map fid_map = boost::choose_param(boost::get_param(np, internal_np::face_index),
Fid_map fid_map = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
get_const_property_map(boost::face_index, tm));
std::vector<std::size_t> face_cc(num_faces(tm), std::size_t(-1));
@ -249,14 +249,14 @@ bool does_bound_a_volume(const TriangleMesh& tm)
/// \endcond
#define CGAL_COREF_SET_OUTPUT_EDGE_MARK_MAP(I) \
typedef typename boost::lookup_named_param_def < \
typedef typename internal_np::Lookup_named_param_def < \
internal_np::edge_is_constrained_t, \
NamedParametersOut##I, \
Corefinement::No_mark<TriangleMesh> \
> ::type Ecm_out_##I; \
Ecm_out_##I ecm_out_##I = \
boost::choose_param( boost::get_param(std::get<I>(nps_out), internal_np::edge_is_constrained), \
Corefinement::No_mark<TriangleMesh>() );
internal_np::choose_parameter( internal_np::get_parameter(std::get<I>(nps_out), internal_np::edge_is_constrained), \
Corefinement::No_mark<TriangleMesh>() );
/**
@ -361,7 +361,7 @@ corefine_and_compute_boolean_operations(
NamedParametersOut3>& nps_out)
{
const bool throw_on_self_intersection =
boost::choose_param(boost::get_param(np1, internal_np::throw_on_self_intersection), false);
parameters::choose_parameter(parameters::get_parameter(np1, internal_np::throw_on_self_intersection), false);
// Vertex point maps
//for input meshes
@ -374,10 +374,10 @@ corefine_and_compute_boolean_operations(
static const bool same_vpm = (boost::is_same<Vpm,Vpm2>::value); )
CGAL_static_assertion(same_vpm);
Vpm vpm1 = boost::choose_param(boost::get_param(np1, internal_np::vertex_point),
Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm1));
Vpm vpm2 = boost::choose_param(boost::get_param(np2, internal_np::vertex_point),
Vpm vpm2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm2));
typedef typename boost::property_traits<Vpm>::value_type Point_3;
@ -494,21 +494,21 @@ corefine_and_compute_boolean_operations(
// Edge is-constrained maps
//for input meshes
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters1,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm1;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters2,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm2;
Ecm1 ecm1 = boost::choose_param( boost::get_param(np1, internal_np::edge_is_constrained),
Ecm1 ecm1 = parameters::choose_parameter( parameters::get_parameter(np1, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
Ecm2 ecm2 = boost::choose_param( boost::get_param(np2, internal_np::edge_is_constrained),
Ecm2 ecm2 = parameters::choose_parameter( parameters::get_parameter(np2, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
typedef Corefinement::Ecm_bind<TriangleMesh, Ecm1, Ecm2> Ecm_in;
@ -533,17 +533,17 @@ corefine_and_compute_boolean_operations(
static const bool same_fidmap = (boost::is_same<Fid_map,Fid_map2>::value);)
CGAL_static_assertion(same_fidmap);
Fid_map fid_map1 = boost::choose_param(boost::get_param(np1, internal_np::face_index),
Fid_map fid_map1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::face_index),
get_property_map(boost::face_index, tm1));
Fid_map fid_map2 = boost::choose_param(boost::get_param(np2, internal_np::face_index),
Fid_map fid_map2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::face_index),
get_property_map(boost::face_index, tm2));
// User visitor
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::graph_visitor_t,
NamedParameters1,
Corefinement::Default_visitor<TriangleMesh>//default
> ::type User_visitor;
User_visitor uv( boost::choose_param( boost::get_param(np1, internal_np::graph_visitor),
User_visitor uv( parameters::choose_parameter( parameters::get_parameter(np1, internal_np::graph_visitor),
Corefinement::Default_visitor<TriangleMesh>() ) );
// surface intersection algorithm call
@ -564,7 +564,7 @@ corefine_and_compute_boolean_operations(
vpm_out_tuple, ecms_out, uv, output);
// special case used for clipping open meshes
if ( boost::choose_param( boost::get_param(np1, internal_np::use_bool_op_to_clip_surface),
if ( parameters::choose_parameter( parameters::get_parameter(np1, internal_np::use_bool_op_to_clip_surface),
false) )
{
CGAL_assertion(output[Corefinement::INTERSECTION] != boost::none);
@ -572,7 +572,7 @@ corefine_and_compute_boolean_operations(
CGAL_assertion(output[Corefinement::TM1_MINUS_TM2] == boost::none);
CGAL_assertion(output[Corefinement::TM2_MINUS_TM1] == boost::none);
const bool use_compact_clipper =
boost::choose_param( boost::get_param(np1, internal_np::use_compact_clipper),
parameters::choose_parameter( parameters::get_parameter(np1, internal_np::use_compact_clipper),
true);
ob.setup_for_clipping_a_surface(use_compact_clipper);
}
@ -841,7 +841,7 @@ corefine_and_compute_difference( TriangleMesh& tm1,
const NamedParameters2& np2)
{
const bool throw_on_self_intersection =
boost::choose_param(boost::get_param(np1, internal_np::throw_on_self_intersection), false);
parameters::choose_parameter(parameters::get_parameter(np1, internal_np::throw_on_self_intersection), false);
// Vertex point maps
typedef typename GetVertexPointMap<TriangleMesh,
@ -853,28 +853,28 @@ corefine_and_compute_difference( TriangleMesh& tm1,
static const bool same_vpm = (boost::is_same<Vpm,Vpm2>::value);)
CGAL_static_assertion(same_vpm);
Vpm vpm1 = boost::choose_param(boost::get_param(np1, internal_np::vertex_point),
Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm1));
Vpm vpm2 = boost::choose_param(boost::get_param(np2, internal_np::vertex_point),
Vpm vpm2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm2));
// Edge is-constrained maps
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters1,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm1;
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters2,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm2;
Ecm1 ecm1 = boost::choose_param( boost::get_param(np1, internal_np::edge_is_constrained),
Ecm1 ecm1 = parameters::choose_parameter( parameters::get_parameter(np1, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
Ecm2 ecm2 = boost::choose_param( boost::get_param(np2, internal_np::edge_is_constrained),
Ecm2 ecm2 = parameters::choose_parameter( parameters::get_parameter(np2, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
typedef Corefinement::Ecm_bind<TriangleMesh, Ecm1, Ecm2> Ecm;
@ -887,12 +887,12 @@ corefine_and_compute_difference( TriangleMesh& tm1,
}
// User visitor
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::graph_visitor_t,
NamedParameters1,
Corefinement::Default_visitor<TriangleMesh>//default
> ::type User_visitor;
User_visitor uv( boost::choose_param( boost::get_param(np1, internal_np::graph_visitor),
User_visitor uv( parameters::choose_parameter( parameters::get_parameter(np1, internal_np::graph_visitor),
Corefinement::Default_visitor<TriangleMesh>() ) );
// surface intersection algorithm call
@ -945,27 +945,27 @@ namespace experimental {
typedef typename GetVertexPointMap<TriangleMesh,
NamedParameters>::type Vpm;
Vpm vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point),
Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm));
// Edge is-constrained maps
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm;
Ecm ecm = boost::choose_param( boost::get_param(np, internal_np::edge_is_constrained),
Ecm ecm = parameters::choose_parameter( parameters::get_parameter(np, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
// User visitor
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::graph_visitor_t,
NamedParameters,
Corefinement::Default_visitor<TriangleMesh>//default
> ::type User_visitor;
User_visitor uv( boost::choose_param( boost::get_param(np, internal_np::graph_visitor),
User_visitor uv( parameters::choose_parameter( parameters::get_parameter(np, internal_np::graph_visitor),
Corefinement::Default_visitor<TriangleMesh>() ) );
@ -1020,28 +1020,28 @@ namespace experimental {
// Vertex point maps
typedef typename GetVertexPointMap<TriangleMesh,
NamedParameters>::type Vpm;
Vpm vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point),
Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_property_map(boost::vertex_point, tm));
// Face index map
typedef typename GetFaceIndexMap<TriangleMesh,
NamedParameters>::type Fid_map;
Fid_map fid_map = boost::choose_param(boost::get_param(np, internal_np::face_index),
Fid_map fid_map = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
get_property_map(boost::face_index, tm));
// Edge is-constrained maps
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters,
Corefinement::No_mark<TriangleMesh>//default
> ::type Ecm;
Ecm ecm = boost::choose_param( boost::get_param(np, internal_np::edge_is_constrained),
Ecm ecm = parameters::choose_parameter( parameters::get_parameter(np, internal_np::edge_is_constrained),
Corefinement::No_mark<TriangleMesh>() );
// User visitor
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::graph_visitor_t,
NamedParameters,
Corefinement::Default_visitor<TriangleMesh>//default
> ::type User_visitor;
User_visitor uv( boost::choose_param( boost::get_param(np, internal_np::graph_visitor),
User_visitor uv( parameters::choose_parameter( parameters::get_parameter(np, internal_np::graph_visitor),
Corefinement::Default_visitor<TriangleMesh>() ) );
// surface intersection algorithm call

14
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/detect_features.h
View File

@ -149,11 +149,11 @@ detect_surface_patches(PolygonMesh& p,
{
//extract types from NPs
typename GetFaceIndexMap<PolygonMesh, NamedParameters>::const_type
fimap = boost::choose_param(get_param(np, internal_np::face_index),
fimap = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
get_const_property_map(boost::face_index, p));
int offset = static_cast<int>(
boost::choose_param(get_param(np, internal_np::first_index),
parameters::choose_parameter(parameters::get_parameter(np, internal_np::first_index),
1));
internal::PatchIdMapWrapper<PatchIdMap,
@ -216,7 +216,7 @@ template<typename GT,
void sharp_call(PolygonMesh& pmesh,
FT& angle_in_deg,
EIFMap edge_is_feature_map,
const boost::param_not_found&)
const internal_np::Param_not_found&)
{
typedef typename boost::graph_traits<PolygonMesh>::edge_descriptor edge_descriptor;
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
@ -286,10 +286,10 @@ void detect_sharp_edges(PolygonMesh& pmesh,
{
//extract types from NPs
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
typedef typename GetGeomTraits<PolygonMesh, GT>::type::FT FT;
typedef typename GT::FT FT;
internal::sharp_call<GT, FT>(pmesh, angle_in_deg, edge_is_feature_map,
get_param(np, internal_np::vertex_feature_degree));
parameters::get_parameter(np, internal_np::vertex_feature_degree));
}
@ -365,7 +365,7 @@ namespace internal
template<typename PolygonMesh,
typename PIDMap,
typename EIFMap>
void vip_call(PolygonMesh&, PIDMap, const boost::param_not_found&, EIFMap)
void vip_call(PolygonMesh&, PIDMap, const internal_np::Param_not_found&, EIFMap)
{
//do nothing when the parameter is not given
}
@ -440,7 +440,7 @@ sharp_edges_segmentation(PolygonMesh& pmesh,
internal::detect_surface_patches(pmesh, patch_id_map, edge_is_feature_map, np);
internal::vip_call(pmesh, patch_id_map,
get_param(np, internal_np::vertex_incident_patches), edge_is_feature_map);
parameters::get_parameter(np, internal_np::vertex_incident_patches), edge_is_feature_map);
return result;
}

46
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/distance.h
View File

@ -340,32 +340,32 @@ sample_triangle_mesh(const TriangleMesh& tm,
typedef typename GT::halfedge_descriptor halfedge_descriptor;
typedef typename GT::edge_descriptor edge_descriptor;
using boost::choose_param;
using boost::get_param;
using boost::is_default_param;
using parameters::choose_parameter;
using parameters::get_parameter;
using parameters::is_default_parameter;
Vpm pmap = choose_param(get_param(np, internal_np::vertex_point),
Vpm pmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm));
typedef Creator_uniform_3<typename Geom_traits::FT,
typename Geom_traits::Point_3> Creator;
Geom_traits geomtraits = choose_param(get_param(np, internal_np::geom_traits), Geom_traits());
Geom_traits geomtraits = choose_parameter(get_parameter(np, internal_np::geom_traits), Geom_traits());
bool use_rs = choose_param(get_param(np, internal_np::random_uniform_sampling), true);
bool use_gs = choose_param(get_param(np, internal_np::grid_sampling), false);
bool use_ms = choose_param(get_param(np, internal_np::monte_carlo_sampling), false);
bool use_rs = choose_parameter(get_parameter(np, internal_np::random_uniform_sampling), true);
bool use_gs = choose_parameter(get_parameter(np, internal_np::grid_sampling), false);
bool use_ms = choose_parameter(get_parameter(np, internal_np::monte_carlo_sampling), false);
if (use_gs || use_ms)
if (is_default_param(get_param(np, internal_np::random_uniform_sampling)))
if (is_default_parameter(get_parameter(np, internal_np::random_uniform_sampling)))
use_rs=false;
bool smpl_vrtcs = choose_param(get_param(np, internal_np::do_sample_vertices), true);
bool smpl_dgs = choose_param(get_param(np, internal_np::do_sample_edges), true);
bool smpl_fcs = choose_param(get_param(np, internal_np::do_sample_faces), true);
bool smpl_vrtcs = choose_parameter(get_parameter(np, internal_np::do_sample_vertices), true);
bool smpl_dgs = choose_parameter(get_parameter(np, internal_np::do_sample_edges), true);
bool smpl_fcs = choose_parameter(get_parameter(np, internal_np::do_sample_faces), true);
double nb_pts_a_u = choose_param(get_param(np, internal_np::nb_points_per_area_unit), 0.);
double nb_pts_l_u = choose_param(get_param(np, internal_np::nb_points_per_distance_unit), 0.);
double nb_pts_a_u = choose_parameter(get_parameter(np, internal_np::nb_points_per_area_unit), 0.);
double nb_pts_l_u = choose_parameter(get_parameter(np, internal_np::nb_points_per_distance_unit), 0.);
// sample vertices
if (smpl_vrtcs)
@ -380,7 +380,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
// grid sampling
if (use_gs)
{
double grid_spacing_ = choose_param(get_param(np, internal_np::grid_spacing), 0.);
double grid_spacing_ = choose_parameter(get_parameter(np, internal_np::grid_spacing), 0.);
if (grid_spacing_==0.)
{
// set grid spacing to the shortest edge length
@ -407,9 +407,9 @@ sample_triangle_mesh(const TriangleMesh& tm,
double min_edge_length = (std::numeric_limits<double>::max)();
std::size_t nb_points_per_face =
choose_param(get_param(np, internal_np::number_of_points_per_face), 0);
choose_parameter(get_parameter(np, internal_np::number_of_points_per_face), 0);
std::size_t nb_points_per_edge =
choose_param(get_param(np, internal_np::number_of_points_per_edge), 0);
choose_parameter(get_parameter(np, internal_np::number_of_points_per_edge), 0);
if ((nb_points_per_face == 0 && nb_pts_a_u ==0.) ||
(nb_points_per_edge == 0 && nb_pts_l_u ==0.) )
@ -488,7 +488,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
// sample faces
if(smpl_fcs)
{
std::size_t nb_points = choose_param(get_param(np, internal_np::number_of_points_on_faces), 0);
std::size_t nb_points = choose_parameter(get_parameter(np, internal_np::number_of_points_on_faces), 0);
Random_points_in_triangle_mesh_3<TriangleMesh, Vpm, Creator> g(tm, pmap);
if (nb_points == 0)
{
@ -504,7 +504,7 @@ sample_triangle_mesh(const TriangleMesh& tm,
if (smpl_dgs)
{
std::size_t nb_points =
choose_param(get_param(np, internal_np::number_of_points_on_edges), 0);
choose_parameter(get_parameter(np, internal_np::number_of_points_on_edges), 0);
Random_points_on_edge_list_graph_3<TriangleMesh, Vpm, Creator> g(tm, pmap);
if (nb_points == 0)
{
@ -630,7 +630,7 @@ double approximate_Hausdorff_distance( const TriangleMesh& tm1,
NamedParameters1>::type Geom_traits;
return approximate_Hausdorff_distance<Concurrency_tag, Geom_traits>(
tm1, tm2, np1, choose_param(get_param(np2, internal_np::vertex_point),
tm1, tm2, np1, parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point),
get_const_property_map(vertex_point, tm2)));
}
@ -687,7 +687,7 @@ double max_distance_to_triangle_mesh(const PointRange& points,
NamedParameters>::type Geom_traits;
return approximate_Hausdorff_distance<Concurrency_tag, Geom_traits>
(points,tm,choose_param(get_param(np, internal_np::vertex_point),
(points,tm,parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm)));
}
@ -734,8 +734,8 @@ double approximate_max_distance_to_point_set(const TriangleMesh& tm,
typename GT::halfedge_descriptor hd(halfedge(f,tm));
for(int i=0; i<3; ++i)
{
points[i] = get(choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm)),
points[i] = get(parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm)),
target(hd, tm));
hd = next(hd, tm);
}

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

@ -28,7 +28,7 @@
#include <CGAL/Polygon_mesh_processing/orientation.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/copy_face_graph.h>
#include <CGAL/Kernel_traits.h>
#include <CGAL/boost/graph/Euler_operations.h>
@ -178,9 +178,12 @@ void extrude_mesh(const InputMesh& input,
typedef typename GetVertexPointMap < OutputMesh, NamedParameters2>::type VPMap;
typedef typename GetVertexPointMap < InputMesh, NamedParameters1>::const_type IVPMap;
VPMap output_vpm = choose_param(get_param(np_out, internal_np::vertex_point),
using parameters::get_parameter;
using parameters::choose_parameter;
VPMap output_vpm = choose_parameter(get_parameter(np_out, internal_np::vertex_point),
get_property_map(vertex_point, output));
IVPMap input_vpm = choose_param(get_param(np_in, internal_np::vertex_point),
IVPMap input_vpm = choose_parameter(get_parameter(np_in, internal_np::vertex_point),
get_const_property_map(vertex_point, input));
std::vector<std::pair<input_vertex_descriptor, output_vertex_descriptor> > bottom_v2v;
@ -273,7 +276,7 @@ void extrude_mesh(const InputMesh& input,
const NamedParameters2& np_out)
{
typedef typename GetVertexPointMap < OutputMesh, NamedParameters2>::type VPMap;
VPMap output_vpm = choose_param(get_param(np_out, internal_np::vertex_point),
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<

12
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/fair.h
View File

@ -116,8 +116,8 @@ namespace internal {
const VertexRange& vertices,
const NamedParameters& np)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
CGAL_precondition(is_triangle_mesh(tmesh));
@ -149,13 +149,13 @@ namespace internal {
typedef CGAL::internal::Cotangent_weight_with_voronoi_area_fairing<TriangleMesh, VPMap>
Default_Weight_calculator;
VPMap vpmap_ = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap_ = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
return internal::fair(tmesh, vertices,
choose_param(get_param(np, internal_np::sparse_linear_solver), Default_solver()),
choose_param(get_param(np, internal_np::weight_calculator), Default_Weight_calculator(tmesh, vpmap_)),
choose_param(get_param(np, internal_np::fairing_continuity), 1),
choose_parameter(get_parameter(np, internal_np::sparse_linear_solver), Default_solver()),
choose_parameter(get_parameter(np, internal_np::weight_calculator), Default_Weight_calculator(tmesh, vpmap_)),
choose_parameter(get_parameter(np, internal_np::fairing_continuity), 1),
vpmap_
);
}

4
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Corefinement/face_graph_utils.h
View File

@ -206,8 +206,8 @@ boost::optional< typename TweakedGetVertexPointMap<PT, NP, PM>::type >
get_vpm(const NP& np, boost::optional<PM*> opm, boost::true_type)
{
if (boost::none == opm) return boost::none;
return boost::choose_param(
boost::get_param(np, internal_np::vertex_point),
return parameters::choose_parameter(
parameters::get_parameter(np, internal_np::vertex_point),
get_property_map(boost::vertex_point, *(*opm)) );
}

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Isotropic_remeshing/remesh_impl.h
View File

@ -1059,7 +1059,7 @@ namespace internal {
// PMP book :
// "maps the vertices back to the surface"
void project_to_surface(boost::param_not_found)
void project_to_surface(internal_np::Param_not_found)
{
//todo : handle the case of boundary vertices
#ifdef CGAL_PMP_REMESHING_VERBOSE

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/named_function_params.h
View File

@ -25,7 +25,7 @@
#include <CGAL/license/Polygon_mesh_processing/core.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#define CGAL_PMP_NP_TEMPLATE_PARAMETERS CGAL_BGL_NP_TEMPLATE_PARAMETERS
#define CGAL_PMP_NP_CLASS CGAL_BGL_NP_CLASS

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

@ -402,8 +402,8 @@ compute_face_face_intersection(const FaceRange& face_range1,
const NamedParameters1& np1,
const NamedParameters2& np2)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
CGAL_precondition(CGAL::is_triangle_mesh(tm1));
CGAL_precondition(CGAL::is_triangle_mesh(tm2));
@ -433,9 +433,9 @@ compute_face_face_intersection(const FaceRange& face_range1,
typedef typename GetVertexPointMap<TM, NamedParameters1>::const_type VertexPointMap1;
typedef typename GetVertexPointMap<TM, NamedParameters2>::const_type VertexPointMap2;
VertexPointMap1 vpmap1 = choose_param(get_param(np1, internal_np::vertex_point),
VertexPointMap1 vpmap1 = choose_parameter(get_parameter(np1, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm1));
VertexPointMap2 vpmap2 = choose_param(get_param(np2, internal_np::vertex_point),
VertexPointMap2 vpmap2 = choose_parameter(get_parameter(np2, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm2));
CGAL_static_assertion(
(boost::is_same<
@ -461,7 +461,7 @@ compute_face_face_intersection(const FaceRange& face_range1,
// compute intersections filtered out by boxes
typedef typename GetGeomTraits<TM, NamedParameters1>::type GeomTraits;
GeomTraits gt = choose_param(get_param(np1, internal_np::geom_traits), GeomTraits());
GeomTraits gt = choose_parameter(get_parameter(np1, internal_np::geom_traits), GeomTraits());
internal::Intersect_faces<TM,
GeomTraits,
@ -528,8 +528,8 @@ compute_face_polyline_intersection( const FaceRange& face_range,
OutputIterator out,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_precondition(CGAL::is_triangle_mesh(tm));
@ -542,8 +542,8 @@ compute_face_polyline_intersection( const FaceRange& face_range,
typedef typename boost::graph_traits<TM>::face_descriptor face_descriptor;
typedef typename GetVertexPointMap<TM, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm));
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm));
typedef typename boost::property_traits<VertexPointMap>::value_type Point;
CGAL_static_assertion(
(boost::is_same<Point,
@ -588,7 +588,7 @@ compute_face_polyline_intersection( const FaceRange& face_range,
// compute intersections filtered out by boxes
typedef typename GetGeomTraits<TM, NamedParameters>::type GeomTraits;
GeomTraits gt = choose_param(get_param(np, internal_np::geom_traits), GeomTraits());
GeomTraits gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GeomTraits());
internal::Intersect_face_polyline<TM,
GeomTraits,
@ -657,8 +657,8 @@ compute_face_polylines_intersection(const FaceRange& face_range,
OutputIterator out,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_precondition(CGAL::is_triangle_mesh(tm));
@ -677,8 +677,8 @@ compute_face_polylines_intersection(const FaceRange& face_range,
typedef typename boost::graph_traits<TM>::face_descriptor face_descriptor;
typedef typename GetVertexPointMap<TM, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm));
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm));
typedef typename boost::property_traits<VertexPointMap>::value_type Point;
typedef typename boost::range_value<PolylineRange>::type Polyline;
CGAL_static_assertion(
@ -731,7 +731,7 @@ compute_face_polylines_intersection(const FaceRange& face_range,
// compute intersections filtered out by boxes
typedef typename GetGeomTraits<TM, NamedParameters>::type GeomTraits;
GeomTraits gt = choose_param(get_param(np, internal_np::geom_traits), GeomTraits());
GeomTraits gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GeomTraits());
internal::Intersect_face_polylines<TM,
GeomTraits,
@ -1236,10 +1236,10 @@ bool do_intersect(const TriangleMesh& tm1,
const NamedParameters1& np1,
const NamedParameters2& np2)
{
using boost::choose_param;
using boost::get_param;
bool test_overlap = choose_param(get_param(np1, internal_np::overlap_test),false) ||
choose_param(get_param(np2, internal_np::overlap_test),false);
using parameters::choose_parameter;
using parameters::get_parameter;
bool test_overlap = choose_parameter(get_parameter(np1, internal_np::overlap_test),false) ||
choose_parameter(get_parameter(np2, internal_np::overlap_test),false);
CGAL_precondition(CGAL::is_triangle_mesh(tm1));
CGAL_precondition(CGAL::is_triangle_mesh(tm2));
@ -1258,12 +1258,12 @@ bool do_intersect(const TriangleMesh& tm1,
{
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters1>::const_type VertexPointMap1;
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters2>::const_type VertexPointMap2;
VertexPointMap1 vpm1 = choose_param(get_param(np1, internal_np::vertex_point),
VertexPointMap1 vpm1 = choose_parameter(get_parameter(np1, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm1));
VertexPointMap2 vpm2 = choose_param(get_param(np2, internal_np::vertex_point),
VertexPointMap2 vpm2 = choose_parameter(get_parameter(np2, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm2));
typedef typename GetGeomTraits<TriangleMesh, NamedParameters1>::type GeomTraits;
GeomTraits gt = choose_param(get_param(np1, internal_np::geom_traits), GeomTraits());
GeomTraits gt = choose_parameter(get_parameter(np1, internal_np::geom_traits), GeomTraits());
return internal::is_mesh2_in_mesh1(tm1, tm2, vpm1, vpm2, gt) ||
internal::is_mesh2_in_mesh1(tm2, tm1, vpm2, vpm1, gt);
@ -1513,18 +1513,18 @@ struct Mesh_callback
template<class Mesh_box>
void operator()(const Mesh_box* b1, const Mesh_box* b2)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
std::size_t mesh_id_1 = std::distance(meshes.begin(), b1->info());
std::size_t mesh_id_2 = std::distance(meshes.begin(), b2->info());
VPM vpm1 = choose_param(get_param(*(nps.begin() + mesh_id_1), internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, *b1->info()));
VPM vpm1 = choose_parameter(get_parameter(*(nps.begin() + mesh_id_1), internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, *b1->info()));
VPM vpm2 = choose_param(get_param(*(nps.begin() + mesh_id_2), internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, *b2->info()));
VPM vpm2 = choose_parameter(get_parameter(*(nps.begin() + mesh_id_2), internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, *b2->info()));
//surfacic test
if(Polygon_mesh_processing::do_intersect(*b1->info(),
@ -1597,12 +1597,12 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
NamedParameters np,
NamedParametersRange nps)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename TriangleMeshRange::const_iterator TriangleMeshIterator;
bool report_overlap = choose_param(get_param(np, internal_np::overlap_test),false);
bool report_overlap = choose_parameter(get_parameter(np, internal_np::overlap_test),false);
typedef CGAL::Box_intersection_d::Box_with_info_d<double, 3, TriangleMeshIterator> Mesh_box;
std::vector<Mesh_box> boxes;
@ -1620,7 +1620,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
typedef typename boost::range_value<NamedParametersRange>::type NP_rng;
typedef typename boost::range_value<TriangleMeshRange>::type TriangleMesh;
typedef typename GetGeomTraits<TriangleMesh, NamedParameters, NP_rng>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
//get all the pairs of meshes intersecting (no strict inclusion test)
@ -1636,7 +1636,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
OutputIterator out,
NamedParameters np)
{
std::vector<cgal_bgl_named_params<bool, internal_np::all_default_t> >nps(
std::vector<Named_function_parameters<bool, internal_np::all_default_t> >nps(
std::distance(range.begin(), range.end()), parameters::all_default());
return intersecting_meshes(range, out, np, nps);
}
@ -1695,7 +1695,7 @@ surface_intersection(const TriangleMesh& tm1,
const NamedParameters2& np2)
{
const bool throw_on_self_intersection =
boost::choose_param(get_param(np1, internal_np::throw_on_self_intersection), false);
parameters::choose_parameter(parameters::get_parameter(np1, internal_np::throw_on_self_intersection), false);
typedef typename GetVertexPointMap<TriangleMesh,
NamedParameters1>::const_type Vpm;
@ -1706,12 +1706,10 @@ surface_intersection(const TriangleMesh& tm1,
static const bool same_vpm = (boost::is_same<Vpm,Vpm2>::value);)
CGAL_static_assertion(same_vpm);
Vpm vpm1 = choose_const_pmap(get_param(np1, internal_np::vertex_point),
tm1,
vertex_point);
Vpm vpm2 = choose_const_pmap(get_param(np2, internal_np::vertex_point),
tm2,
vertex_point);
Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np1, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tm1));
Vpm vpm2 = parameters::choose_parameter(parameters::get_parameter(np2, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tm2));
Corefinement::Intersection_of_triangle_meshes<TriangleMesh,Vpm>
functor(tm1, tm2, vpm1, vpm2);
@ -1755,9 +1753,8 @@ surface_self_intersection(const TriangleMesh& tm,
typedef typename GetVertexPointMap<TriangleMesh,
NamedParameters>::const_type Vpm;
Vpm vpm = choose_const_pmap(get_param(np, internal_np::vertex_point),
tm,
vertex_point);
Vpm vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tm));
// surface intersection algorithm call
typedef Corefinement::Default_surface_intersection_visitor<TriangleMesh,

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

@ -100,12 +100,12 @@ edge_length(typename boost::graph_traits<PolygonMesh>::halfedge_descriptor h,
const PolygonMesh& pmesh,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using internal_np::choose_parameter;
using internal_np::get_parameter;
typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, pmesh));
return CGAL::approximate_sqrt(CGAL::squared_distance(get(vpm, source(h, pmesh)),
get(vpm, target(h, pmesh))));
@ -321,16 +321,16 @@ face_area(typename boost::graph_traits<TriangleMesh>::face_descriptor f,
const TriangleMesh& tmesh,
const CGAL_PMP_NP_CLASS& np)
{
using boost::choose_param;
using boost::get_param;
using internal_np::choose_parameter;
using internal_np::get_parameter;
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
CGAL_precondition(boost::graph_traits<TriangleMesh>::null_face() != f);
typename GetVertexPointMap<TriangleMesh, CGAL_PMP_NP_CLASS>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
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);
@ -504,11 +504,11 @@ volume(const TriangleMesh& tmesh,
CGAL_assertion(is_triangle_mesh(tmesh));
CGAL_assertion(is_closed(tmesh));
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typename GetVertexPointMap<TriangleMesh, CGAL_PMP_NP_CLASS>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
typename GetGeomTraits<TriangleMesh, CGAL_PMP_NP_CLASS>::type::Point_3 origin(0, 0, 0);

7
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/merge_border_vertices.h
View File

@ -218,8 +218,11 @@ void merge_duplicated_vertices_in_boundary_cycle(
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameter>::const_type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pm));
using parameters::get_parameter;
using parameters::choose_parameter;
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pm));
// collect all the halfedges of the cycle
std::vector< std::pair<halfedge_descriptor, std::size_t> > cycle_hedges;

40
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h
View File

@ -69,18 +69,18 @@ namespace internal{
const PolygonMesh& pmesh,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_assertion(halfedge(v_max, pmesh)!=boost::graph_traits<PolygonMesh>::null_halfedge());
//VertexPointMap
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VPMap;
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
//Kernel
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
//among the incoming edges of `v_max`, find one edge `e` with the minimal slope
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
@ -182,16 +182,16 @@ bool is_outward_oriented(const PolygonMesh& pmesh,
if (faces(pmesh).first == faces(pmesh).second)
return true;
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
//VertexPointMap
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VPMap;
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
//Kernel
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
//find the vertex with maximal z coordinate
internal::Compare_vertex_points_z_3<GT, VPMap> less_z(vpmap, gt);
@ -482,16 +482,16 @@ void orient(TriangleMesh& tm, const NamedParameters& np)
CGAL_assertion(is_valid_polygon_mesh(tm));
CGAL_assertion(is_closed(tm));
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
bool orient_outward = choose_param(
get_param(np, internal_np::outward_orientation),true);
bool orient_outward = choose_parameter(
get_parameter(np, internal_np::outward_orientation),true);
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm));
Fid_map fid_map = choose_param(get_param(np, internal_np::face_index),
Fid_map fid_map = choose_parameter(get_parameter(np, internal_np::face_index),
get_const_property_map(boost::face_index, tm));
std::vector<std::size_t> face_cc(num_faces(tm), std::size_t(-1));
@ -589,16 +589,16 @@ void orient_to_bound_a_volume(TriangleMesh& tm,
if (!is_closed(tm)) return;
if (!is_triangle_mesh(tm)) return;
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
bool orient_outward = choose_param(
get_param(np, internal_np::outward_orientation),true);
bool orient_outward = choose_parameter(
get_parameter(np, internal_np::outward_orientation),true);
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm));
Fid_map fid_map = choose_param(get_param(np, internal_np::face_index),
Fid_map fid_map = choose_parameter(get_parameter(np, internal_np::face_index),
get_const_property_map(boost::face_index, tm));
std::vector<std::size_t> face_cc(num_faces(tm), std::size_t(-1));

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

@ -150,8 +150,8 @@ void random_perturbation(VertexRange vertices
, const NamedParameters& np)
{
typedef TriangleMesh PM;
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename boost::graph_traits<PM>::vertex_descriptor vertex_descriptor;
@ -164,22 +164,22 @@ void random_perturbation(VertexRange vertices
#endif
typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typedef typename GetVertexPointMap<PM, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::vertex_is_constrained_t,
NamedParameters,
Constant_property_map<vertex_descriptor, bool> // default
> ::type VCMap;
VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained),
Constant_property_map<vertex_descriptor, bool>(false));
VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
Constant_property_map<vertex_descriptor, bool>(false));
unsigned int seed = choose_param(get_param(np, internal_np::random_seed), -1);
bool do_project = choose_param(get_param(np, internal_np::do_project), true);
unsigned int seed = choose_parameter(get_parameter(np, internal_np::random_seed), -1);
bool do_project = choose_parameter(get_parameter(np, internal_np::do_project), true);
CGAL::Random rng = (seed == unsigned(-1)) ? CGAL::Random() : CGAL::Random(seed);

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

@ -83,20 +83,20 @@ namespace Polygon_mesh_processing {
VertexOutputIterator vertices_out,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
CGAL_precondition(is_triangle_mesh(tmesh) );
typedef typename GetVertexPointMap<TriangleMesh,NamedParameters>::type VPmap;
VPmap vpm = choose_param(get_param(np, internal_np::vertex_point),
VPmap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
internal::Refine_Polyhedron_3<TriangleMesh, VPmap> refine_functor(tmesh, vpm);
refine_functor.refine(faces,
faces_out,
vertices_out,
choose_param(get_param(np, internal_np::density_control_factor), CGAL::sqrt(2.)));
choose_parameter(get_parameter(np, internal_np::density_control_factor), CGAL::sqrt(2.)));
return std::make_pair(faces_out, vertices_out);
}

62
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/remesh.h
View File

@ -148,8 +148,8 @@ void isotropic_remeshing(const FaceRange& faces
typedef PolygonMesh PM;
typedef typename boost::graph_traits<PM>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<PM>::edge_descriptor edge_descriptor;
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
#ifdef CGAL_PMP_REMESHING_VERBOSE
std::cout << std::endl;
@ -160,45 +160,45 @@ void isotropic_remeshing(const FaceRange& faces
#endif
static const bool need_aabb_tree =
boost::is_default_param(get_param(np, internal_np::projection_functor));
parameters::is_default_parameter(get_parameter(np, internal_np::projection_functor));
typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typedef typename GetVertexPointMap<PM, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, pmesh));
typedef typename GetFaceIndexMap<PM, NamedParameters>::type FIMap;
FIMap fimap = choose_param(get_param(np, internal_np::face_index),
FIMap fimap = choose_parameter(get_parameter(np, internal_np::face_index),
get_property_map(face_index, pmesh));
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters,
Constant_property_map<edge_descriptor, bool> // default (no constraint pmap)
> ::type ECMap;
ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained),
Constant_property_map<edge_descriptor, bool>(false));
ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
Constant_property_map<edge_descriptor, bool>(false));
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::vertex_is_constrained_t,
NamedParameters,
Constant_property_map<vertex_descriptor, bool> // default (no constraint pmap)
> ::type VCMap;
VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained),
Constant_property_map<vertex_descriptor, bool>(false));
VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
Constant_property_map<vertex_descriptor, bool>(false));
bool protect = choose_param(get_param(np, internal_np::protect_constraints), false);
typedef typename boost::lookup_named_param_def <
bool protect = choose_parameter(get_parameter(np, internal_np::protect_constraints), false);
typedef typename internal_np::Lookup_named_param_def <
internal_np::face_patch_t,
NamedParameters,
internal::Connected_components_pmap<PM, FIMap>//default
> ::type FPMap;
FPMap fpmap = choose_param(
get_param(np, internal_np::face_patch),
FPMap fpmap = choose_parameter(
get_parameter(np, internal_np::face_patch),
internal::Connected_components_pmap<PM, FIMap>(faces, pmesh, ecmap, fimap,
boost::is_default_param(get_param(np, internal_np::face_patch)) && (need_aabb_tree
parameters::is_default_parameter(get_parameter(np, internal_np::face_patch)) && (need_aabb_tree
#if !defined(CGAL_NO_PRECONDITIONS)
|| protect // face patch map is used to identify patch border edges to check protected edges are short enough
#endif
@ -236,10 +236,10 @@ void isotropic_remeshing(const FaceRange& faces
std::cout << " done ("<< t.time() <<" sec)." << std::endl;
#endif
bool collapse_constraints = choose_param(get_param(np, internal_np::collapse_constraints), true);
unsigned int nb_iterations = choose_param(get_param(np, internal_np::number_of_iterations), 1);
bool smoothing_1d = choose_param(get_param(np, internal_np::relax_constraints), false);
unsigned int nb_laplacian = choose_param(get_param(np, internal_np::number_of_relaxation_steps), 1);
bool collapse_constraints = choose_parameter(get_parameter(np, internal_np::collapse_constraints), true);
unsigned int nb_iterations = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
bool smoothing_1d = choose_parameter(get_parameter(np, internal_np::relax_constraints), false);
unsigned int nb_laplacian = choose_parameter(get_parameter(np, internal_np::number_of_relaxation_steps), 1);
#ifdef CGAL_PMP_REMESHING_VERBOSE
std::cout << std::endl;
@ -260,8 +260,8 @@ void isotropic_remeshing(const FaceRange& faces
}
remesher.equalize_valences();
remesher.tangential_relaxation(smoothing_1d, nb_laplacian);
if ( choose_param(get_param(np, internal_np::do_project), true) )
remesher.project_to_surface(get_param(np, internal_np::projection_functor));
if ( choose_parameter(get_parameter(np, internal_np::do_project), true) )
remesher.project_to_surface(get_parameter(np, internal_np::projection_functor));
#ifdef CGAL_PMP_REMESHING_VERBOSE
std::cout << std::endl;
#endif
@ -337,27 +337,27 @@ void split_long_edges(const EdgeRange& edges
typedef PolygonMesh PM;
typedef typename boost::graph_traits<PM>::edge_descriptor edge_descriptor;
typedef typename boost::graph_traits<PM>::vertex_descriptor vertex_descriptor;
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
GT gt = choose_param(get_param(np, internal_np::geom_traits), GT());
GT gt = choose_parameter(get_parameter(np, internal_np::geom_traits), GT());
typedef typename GetVertexPointMap<PM, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, pmesh));
typedef typename GetFaceIndexMap<PM, NamedParameters>::type FIMap;
FIMap fimap = choose_param(get_param(np, internal_np::face_index),
FIMap fimap = choose_parameter(get_parameter(np, internal_np::face_index),
get_property_map(face_index, pmesh));
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::edge_is_constrained_t,
NamedParameters,
Constant_property_map<edge_descriptor, bool> // default (no constraint pmap)
> ::type ECMap;
ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained),
Constant_property_map<edge_descriptor, bool>(false));
ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
Constant_property_map<edge_descriptor, bool>(false));
typename internal::Incremental_remesher<PM, VPMap, GT, ECMap,
Constant_property_map<vertex_descriptor, bool>, // no constraint pmap

32
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair.h
View File

@ -581,8 +581,8 @@ bool remove_degenerate_edges(const EdgeRange& edge_range,
CGAL_assertion(CGAL::is_triangle_mesh(tmesh));
CGAL_assertion(CGAL::is_valid_polygon_mesh(tmesh));
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef TriangleMesh TM;
typedef typename boost::graph_traits<TriangleMesh> GT;
@ -592,7 +592,7 @@ bool remove_degenerate_edges(const EdgeRange& edge_range,
typedef typename GT::vertex_descriptor vertex_descriptor;
typedef typename GetVertexPointMap<TM, NamedParameters>::type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
typedef typename GetGeomTraits<TM, NamedParameters>::type Traits;
@ -1109,8 +1109,8 @@ bool remove_degenerate_faces(const FaceRange& face_range,
{
CGAL_assertion(CGAL::is_triangle_mesh(tmesh));
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef TriangleMesh TM;
typedef typename boost::graph_traits<TriangleMesh> GT;
@ -1120,10 +1120,10 @@ bool remove_degenerate_faces(const FaceRange& face_range,
typedef typename GT::vertex_descriptor vertex_descriptor;
typedef typename GetVertexPointMap<TM, NamedParameters>::type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, tmesh));
typedef typename GetGeomTraits<TM, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typedef typename boost::property_traits<VertexPointMap>::value_type Point_3;
typedef typename boost::property_traits<VertexPointMap>::reference Point_ref;
@ -2078,18 +2078,18 @@ std::size_t make_umbrella_manifold(typename boost::graph_traits<PolygonMesh>::ha
typedef typename boost::graph_traits<PolygonMesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::type VertexPointMap;
VertexPointMap vpm = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, pm));
typedef typename boost::lookup_named_param_def<internal_np::vertex_is_constrained_t,
typedef typename internal_np::Lookup_named_param_def<internal_np::vertex_is_constrained_t,
NamedParameters,
Constant_property_map<vertex_descriptor, bool> // default (no constraint pmap)
>::type VerticesMap;
VerticesMap cmap = choose_param(get_param(np, internal_np::vertex_is_constrained),
VerticesMap cmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
Constant_property_map<vertex_descriptor, bool>(false));
std::size_t nb_new_vertices = 0;
@ -2881,12 +2881,12 @@ bool remove_self_intersections(TriangleMesh& tm, const NamedParameters& np)
// named parameter extraction
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::type VertexPointMap;
VertexPointMap vpm = boost::choose_param(boost::get_param(np, internal_np::vertex_point),
VertexPointMap vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, tm));
const int max_steps = boost::choose_param(boost::get_param(np, internal_np::number_of_iterations), 7);
bool verbose = boost::choose_param(boost::get_param(np, internal_np::verbosity_level), 0) > 0;
bool preserve_genus = boost::choose_param(boost::get_param(np, internal_np::preserve_genus), true);
const int max_steps = parameters::choose_parameter(parameters::get_parameter(np, internal_np::number_of_iterations), 7);
bool verbose = parameters::choose_parameter(parameters::get_parameter(np, internal_np::verbosity_level), 0) > 0;
bool preserve_genus = parameters::choose_parameter(parameters::get_parameter(np, internal_np::preserve_genus), true);
if (verbose)
std::cout << "DEBUG: Starting remove_self_intersections, is_valid(tm)? " << is_valid_polygon_mesh(tm) << "\n";

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

@ -23,7 +23,7 @@
#include <CGAL/license/Polygon_mesh_processing/repair.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/Polygon_mesh_processing/internal/named_function_params.h>
#include <CGAL/Polygon_mesh_processing/internal/named_params_helper.h>
@ -70,7 +70,7 @@ struct Polygon_types
template <typename PointRange, typename PolygonRange, typename NamedParameters>
struct GetPolygonGeomTraits
{
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::geom_traits_t,
NamedParameters,
typename CGAL::Kernel_traits<
@ -518,11 +518,11 @@ std::size_t merge_duplicate_points_in_polygon_soup(PointRange& points,
typedef typename internal::Polygon_types<PointRange, PolygonRange>::Point_3 Point_3;
typedef typename internal::Polygon_types<PointRange, PolygonRange>::Polygon_3 Polygon_3;
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename internal::GetPolygonGeomTraits<PointRange, PolygonRange, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typedef typename Traits::Less_xyz_3 Less_xyz_3;
@ -909,13 +909,13 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
PolygonRange& polygons,
const NamedParameters& np)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename internal::Polygon_types<PointRange, PolygonRange>::P_ID P_ID;
const bool erase_all_duplicates = choose_param(get_param(np, internal_np::erase_all_duplicates), false);
const bool same_orientation = choose_param(get_param(np, internal_np::require_same_orientation), false);
const bool erase_all_duplicates = choose_parameter(get_parameter(np, internal_np::erase_all_duplicates), false);
const bool same_orientation = choose_parameter(get_parameter(np, internal_np::require_same_orientation), false);
#ifdef CGAL_PMP_REPAIR_POLYGON_SOUP_VERBOSE_PP
std::cout << "Only polygons with the same orientation are duplicates: " << std::boolalpha << same_orientation << std::endl;
@ -923,7 +923,7 @@ std::size_t merge_duplicate_polygons_in_polygon_soup(const PointRange& points,
#endif
typedef typename internal::GetPolygonGeomTraits<PointRange, PolygonRange, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
std::vector<std::vector<P_ID> > all_duplicate_polygons;
internal::collect_duplicate_polygons(points, polygons, std::back_inserter(all_duplicate_polygons), traits, same_orientation);
@ -1066,11 +1066,11 @@ void repair_polygon_soup(PointRange& points,
PolygonRange& polygons,
const NamedParameters& np)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename internal::GetPolygonGeomTraits<PointRange, PolygonRange, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
#ifdef CGAL_PMP_REPAIR_POLYGON_SOUP_VERBOSE
std::cout << "Repairing soup with " << points.size() << " points and " << polygons.size() << " polygons" << std::endl;

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

@ -272,7 +272,7 @@ self_intersections(const TriangleMesh& tmesh
#ifdef DOXYGEN_RUNNING
, const NamedParameters& np)
#else
, const cgal_bgl_named_params<P,T,R>& np)
, const Named_function_parameters<P,T,R>& np)
#endif
{
return self_intersections(faces(tmesh), tmesh, out, np);
@ -340,8 +340,8 @@ self_intersections( const FaceRange& face_range,
);
typedef typename GetVertexPointMap<TM, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = boost::choose_param(get_param(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tmesh));
VertexPointMap vpmap = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tmesh));
for(face_descriptor f : face_range)
{
@ -366,7 +366,7 @@ self_intersections( const FaceRange& face_range,
typedef typename GetGeomTraits<TM, NamedParameters>::type GeomTraits;
CGAL::internal::Intersect_facets<TM,GeomTraits,Box,OutputIterator,VertexPointMap>
intersect_facets(tmesh, out, vpmap,
boost::choose_param(get_param(np, internal_np::geom_traits), GeomTraits()));
parameters::choose_parameter(parameters::get_parameter(np, internal_np::geom_traits), GeomTraits()));
std::ptrdiff_t cutoff = 2000;
CGAL::box_self_intersection_d(box_ptr.begin(), box_ptr.end(),intersect_facets,cutoff);

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

@ -74,15 +74,15 @@ bool is_degenerate_edge(typename boost::graph_traits<PolygonMesh>::edge_descript
const PolygonMesh& pm,
const NamedParameters& np)
{
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pm));
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
return traits.equal_3_object()(get(vpmap, source(e, pm)), get(vpmap, target(e, pm)));
}
@ -127,15 +127,15 @@ bool is_degenerate_triangle_face(typename boost::graph_traits<TriangleMesh>::fac
{
CGAL_precondition(CGAL::is_triangle(halfedge(f, tm), tm));
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm));
typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typename boost::graph_traits<TriangleMesh>::halfedge_descriptor h = halfedge(f, tm);
@ -186,17 +186,17 @@ is_needle_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descrip
{
CGAL_precondition(threshold >= 1.);
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm));
typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typedef typename Traits::FT FT;
@ -288,18 +288,18 @@ is_cap_triangle_face(typename boost::graph_traits<TriangleMesh>::face_descriptor
CGAL_precondition(threshold >= -1.);
CGAL_precondition(threshold <= 0.);
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<TriangleMesh, NamedParameters>::const_type VertexPointMap;
VertexPointMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VertexPointMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, tm));
typedef typename GetGeomTraits<TriangleMesh, NamedParameters>::type Traits;
Traits traits = choose_param(get_param(np, internal_np::geom_traits), Traits());
Traits traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Traits());
typedef typename Traits::FT FT;
typedef typename Traits::Vector_3 Vector_3;

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

@ -181,14 +181,14 @@ collect_duplicated_stitchable_boundary_edges
Face_cc_map cc;
std::size_t num_component = 0;
std::vector<std::vector<halfedge_descriptor> > border_edges_per_cc;
bool per_cc = boost::choose_param(get_param(np, internal_np::apply_per_connected_component),
false);
bool per_cc = parameters::choose_parameter(parameters::get_parameter(np, internal_np::apply_per_connected_component),
false);
if(per_cc)
{
cc = get(Face_property_tag(), pmesh);
typedef typename GetFaceIndexMap<PM, CGAL_PMP_NP_CLASS>::const_type FIMap;
FIMap fim = boost::choose_param(get_param(np, internal_np::face_index),
get_const_property_map(face_index, pmesh));
FIMap fim = parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
get_const_property_map(face_index, pmesh));
num_component = num_component_wrapper(pmesh, cc, fim);
border_edges_per_cc.resize(num_component);
}
@ -561,13 +561,13 @@ std::size_t stitch_boundary_cycle(const typename boost::graph_traits<PolygonMesh
PolygonMesh& pm,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::const_type VPMap;
VPMap vpm = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pm));
std::size_t stitched_boundary_cycles_n = 0;
@ -720,8 +720,8 @@ template <typename PolygonMesh,
void stitch_borders(PolygonMesh& pmesh,
const HalfedgePairsRange& hedge_pairs_to_stitch)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
internal::stitch_borders_impl(pmesh, hedge_pairs_to_stitch);
}
@ -758,15 +758,15 @@ void stitch_borders(PolygonMesh& pmesh,
template <typename PolygonMesh, class CGAL_PMP_NP_TEMPLATE_PARAMETERS>
void stitch_borders(PolygonMesh& pmesh, const CGAL_PMP_NP_CLASS& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor
halfedge_descriptor;
std::vector< std::pair<halfedge_descriptor, halfedge_descriptor> > hedge_pairs_to_stitch;
typedef typename GetVertexPointMap<PolygonMesh, CGAL_PMP_NP_CLASS>::const_type VPMap;
VPMap vpm = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(vertex_point, pmesh));
stitch_boundary_cycles(pmesh, np);

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

@ -54,8 +54,8 @@ void transform(const Transformation& transformation,
const NamedParameters& np)
{
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::type VPMap;
VPMap vpm = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(vertex_point, mesh));
VPMap vpm = parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, mesh));
for(typename boost::graph_traits<PolygonMesh>::vertex_descriptor vd : vertices(mesh))
{

20
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/triangulate_faces.h
View File

@ -430,20 +430,20 @@ bool triangulate_face(typename boost::graph_traits<PolygonMesh>::face_descriptor
PolygonMesh& pmesh,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
//VertexPointMap
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, pmesh));
//Kernel
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Kernel;
Kernel traits = choose_param(get_param(np, internal_np::geom_traits), Kernel());
Kernel traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Kernel());
//Option
bool use_cdt = choose_param(get_param(np, internal_np::use_delaunay_triangulation), true);
bool use_cdt = choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true);
internal::Triangulate_modifier<PolygonMesh, VPMap, Kernel> modifier(vpmap, traits);
return modifier.triangulate_face(f, pmesh, use_cdt);
@ -485,20 +485,20 @@ bool triangulate_faces(FaceRange face_range,
PolygonMesh& pmesh,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
//VertexPointMap
typedef typename GetVertexPointMap<PolygonMesh, NamedParameters>::type VPMap;
VPMap vpmap = choose_param(get_param(np, internal_np::vertex_point),
VPMap vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, pmesh));
//Kernel
typedef typename GetGeomTraits<PolygonMesh, NamedParameters>::type Kernel;
Kernel traits = choose_param(get_param(np, internal_np::geom_traits), Kernel());
Kernel traits = choose_parameter(get_parameter(np, internal_np::geom_traits), Kernel());
//Option
bool use_cdt = choose_param(get_param(np, internal_np::use_delaunay_triangulation), true);
bool use_cdt = choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true);
internal::Triangulate_modifier<PolygonMesh, VPMap, Kernel> modifier(vpmap, traits);
return modifier(face_range, pmesh, use_cdt);

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

@ -90,14 +90,14 @@ namespace Polygon_mesh_processing {
OutputIterator out,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
bool use_dt3 =
#ifdef CGAL_HOLE_FILLING_DO_NOT_USE_DT3
false;
#else
choose_param(get_param(np, internal_np::use_delaunay_triangulation), true);
choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true);
#endif
CGAL_precondition(face(border_halfedge, pmesh) == boost::graph_traits<PolygonMesh>::null_face());
@ -105,9 +105,9 @@ namespace Polygon_mesh_processing {
return internal::triangulate_hole_polygon_mesh(pmesh,
border_halfedge,
out,
choose_param(get_param(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)),
choose_parameter(get_parameter(np, internal_np::vertex_point), get_property_map(vertex_point, pmesh)),
use_dt3,
choose_param(get_param(np, internal_np::geom_traits), typename GetGeomTraits<PolygonMesh,NamedParameters>::type()))
choose_parameter(get_parameter(np, internal_np::geom_traits), typename GetGeomTraits<PolygonMesh,NamedParameters>::type()))
.first;
}
@ -343,14 +343,14 @@ namespace Polygon_mesh_processing {
OutputIterator out,
const NamedParameters& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
bool use_dt3 =
#ifdef CGAL_HOLE_FILLING_DO_NOT_USE_DT3
false;
#else
choose_param(get_param(np, internal_np::use_delaunay_triangulation), true);
choose_parameter(get_parameter(np, internal_np::use_delaunay_triangulation), true);
#endif
typedef CGAL::internal::Weight_min_max_dihedral_and_area Weight;
@ -370,7 +370,7 @@ namespace Polygon_mesh_processing {
triangulate_hole_polyline(points, third_points, tracer, WC(),
use_dt3,
choose_param(get_param(np, internal_np::geom_traits),
choose_parameter(get_parameter(np, internal_np::geom_traits),
typename CGAL::Kernel_traits<Point>::Kernel()));
CGAL_assertion(holes.empty());

10
Polygon_mesh_processing/include/CGAL/Rigid_triangle_mesh_collision_detection.h
View File

@ -234,7 +234,7 @@ public:
CGAL_static_assertion(same_vpm);
Vpm vpm =
boost::choose_param(boost::get_param(np, internal_np::vertex_point),
parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm) );
// now add the mesh
std::size_t id = get_id_for_new_mesh();
@ -530,8 +530,8 @@ public:
using Polygon_mesh_processing::GetFaceIndexMap;
const bool maybe_several_cc =
boost::choose_param(
boost::get_param(np, internal_np::apply_per_connected_component), true);
parameters::choose_parameter(
parameters::get_parameter(np, internal_np::apply_per_connected_component), true);
typedef typename GetVertexPointMap<TriangleMesh,
NamedParameters>::const_type Local_vpm;
@ -542,7 +542,7 @@ public:
CGAL_static_assertion(same_vpm);
Vpm vpm =
boost::choose_param(boost::get_param(np, internal_np::vertex_point),
parameters::choose_parameter(parameters::get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tm) );
if (maybe_several_cc)
@ -555,7 +555,7 @@ public:
NamedParameters>::type Fid_map;
Fid_map fid_map =
boost::choose_param(boost::get_param(np, internal_np::face_index),
parameters::choose_parameter(parameters::get_parameter(np, internal_np::face_index),
get_const_property_map(boost::face_index, tm));
std::size_t nb_cc =

11
Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp
View File

@ -22,11 +22,14 @@ bool test_orientation(TriangleMesh& tm, bool is_positive, const NamedParameters&
typedef typename CGAL::Polygon_mesh_processing::GetFaceIndexMap<TriangleMesh,
NamedParameters>::const_type Fid_map;
Vpm vpm = boost::choose_param(get_param(np, CGAL::internal_np::vertex_point),
CGAL::get_const_property_map(boost::vertex_point, tm));
using CGAL::parameters::choose_parameter;
using CGAL::parameters::get_parameter;
Vpm vpm = choose_parameter(get_parameter(np, CGAL::internal_np::vertex_point),
CGAL::get_const_property_map(boost::vertex_point, tm));
Fid_map fid_map = boost::choose_param(get_param(np, CGAL::internal_np::face_index),
CGAL::get_const_property_map(boost::face_index, tm));
Fid_map fid_map = choose_parameter(get_parameter(np, CGAL::internal_np::face_index),
CGAL::get_const_property_map(boost::face_index, tm));
std::vector<std::size_t> face_cc(num_faces(tm), std::size_t(-1));

4
Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp
View File

@ -120,9 +120,9 @@ void Polyhedron_demo_inside_out_plugin::on_actionOrientCC_triggered()
SMesh* pMesh = sm_item->polyhedron();
if(pMesh){
if(is_closed(*pMesh))
CGAL::Polygon_mesh_processing::orient_to_bound_a_volume(*pMesh, item==items.first());
CGAL::Polygon_mesh_processing::orient_to_bound_a_volume(*pMesh);
else
CGAL::Polygon_mesh_processing::orient(*pMesh, item==items.first());
CGAL::Polygon_mesh_processing::orient(*pMesh);
sm_item->invalidateOpenGLBuffers();
}
}

12
Polyhedron/demo/Polyhedron/include/Point_set_3.h
View File

@ -505,13 +505,13 @@ public:
bool are_radii_uptodate() const { return m_radii_are_uptodate; }
void set_radii_uptodate(bool /*on*/) { m_radii_are_uptodate = false; }
CGAL::cgal_bgl_named_params
CGAL::Named_function_parameters
<Kernel,
CGAL::internal_np::geom_traits_t,
CGAL::cgal_bgl_named_params
CGAL::Named_function_parameters
<typename Base::template Property_map<Vector>,
CGAL::internal_np::normal_t,
CGAL::cgal_bgl_named_params
CGAL::Named_function_parameters
<typename Base::template Property_map<Point>,
CGAL::internal_np::point_t> > >
inline parameters() const
@ -598,13 +598,13 @@ namespace Point_set_processing_3
namespace parameters
{
template <typename Kernel>
cgal_bgl_named_params
Named_function_parameters
<Kernel,
internal_np::geom_traits_t,
cgal_bgl_named_params
Named_function_parameters
<typename ::Point_set_3<Kernel>::template Property_map<typename Kernel::Vector_3>,
internal_np::normal_t,
cgal_bgl_named_params
Named_function_parameters
<typename ::Point_set_3<Kernel>::template Property_map<typename Kernel::Point_3>,
internal_np::point_t> > >
inline all_default(const ::Point_set_3<Kernel>& ps)

18
Polyhedron_IO/include/CGAL/IO/Polyhedron_iostream.h
View File

@ -29,7 +29,7 @@
#include <CGAL/IO/print_OFF.h>
#include <CGAL/IO/scan_OFF.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <iostream>
namespace CGAL {
@ -41,11 +41,14 @@ template < class Traits,
class HDS, class Alloc, class NamedParameters>
bool
write_off( std::ostream& out, const Polyhedron_3<Traits,Items,HDS,Alloc>& P, const NamedParameters& np){
using parameters::choose_parameter;
using parameters::get_parameter;
// 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::Polygon_mesh_processing::GetVertexPointMap<Polyhedron_3<Traits,Items,HDS,Alloc>, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, P));
CGAL::print_polyhedron_with_header_OFF( out, P, header, vpm);
return out.good();
@ -70,11 +73,14 @@ read_off(std::istream& in,
Polyhedron_3<Traits,Items,HDS,Alloc>& P,
NamedParameters np) {
// reads a polyhedron from `in' and appends it to P.
typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Polyhedron_3<Traits,Items,HDS,Alloc>, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, P));
typedef typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Polyhedron_3<Traits,Items,HDS,Alloc>, NamedParameters>::type Vpm;
using parameters::choose_parameter;
using parameters::get_parameter;
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, P));
CGAL::scan_OFF( in, P);
if(!boost::is_default_param(get_param(np, internal_np::vertex_point)))
if(!parameters::is_default_parameter(get_parameter(np, internal_np::vertex_point)))
{
typedef typename boost::graph_traits<Polyhedron_3<Traits,Items,HDS,Alloc> >::vertex_descriptor Vertex;
typename property_map_selector<Polyhedron_3<Traits,Items,HDS,Alloc>, boost::vertex_point_t>::type

2
Polyhedron_IO/include/CGAL/IO/generic_print_polyhedron.h
View File

@ -24,7 +24,7 @@
#include <CGAL/license/Polyhedron.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/property_map.h>
#include <boost/graph/graph_traits.hpp>

17
Scripts/developer_scripts/update_to_CGAL_np.sh Normal file
View File

@ -0,0 +1,17 @@
#!/bin/bash
ack -l --cpp boost::lookup_named_param_def | xargs sed -i 's/boost::lookup_named_param_def/internal_np::Lookup_named_param_def/g'
ack -l --cpp boost::param_not_found | xargs sed -i 's/boost::param_not_found/internal_np::Param_not_found/g'
ack -l --cpp boost::is_default_param | xargs sed -i 's/boost::is_default_param/parameters::is_default_parameter/g'
ack -l --cpp boost::get_param | xargs sed -i 's/boost::get_param/parameters::get_parameter/g'
ack -l --cpp boost::choose_param | xargs sed -i 's/boost::choose_param/parameters::choose_parameter/g'
ack -l --cpp cgal_bgl_named_params | xargs sed -i 's/cgal_bgl_named_params/Named_function_parameters/g'
ack -l --cpp choose_param | xargs sed -i -E 's/choose_param[ ]*\(/choose_parameter(/g'
ack -l --cpp get_param | xargs sed -i -E 's/get_param[ ]*\(/get_parameter(/g'
ack -l --cpp is_default_param | xargs sed -i -E 's/is_default_param[ ]*\(/is_default_parameter(/g'
ack vertex_index_t | grep get_param
git checkout BGL/include/CGAL/boost/graph/dijkstra_shortest_paths.hpp

34
Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_hosts_3.h
View File

@ -31,7 +31,7 @@
#include <CGAL/circulator.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/Subdivision_method_3/internal/subdivision_hosts_impl_3.h>
@ -84,14 +84,14 @@ void PQQ(PolygonMesh& pmesh, Mask mask, int step = 1) {
template <class PolygonMesh, class Mask, class NamedParameters>
void PQQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) {
// todo: static assert that PolygonMesh == Mask::PolygonMesh
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, pmesh));
unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1);
unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
for (unsigned int i = 0; i < step; i++)
internal::PQQ_1step(pmesh, vpm, mask);
}
@ -131,14 +131,14 @@ void PTQ(PolygonMesh& pmesh, Mask mask, int step = 1) {
template <class PolygonMesh, class Mask, class NamedParameters>
void PTQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) {
// todo: static assert that PolygonMesh == Mask::PolygonMesh
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, pmesh));
unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1);
unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
for (unsigned int i = 0; i < step; i++)
internal::PTQ_1step(pmesh, vpm, mask);
}
@ -181,14 +181,14 @@ void DQQ(PolygonMesh& pmesh, Mask mask, int step = 1) {
template <class PolygonMesh, class Mask, class NamedParameters>
void DQQ(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) {
// todo: static assert that PolygonMesh == Mask::PolygonMesh
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, pmesh));
unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1);
unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
for (unsigned int i = 0; i < step; i++)
internal::DQQ_1step(pmesh, vpm, mask);
}
@ -233,14 +233,14 @@ void Sqrt3(PolygonMesh& pmesh, Mask mask, int step = 1) {
template <class PolygonMesh, class Mask, class NamedParameters>
void Sqrt3(PolygonMesh& pmesh, Mask mask, const NamedParameters& np) {
// todo: static assert that PolygonMesh == Mask::PolygonMesh
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, pmesh));
unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1);
unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
for (unsigned int i = 0; i < step; i++)
internal::Sqrt3_1step(pmesh, vpm, mask, (i%2==1));
}

34
Subdivision_method_3/include/CGAL/Subdivision_method_3/subdivision_methods_3.h
View File

@ -29,7 +29,7 @@
#include <CGAL/circulator.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/Subdivision_method_3/subdivision_hosts_3.h>
@ -128,13 +128,13 @@ void CatmullClark_subdivision(PolygonMesh& pmesh, int step) {
**/
template <class PolygonMesh, class NamedParameters>
void CatmullClark_subdivision(PolygonMesh& pmesh, const NamedParameters& np) {
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, pmesh));
unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1);
unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
CatmullClark_mask_3<PolygonMesh,Vpm> mask(&pmesh, vpm);
for(unsigned int i = 0; i < step; i++)
@ -181,13 +181,13 @@ void Loop_subdivision(PolygonMesh& pmesh, int step) {
**/
template <class PolygonMesh, class NamedParameters>
void Loop_subdivision(PolygonMesh& pmesh, const NamedParameters& np) {
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, pmesh));
unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1);
unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
Loop_mask_3<PolygonMesh,Vpm> mask(&pmesh, vpm);
for(unsigned int i = 0; i < step; i++)
@ -234,13 +234,13 @@ void DooSabin_subdivision(PolygonMesh& pmesh, int step) {
**/
template <class PolygonMesh, class NamedParameters>
void DooSabin_subdivision(PolygonMesh& pmesh, const NamedParameters& np) {
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, pmesh));
unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1);
unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
DooSabin_mask_3<PolygonMesh,Vpm> mask(&pmesh, vpm);
for(unsigned int i = 0; i < step; i++)
@ -292,13 +292,13 @@ void Sqrt3_subdivision(PolygonMesh& pmesh, int step) {
**/
template <class PolygonMesh, class NamedParameters>
void Sqrt3_subdivision(PolygonMesh& pmesh, const NamedParameters& np) {
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
typedef typename Polygon_mesh_processing::GetVertexPointMap<PolygonMesh, NamedParameters>::type Vpm;
Vpm vpm = choose_param(get_param(np, internal_np::vertex_point),
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(CGAL::vertex_point, pmesh));
unsigned int step = choose_param(get_param(np, internal_np::number_of_iterations), 1);
unsigned int step = choose_parameter(get_parameter(np, internal_np::number_of_iterations), 1);
Sqrt3_mask_3<PolygonMesh,Vpm> mask(&pmesh, vpm);
for(unsigned int i = 0; i < step; i++)

12
Surface_mesh/include/CGAL/Surface_mesh/Surface_mesh.h
View File

@ -56,7 +56,7 @@
#include <CGAL/Surface_mesh/IO/PLY.h>
#include <CGAL/Handle_hash_function.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
namespace CGAL {
@ -2112,13 +2112,16 @@ private: //------------------------------------------------------- private data
bool has_fcolors;
boost::tie(fcolors, has_fcolors) = sm.template property_map<typename Mesh::Face_index, CGAL::Color >("f:color");
using parameters::choose_parameter;
using parameters::get_parameter;
if(!has_fcolors && !has_vcolors)
os << "OFF\n" << sm.number_of_vertices() << " " << sm.number_of_faces() << " 0\n";
else
os << "COFF\n" << sm.number_of_vertices() << " " << sm.number_of_faces() << " 0\n";
std::vector<int> reindex;
typename Polygon_mesh_processing::GetVertexPointMap<Surface_mesh<P>, NamedParameters>::const_type
vpm = choose_param(get_param(np, internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, sm));
reindex.resize(sm.num_vertices());
int n = 0;
@ -2398,8 +2401,11 @@ private: //------------------------------------------------------- private data
typedef typename Mesh::Face_index Face_index;
typedef typename Mesh::Vertex_index Vertex_index;
typedef typename Mesh::size_type size_type;
using parameters::choose_parameter;
using parameters::get_parameter;
typename CGAL::Polygon_mesh_processing::GetVertexPointMap<Surface_mesh<P>, NamedParameters>::type
vpm = choose_param(get_param(np, CGAL::internal_np::vertex_point),
vpm = choose_parameter(get_parameter(np, CGAL::internal_np::vertex_point),
get_property_map(CGAL::vertex_point, sm));
int n, f, e;
std::string off;

2
Surface_mesh/include/CGAL/boost/graph/graph_traits_Surface_mesh.h
View File

@ -26,7 +26,7 @@
#include <CGAL/license/Surface_mesh.h>
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/properties.hpp>

64
Surface_mesh_approximation/include/CGAL/Surface_mesh_approximation/approximate_triangle_mesh.h
View File

@ -27,7 +27,7 @@
#include <CGAL/Variational_shape_approximation.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/property_map.h>
@ -127,22 +127,22 @@ unspecified_type all_default();
template <typename TriangleMesh, typename NamedParameters>
bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np)
{
using boost::get_param;
using boost::choose_param;
using boost::is_default_param;
using parameters::get_parameter;
using parameters::choose_parameter;
using parameters::is_default_parameter;
typedef typename Polygon_mesh_processing::GetGeomTraits<TriangleMesh, NamedParameters>::type Geom_traits;
typedef typename Geom_traits::FT FT;
typedef typename Polygon_mesh_processing::GetVertexPointMap<TriangleMesh, NamedParameters>::type Vertex_point_map;
Vertex_point_map point_pmap = choose_param(get_param(np, internal_np::vertex_point),
Vertex_point_map point_pmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_property_map(vertex_point, const_cast<TriangleMesh &>(tm)));
typedef CGAL::Variational_shape_approximation<TriangleMesh, Vertex_point_map> L21_approx;
typedef typename L21_approx::Error_metric L21_metric;
const Verbose_level vl = choose_param(
get_param(np, internal_np::verbose_level), SILENT);
const Verbose_level vl = choose_parameter(
get_parameter(np, internal_np::verbose_level), SILENT);
const std::size_t number_of_faces = std::distance(faces(tm).first, faces(tm).second);
const std::size_t number_of_vertices = std::distance(vertices(tm).first, vertices(tm).second);
@ -157,14 +157,14 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
L21_approx approx(tm, point_pmap, metric);
// hierarchical seeding by default
const Seeding_method method = choose_param(
get_param(np, internal_np::seeding_method), HIERARCHICAL);
const std::size_t max_nb_of_proxies = choose_param(
get_param(np, internal_np::max_number_of_proxies), 0);
const FT min_error_drop = choose_param(
get_param(np, internal_np::min_error_drop), FT(0.0));
const std::size_t nb_of_relaxations = choose_param(
get_param(np, internal_np::number_of_relaxations), 5);
const Seeding_method method = choose_parameter(
get_parameter(np, internal_np::seeding_method), HIERARCHICAL);
const std::size_t max_nb_of_proxies = choose_parameter(
get_parameter(np, internal_np::max_number_of_proxies), 0);
const FT min_error_drop = choose_parameter(
get_parameter(np, internal_np::min_error_drop), FT(0.0));
const std::size_t nb_of_relaxations = choose_parameter(
get_parameter(np, internal_np::number_of_relaxations), 5);
if (vl == VERBOSE) {
std::cout << (method == RANDOM ? "Random" :
@ -179,8 +179,8 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
if (vl == MAIN_STEPS || vl == VERBOSE)
std::cout << "Seeding done." << std::endl;
const std::size_t nb_of_iterations = choose_param(
get_param(np, internal_np::number_of_iterations), 20);
const std::size_t nb_of_iterations = choose_parameter(
get_parameter(np, internal_np::number_of_iterations), 20);
if (vl == VERBOSE)
std::cout << "\n#nb_of_iterations = " << nb_of_iterations << std::endl;
@ -193,30 +193,30 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
}
// get proxy map
approx.proxy_map( get_param(np, internal_np::face_proxy_map) );
approx.proxy_map( get_parameter(np, internal_np::face_proxy_map) );
if (!boost::is_default_param(get_param(np, internal_np::face_proxy_map))
if (!parameters::is_default_parameter(get_parameter(np, internal_np::face_proxy_map))
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Filling face proxy map done." << std::endl;
// get proxies
approx.proxies( get_param(np, internal_np::proxies) );
approx.proxies( get_parameter(np, internal_np::proxies) );
if (!is_default_param( get_param(np, internal_np::proxies) )
if (!is_default_parameter( get_parameter(np, internal_np::proxies) )
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get proxies done." << std::endl;
// meshing
bool is_manifold = false;
if (!is_default_param( get_param(np, internal_np::anchors))
|| !is_default_param( get_param(np, internal_np::triangles) ))
if (!is_default_parameter( get_parameter(np, internal_np::anchors))
|| !is_default_parameter( get_parameter(np, internal_np::triangles) ))
{
if (vl == VERBOSE) {
const FT subdivision_ratio = choose_param(get_param(np, internal_np::subdivision_ratio), FT(5.0));
const bool relative_to_chord = choose_param(get_param(np, internal_np::relative_to_chord), false);
const bool with_dihedral_angle = choose_param(get_param(np, internal_np::with_dihedral_angle), false);
const bool optimize_anchor_location = choose_param(get_param(np, internal_np::optimize_anchor_location), true);
const bool pca_plane = choose_param(get_param(np, internal_np::pca_plane), false);
const FT subdivision_ratio = choose_parameter(get_parameter(np, internal_np::subdivision_ratio), FT(5.0));
const bool relative_to_chord = choose_parameter(get_parameter(np, internal_np::relative_to_chord), false);
const bool with_dihedral_angle = choose_parameter(get_parameter(np, internal_np::with_dihedral_angle), false);
const bool optimize_anchor_location = choose_parameter(get_parameter(np, internal_np::optimize_anchor_location), true);
const bool pca_plane = choose_parameter(get_parameter(np, internal_np::pca_plane), false);
std::cout << "Meshing: "
<< "\nchord_error = " << subdivision_ratio
<< "\nrelative_to_chord = " << relative_to_chord
@ -233,16 +233,16 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
}
// get anchor points
approx.anchor_points( get_param(np, internal_np::anchors) );
approx.anchor_points( get_parameter(np, internal_np::anchors) );
if (!is_default_param( get_param(np, internal_np::anchors) )
if (!is_default_parameter( get_parameter(np, internal_np::anchors) )
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get anchors done." << std::endl;
// get indexed triangles
approx.indexed_triangles( get_param(np, internal_np::triangles) );
approx.indexed_triangles( get_parameter(np, internal_np::triangles) );
if (!is_default_param( get_param(np, internal_np::triangles) )
if (!is_default_parameter( get_parameter(np, internal_np::triangles) )
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get indexed triangles done." << std::endl;

56
Surface_mesh_approximation/include/CGAL/Variational_shape_approximation.h
View File

@ -44,7 +44,7 @@
#include <boost/graph/subgraph.hpp>
#include <boost/optional.hpp>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <vector>
@ -322,17 +322,17 @@ public:
*/
template <typename NamedParameters>
std::size_t initialize_seeds(const NamedParameters &np) {
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
const Surface_mesh_approximation::Seeding_method method = choose_param(
get_param(np, internal_np::seeding_method), Surface_mesh_approximation::HIERARCHICAL);
std::size_t max_nb_proxies = choose_param(
get_param(np, internal_np::max_number_of_proxies), 0);
FT min_error_drop = choose_param(
get_param(np, internal_np::min_error_drop), FT(0.0));
const std::size_t nb_relaxations = choose_param(
get_param(np, internal_np::number_of_relaxations), 5);
const Surface_mesh_approximation::Seeding_method method = choose_parameter(
get_parameter(np, internal_np::seeding_method), Surface_mesh_approximation::HIERARCHICAL);
std::size_t max_nb_proxies = choose_parameter(
get_parameter(np, internal_np::max_number_of_proxies), 0);
FT min_error_drop = choose_parameter(
get_parameter(np, internal_np::min_error_drop), FT(0.0));
const std::size_t nb_relaxations = choose_parameter(
get_parameter(np, internal_np::number_of_relaxations), 5);
// adjust parameters
if (max_nb_proxies < (m_nb_of_faces / 3) && max_nb_proxies > 0) {
@ -797,14 +797,14 @@ public:
*/
template <typename NamedParameters>
bool extract_mesh(const NamedParameters &np) {
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
const FT subdivision_ratio = choose_param(get_param(np, internal_np::subdivision_ratio), FT(5.0));
const bool relative_to_chord = choose_param(get_param(np, internal_np::relative_to_chord), false);
const bool with_dihedral_angle = choose_param(get_param(np, internal_np::with_dihedral_angle), false);
const bool optimize_anchor_location = choose_param(get_param(np, internal_np::optimize_anchor_location), true);
const bool pca_plane = choose_param(get_param(np, internal_np::pca_plane), false);
const FT subdivision_ratio = choose_parameter(get_parameter(np, internal_np::subdivision_ratio), FT(5.0));
const bool relative_to_chord = choose_parameter(get_parameter(np, internal_np::relative_to_chord), false);
const bool with_dihedral_angle = choose_parameter(get_parameter(np, internal_np::with_dihedral_angle), false);
const bool optimize_anchor_location = choose_parameter(get_parameter(np, internal_np::optimize_anchor_location), true);
const bool pca_plane = choose_parameter(get_parameter(np, internal_np::pca_plane), false);
// compute averaged edge length, used in chord subdivision
m_average_edge_length = compute_averaged_edge_length(*m_ptm, m_vpoint_map);
@ -860,19 +860,19 @@ public:
*/
template <typename NamedParameters>
void output(const NamedParameters &np) const {
using boost::get_param;
using boost::choose_param;
using parameters::get_parameter;
using parameters::choose_parameter;
// get proxy map
proxy_map( get_param(np, internal_np::face_proxy_map) );
proxy_map( get_parameter(np, internal_np::face_proxy_map) );
// get proxies
proxies( get_param(np, internal_np::proxies) );
proxies( get_parameter(np, internal_np::proxies) );
// get anchor points
anchor_points( get_param(np, internal_np::anchors) );
anchor_points( get_parameter(np, internal_np::anchors) );
// get indexed triangles
indexed_triangles( get_param(np, internal_np::triangles) );
indexed_triangles( get_parameter(np, internal_np::triangles) );
}
/*!
@ -896,7 +896,7 @@ public:
/*!
* @brief dummy function for named parameters.
*/
void proxy_map(boost::param_not_found) const {}
void proxy_map(internal_np::Param_not_found) const {}
/*!
* @brief gets the face region of the specified proxy.
@ -928,7 +928,7 @@ public:
/*!
* @brief dummy function for named parameters.
*/
void proxies(boost::param_not_found) const {}
void proxies(internal_np::Param_not_found) const {}
/*!
* @brief gets the wrapped proxies.
@ -955,7 +955,7 @@ public:
/*!
* @brief dummy function for named parameters.
*/
void anchor_points(boost::param_not_found) const {}
void anchor_points(internal_np::Param_not_found) const {}
/*!
* @brief gets the anchor vertices.
@ -983,7 +983,7 @@ public:
/*!
* @brief dummy function for named parameters.
*/
void indexed_triangles(boost::param_not_found) const {}
void indexed_triangles(internal_np::Param_not_found) const {}
/*!
* @brief gets the indexed boundary polygon approximation.

2
Surface_mesh_segmentation/include/CGAL/internal/Surface_mesh_segmentation/Alpha_expansion_graph_cut.h
View File

@ -47,7 +47,7 @@
#endif
#include <CGAL/IO/trace.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <boost/version.hpp>
#ifdef CGAL_DO_NOT_USE_BOYKOV_KOLMOGOROV_MAXFLOW_SOFTWARE

44
Surface_mesh_simplification/include/CGAL/Surface_mesh_simplification/edge_collapse.h
View File

@ -24,7 +24,7 @@
#include <CGAL/boost/graph/properties.h>
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/Surface_mesh_simplification/Detail/Edge_collapse.h>
#include <CGAL/Surface_mesh_simplification/Detail/Common.h>
@ -102,12 +102,11 @@ struct Dummy_visitor
template<class TM, class ShouldStop, class P, class T, class R>
int edge_collapse ( TM& aSurface
, ShouldStop const& aShould_stop
, cgal_bgl_named_params<P,T,R> const& aParams
, Named_function_parameters<P,T,R> const& aParams
)
{
using boost::choose_param ;
using boost::choose_const_pmap ;
using boost::get_param ;
using parameters::choose_parameter;
using parameters::get_parameter;
LindstromTurk_params lPolicyParams ;
@ -115,25 +114,24 @@ int edge_collapse ( TM& aSurface
return edge_collapse(aSurface
,aShould_stop
,choose_const_pmap(get_param(aParams,internal_np::vertex_index),aSurface,boost::vertex_index)
,choose_pmap(get_param(aParams,internal_np::vertex_point),aSurface,boost::vertex_point)
,choose_const_pmap(get_param(aParams,internal_np::halfedge_index),aSurface,boost::halfedge_index)
,choose_param (get_param(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<TM>())
,choose_param (get_param(aParams,internal_np::get_cost_policy), LindstromTurk_cost<TM>())
,choose_param (get_param(aParams,internal_np::get_placement_policy), LindstromTurk_placement<TM>())
,choose_param (get_param(aParams,vis), Dummy_visitor())
,choose_parameter(get_parameter(aParams,internal_np::vertex_index), get_const_property_map(boost::vertex_index, aSurface))
,choose_parameter(get_parameter(aParams,internal_np::vertex_point),get_property_map(vertex_point, aSurface))
,choose_parameter(get_parameter(aParams,internal_np::halfedge_index),get_const_property_map(boost::halfedge_index, aSurface))
,choose_parameter(get_parameter(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<TM>())
,choose_parameter(get_parameter(aParams,internal_np::get_cost_policy), LindstromTurk_cost<TM>())
,choose_parameter(get_parameter(aParams,internal_np::get_placement_policy), LindstromTurk_placement<TM>())
,choose_parameter(get_parameter(aParams,vis), Dummy_visitor())
);
}
template<class TM, class ShouldStop, class GT, class P, class T, class R>
int edge_collapse ( TM& aSurface
, ShouldStop const& aShould_stop
, cgal_bgl_named_params<P,T,R> const& aParams
, Named_function_parameters<P,T,R> const& aParams
)
{
using boost::choose_param ;
using boost::choose_const_pmap ;
using boost::get_param ;
using parameters::choose_parameter;
using parameters::get_parameter;
LindstromTurk_params lPolicyParams ;
@ -141,13 +139,13 @@ int edge_collapse ( TM& aSurface
return edge_collapse(aSurface
,aShould_stop
,choose_const_pmap(get_param(aParams,internal_np::vertex_index),aSurface,boost::vertex_index)
,choose_const_pmap(get_param(aParams,internal_np::vertex_point),aSurface,boost::vertex_point)
,choose_const_pmap(get_param(aParams,internal_np::halfedge_index),aSurface,boost::halfedge_index)
,choose_param (get_param(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<TM>())
,choose_param (get_param(aParams,internal_np::get_cost_policy), LindstromTurk_cost<TM>())
,choose_param (get_param(aParams,internal_np::get_placement_policy), LindstromTurk_placement<TM>())
,choose_param (get_param(aParams,vis), Dummy_visitor())
,choose_parameter(get_parameter(aParams,internal_np::vertex_index), get_const_property_map(boost::vertex_index, aSurface))
,choose_parameter(get_parameter(aParams,internal_np::vertex_point),get_property_map(vertex_point, aSurface))
,choose_parameter(get_parameter(aParams,internal_np::halfedge_index),get_const_property_map(boost::halfedge_index, aSurface))
,choose_parameter(get_parameter(aParams,internal_np::edge_is_constrained),No_constrained_edge_map<TM>())
,choose_parameter(get_parameter(aParams,internal_np::get_cost_policy), LindstromTurk_cost<TM>())
,choose_parameter(get_parameter(aParams,internal_np::get_placement_policy), LindstromTurk_placement<TM>())
,choose_parameter(get_parameter(aParams,vis), Dummy_visitor())
);
}

2
Triangulation_2/include/CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h
View File

@ -24,7 +24,7 @@
#include <functional>
// include this to avoid a VC15 warning
#include <CGAL/boost/graph/named_function_params.h>
#include <CGAL/boost/graph/Named_function_parameters.h>
#include <CGAL/boost/graph/internal/graph_traits_2D_triangulation_helper.h>
#include <CGAL/boost/graph/properties_Triangulation_data_structure_2.h>