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

keep only the static version of is_default_parameter

This commit is contained in:
Sébastien Loriot 2022-01-10 15:38:18 +01:00
parent 75b03e6c0a
commit 4fa826b3ed
21 changed files with 72 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -76,10 +76,10 @@ public:
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool is_vnm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map)));
const bool is_vcm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_color_map)));
const bool is_vtm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map)));
const bool is_fcm_requested = !(is_default_parameter(get_parameter(np, internal_np::face_color_map)));
const bool is_vnm_requested = !(is_default_parameter<NamedParameters, internal_np::vertex_normal_map_t>());
const bool is_vcm_requested = !(is_default_parameter<NamedParameters, internal_np::vertex_color_map_t>());
const bool is_vtm_requested = !(is_default_parameter<NamedParameters, internal_np::vertex_texture_map_t>());
const bool is_fcm_requested = !(is_default_parameter<NamedParameters, internal_np::face_color_map_t>());
std::vector<Vertex_normal> vertex_normals;
std::vector<Vertex_color> vertex_colors;

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

@ -122,10 +122,10 @@ public:
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, g));
const bool has_vertex_normals = !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map)));
const bool has_vertex_colors = !(is_default_parameter(get_parameter(np, internal_np::vertex_color_map)));
const bool has_vertex_textures = !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map)));
const bool has_face_colors = !(is_default_parameter(get_parameter(np, internal_np::face_color_map)));
const bool has_vertex_normals = !(is_default_parameter<NamedParameters, internal_np::vertex_normal_map_t>());
const bool has_vertex_colors = !(is_default_parameter<NamedParameters, internal_np::vertex_color_map_t>());
const bool has_vertex_textures = !(is_default_parameter<NamedParameters, internal_np::vertex_texture_map_t>());
const bool has_face_colors = !(is_default_parameter<NamedParameters, internal_np::face_color_map_t>());
VNM vnm = get_parameter(np, internal_np::vertex_normal_map);
VTM vtm = get_parameter(np, internal_np::vertex_texture_map);

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

@ -326,8 +326,8 @@ bool write_PLY(std::ostream& os,
VCM vcm = choose_parameter(get_parameter(np, internal_np::vertex_color_map), VCM());
FCM fcm = choose_parameter(get_parameter(np, internal_np::face_color_map), FCM());
bool has_vcolor = !is_default_parameter(get_parameter(np, internal_np::vertex_color_map));
bool has_fcolor = !is_default_parameter(get_parameter(np, internal_np::face_color_map));
bool has_vcolor = !is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>();
bool has_fcolor = !is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>();
VIMap vim = CGAL::get_initialized_vertex_index_map(g, np);
Vpm vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, g));

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

@ -508,7 +508,7 @@ CGAL_DEF_GET_INITIALIZED_INDEX_MAP(face, typename boost::graph_traits<Graph>::fa
using parameters::choose_parameter;
using parameters::is_default_parameter;
if(!is_default_parameter(get_parameter(np, internal_np::stream_precision)))
if(!is_default_parameter<NP, internal_np::stream_precision_t>())
{
const int precision = choose_parameter<int>(get_parameter(np,
internal_np::stream_precision));

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

@ -48,7 +48,7 @@ bool write_OFF_PSP(std::ostream& os,
typedef typename NP_helper::Const_point_map PointMap;
typedef typename NP_helper::Normal_map NormalMap;
const bool has_normals = !(is_default_parameter(get_parameter(np, internal_np::normal_map)));
const bool has_normals = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::normal_t>());
PointMap point_map = NP_helper::get_const_point_map(points, np);
NormalMap normal_map = NP_helper::get_normal_map(points, np);

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

@ -665,7 +665,7 @@ mst_orient_normals(
// or vertex j is in the k-neighborhood of vertex i.
Riemannian_graph riemannian_graph;
if (is_default_parameter(get_parameter(np, internal_np::point_is_constrained)))
if (is_default_parameter<NamedParameters, internal_np::point_is_constrained_t>())
riemannian_graph = create_riemannian_graph(points,
point_map, normal_map, index_map,
Default_constrained_map<typename PointRange::iterator>

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

@ -225,7 +225,7 @@ public:
{
using parameters::choose_parameter;
using parameters::get_parameter;
using parameters::is_default_parameter_static;
using parameters::is_default_parameter;
// basic geometric types
typedef Point_set_processing_3_np_helper<PointRange, NamedParameters> NP_helper;
@ -235,7 +235,7 @@ public:
typedef typename Point_set_processing_3::GetPlaneIndexMap<NamedParameters>::type PlaneIndexMap;
CGAL_static_assertion_msg(NP_helper::has_normal_map(), "Error: no normal map");
CGAL_static_assertion_msg((!is_default_parameter_static<NamedParameters, internal_np::plane_index_t>()),
CGAL_static_assertion_msg((!is_default_parameter<NamedParameters, internal_np::plane_index_t>()),
"Error: no plane index map");
PointMap point_map = NP_helper::get_const_point_map(points, np);

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

@ -672,7 +672,7 @@ compute_vertex_normal(typename boost::graph_traits<PolygonMesh>::vertex_descript
Face_vector_map default_fvmap;
Face_normal_map face_normals = choose_parameter(get_parameter(np, internal_np::face_normal),
Default_map(default_fvmap));
const bool must_compute_face_normals = is_default_parameter(get_parameter(np, internal_np::face_normal));
const bool must_compute_face_normals = is_default_parameter<NamedParameters, internal_np::face_normal_t>();
#ifdef CGAL_PMP_COMPUTE_NORMAL_DEBUG_PP
std::cout << "<----- compute vertex normal at " << get(vpmap, v)
@ -786,7 +786,7 @@ void compute_vertex_normals(const PolygonMesh& pmesh,
Face_normal_dmap>::type Face_normal_map;
Face_normal_map face_normals = choose_parameter(get_parameter(np, internal_np::face_normal),
get(Face_normal_tag(), pmesh));
const bool must_compute_face_normals = is_default_parameter(get_parameter(np, internal_np::face_normal));
const bool must_compute_face_normals = is_default_parameter<NamedParameters, internal_np::face_normal_t>();
if(must_compute_face_normals)
compute_face_normals(pmesh, face_normals, np);

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

@ -600,12 +600,12 @@ std::size_t keep_large_connected_components(PolygonMesh& pmesh,
template <typename PolygonMesh
, typename ComponentRange
, typename FaceComponentMap
, typename NamedParameters = parameters::Default_named_parameters>
, typename CGAL_BGL_NP_TEMPLATE_PARAMETERS>
void keep_or_remove_connected_components(PolygonMesh& pmesh
, const ComponentRange& components_to_keep
, const FaceComponentMap& fcm
, bool keep
, const NamedParameters& np = parameters::default_values())
, const CGAL_BGL_NP_CLASS& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
@ -616,7 +616,7 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
typedef typename boost::graph_traits<PolygonMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename boost::graph_traits<PolygonMesh>::edge_descriptor edge_descriptor;
typedef typename GetInitializedVertexIndexMap<PolygonMesh, NamedParameters>::type VertexIndexMap;
typedef typename GetInitializedVertexIndexMap<PolygonMesh, CGAL_BGL_NP_CLASS>::type VertexIndexMap;
VertexIndexMap vim = get_initialized_vertex_index_map(pmesh, np);
std::set<std::size_t> cc_to_keep;
@ -720,13 +720,13 @@ void keep_or_remove_connected_components(PolygonMesh& pmesh
for(vertex_descriptor v: vertices(pmesh))
if (!keep_vertex[v])
vertices_to_remove.push_back(v);
if ( is_default_parameter(get_parameter(np, internal_np::vertex_is_constrained)) )
if ( is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_is_constrained_t>() )
for (vertex_descriptor v : vertices_to_remove)
remove_vertex(v, pmesh);
else
{
typedef typename internal_np::Lookup_named_param_def<internal_np::vertex_is_constrained_t,
NamedParameters,
CGAL_BGL_NP_CLASS,
Static_boolean_property_map<vertex_descriptor, false> // default (not used)
>::type Vertex_map;
Vertex_map is_cst = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
@ -995,7 +995,7 @@ void split_connected_components_impl(FIMap fim,
get(CGAL::dynamic_face_property_t<faces_size_type>(), tm));
faces_size_type nb_patches = 0;
if(is_default_parameter(get_parameter(np, internal_np::face_patch)))
if(is_default_parameter<NamedParameters, internal_np::face_patch_t>())
{
nb_patches = CGAL::Polygon_mesh_processing::connected_components(
tm, pidmap, CGAL::parameters::face_index_map(fim)

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

@ -220,7 +220,7 @@ struct Triangle_structure_sampler_base
bool use_ms = choose_parameter(get_parameter(np, internal_np::monte_carlo_sampling), false);
if(use_gs || use_ms)
if(is_default_parameter(get_parameter(np, internal_np::random_uniform_sampling)))
if(is_default_parameter<NamedParameters, internal_np::random_uniform_sampling_t>())
use_rs = false;
bool smpl_vrtcs = choose_parameter(get_parameter(np, internal_np::do_sample_vertices), true);

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

@ -1094,7 +1094,6 @@ std::size_t snap_non_conformal(HalfedgeRange& halfedge_range_A,
>::reference Visitor;
using CGAL::parameters::choose_parameter;
using CGAL::parameters::is_default_parameter;
using CGAL::parameters::get_parameter;
using CGAL::parameters::get_parameter_reference;

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

@ -217,7 +217,7 @@ void isotropic_remeshing(const FaceRange& faces
#endif
static const bool need_aabb_tree =
parameters::is_default_parameter(get_parameter(np, internal_np::projection_functor));
parameters::is_default_parameter<NamedParameters, internal_np::projection_functor_t>();
typedef typename GetGeomTraits<PM, NamedParameters>::type GT;
GT gt = choose_parameter<GT>(get_parameter(np, internal_np::geom_traits));
@ -254,7 +254,7 @@ void isotropic_remeshing(const FaceRange& faces
FPMap fpmap = choose_parameter(
get_parameter(np, internal_np::face_patch),
internal::Connected_components_pmap<PM, FIMap>(faces, pmesh, ecmap, fimap,
parameters::is_default_parameter(get_parameter(np, internal_np::face_patch)) && (need_aabb_tree
parameters::is_default_parameter<NamedParameters, internal_np::face_patch_t>() && (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

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

@ -175,8 +175,8 @@ std::size_t remove_connected_components_of_negligible_size(TriangleMesh& tmesh,
FT volume_threshold = choose_parameter(get_parameter(np, internal_np::volume_threshold), FT(-1));
// If no threshold is provided, compute it as a % of the bbox
const bool is_default_area_threshold = is_default_parameter(get_parameter(np, internal_np::area_threshold));
const bool is_default_volume_threshold = is_default_parameter(get_parameter(np, internal_np::volume_threshold));
const bool is_default_area_threshold = is_default_parameter<NamedParameters, internal_np::area_threshold_t>();
const bool is_default_volume_threshold = is_default_parameter<NamedParameters, internal_np::volume_threshold_t>();
const bool dry_run = choose_parameter(get_parameter(np, internal_np::dry_run), false);

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

@ -249,7 +249,7 @@ self_intersections_impl(const FaceRange& face_range,
VPM vpmap = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(boost::vertex_point, tmesh));
const bool do_limit = !(is_default_parameter(get_parameter(np, internal_np::maximum_number)));
const bool do_limit = !(is_default_parameter<NamedParameters, internal_np::maximum_number_t>());
const unsigned int maximum_number = choose_parameter(get_parameter(np, internal_np::maximum_number), 0);
if(do_limit && maximum_number == 0)
{

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

@ -402,7 +402,7 @@ public:
else
deg_faces.insert(f);
}
if (is_default_parameter(get_parameter(np, internal_np::face_epsilon_map)))
if (is_default_parameter<NamedParameters, internal_np::face_epsilon_map_t>())
init(epsilon);
else
{
@ -511,7 +511,7 @@ public:
deg_faces.insert(f);
}
if (is_default_parameter(get_parameter(np, internal_np::face_epsilon_map)))
if (is_default_parameter<NamedParameters, internal_np::face_epsilon_map_t>())
init(epsilon);
else
{
@ -594,7 +594,7 @@ public:
env_faces.emplace_back(face);
}
if (is_default_parameter(get_parameter(np, internal_np::face_epsilon_map)))
if (is_default_parameter<NamedParameters, internal_np::face_epsilon_map_t>())
init(epsilon);
else
{

17
Polygon_mesh_processing/test/Polygon_mesh_processing/test_pmp_np_function.cpp
View File

@ -44,6 +44,9 @@ void my_function_with_named_parameters(PolygonMesh& mesh, const NamedParameters&
//boolean NP example. Default value is `false`
bool do_project = choose_parameter(get_parameter(np, internal_np::do_project), false);
// check is a parameter has been given by the user
constexpr bool do_project_is_default = is_default_parameter<NamedParameters, internal_np::do_project_t>();
VCM vcm_np = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained), Default_VCM());
@ -53,10 +56,16 @@ void my_function_with_named_parameters(PolygonMesh& mesh, const NamedParameters&
std::cout<<"vertex #"<<get(vim, v)<<" : "<<get(vpm, v)<<" : "<<get(vcm_np, v)<<std::endl;
}
if(do_project)
std::cout<<"do project"<<std::endl;
else
std::cout<<"don't project"<<std::endl;
if (!do_project_is_default)
{
if(do_project)
std::cout<<"do project"<<std::endl;
else
std::cout<<"don't project"<<std::endl;
}
else
std::cout<<"use default for project"<<std::endl;
}
}

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

@ -66,17 +66,17 @@ bool read_OFF(std::istream& in,
const bool verbose = choose_parameter(get_parameter(np, internal_np::verbose), true);
if(!(is_default_parameter(get_parameter(np, internal_np::vertex_color_map))) ||
!(is_default_parameter(get_parameter(np, internal_np::face_color_map))) ||
!(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map))) ||
!(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map))))
if(!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>()))
{
return CGAL::IO::internal::read_OFF_BGL(in, P, np);
}
CGAL::scan_OFF(in, P, verbose);
if(!parameters::is_default_parameter(get_parameter(np, internal_np::vertex_point)))
if(!parameters::is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_point_t>())
{
Def_VPM def_vpm = get_property_map(CGAL::vertex_point, P);
VPM vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
@ -132,10 +132,10 @@ bool write_OFF(std::ostream& out,
using parameters::get_parameter;
using parameters::is_default_parameter;
if(!(is_default_parameter(get_parameter(np, internal_np::vertex_color_map))) ||
!(is_default_parameter(get_parameter(np, internal_np::face_color_map))) ||
!(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map))) ||
!(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map))))
if(!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>()) ||
!(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>()))
{
return CGAL::IO::internal::write_OFF_BGL(out, P, np);
}

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

@ -356,19 +356,8 @@ const T& choose_parameter(const T& t)
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;
}
template <class NP, class TAG>
constexpr bool is_default_parameter_static()
constexpr bool is_default_parameter()
{
return std::is_same< typename internal_np::Get_param<typename NP::base, TAG>::type,
internal_np::Param_not_found> ::value;

4
Shape_regularization/include/CGAL/Shape_regularization/regularize_planes.h
View File

@ -292,11 +292,11 @@ namespace Planes {
using parameters::get_parameter;
using parameters::choose_parameter;
using parameters::is_default_parameter_static;
using parameters::is_default_parameter;
using PlaneIndexMap = typename CGAL::Point_set_processing_3::
GetPlaneIndexMap<NamedParameters>::type;
CGAL_static_assertion_msg((!is_default_parameter_static<NamedParameters, internal_np::plane_index_t>()),
CGAL_static_assertion_msg((!is_default_parameter<NamedParameters, internal_np::plane_index_t>()),
"Error: no plane index map");
const PlaneIndexMap index_map =

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

@ -110,7 +110,7 @@ bool read_OFF_with_or_without_fcolors(std::istream& is,
typename Mesh::template Property_map<Face_index, Color> fcm;
bool is_fcm_requested = !(is_default_parameter(get_parameter(np, internal_np::face_color_map)));
bool is_fcm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>());
if(!is_fcm_requested && scanner.has_colors())
{
bool created;
@ -149,7 +149,7 @@ bool read_OFF_with_or_without_vtextures(std::istream& is,
typename Mesh::template Property_map<Vertex_index, Texture> vtm;
bool is_vtm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map)));
bool is_vtm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>());
if(!is_vtm_requested && scanner.has_textures())
{
bool created;
@ -187,7 +187,7 @@ bool read_OFF_with_or_without_vcolors(std::istream& is,
typename Mesh::template Property_map<Vertex_index, Color> vcm;
bool is_vcm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_color_map)));
bool is_vcm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>());
if(!is_vcm_requested && scanner.has_colors())
{
bool created;
@ -226,7 +226,7 @@ bool read_OFF_with_or_without_vnormals(std::istream& is,
typename Mesh::template Property_map<Vertex_index, Normal> vnm;
bool is_vnm_requested = !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map)));
bool is_vnm_requested = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>());
if(!is_vnm_requested && scanner.has_normals())
{
bool created;
@ -394,7 +394,7 @@ bool write_OFF_with_or_without_fcolors(std::ostream& os,
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_fcolors = !(is_default_parameter(get_parameter(np, internal_np::face_color_map)));
const bool has_fcolors = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::face_color_map_t>());
typename Mesh::template Property_map<Face_index, Color> fcolors;
bool has_internal_fcolors;
@ -421,7 +421,7 @@ bool write_OFF_with_or_without_vtextures(std::ostream& os,
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_vtextures = !(is_default_parameter(get_parameter(np, internal_np::vertex_texture_map)));
const bool has_vtextures = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_texture_map_t>());
typename Mesh::template Property_map<Vertex_index, Texture> vtextures;
bool has_internal_vtextures;
@ -446,7 +446,7 @@ bool write_OFF_with_or_without_vcolors(std::ostream& os,
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_vcolors = !(is_default_parameter(get_parameter(np, internal_np::vertex_color_map)));
const bool has_vcolors = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_color_map_t>());
typename Mesh::template Property_map<Vertex_index, Color> vcolors;
bool has_internal_vcolors;
@ -473,7 +473,7 @@ bool write_OFF_with_or_without_vnormals(std::ostream& os,
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_vnormals = !(is_default_parameter(get_parameter(np, internal_np::vertex_normal_map)));
const bool has_vnormals = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_normal_map_t>());
typename Mesh::template Property_map<Vertex_index, Normal> vnormals;
bool has_internal_vnormals;
@ -563,7 +563,7 @@ bool write_OFF(std::ostream& os,
using parameters::is_default_parameter;
using parameters::get_parameter;
const bool has_vpoints = !(is_default_parameter(get_parameter(np, internal_np::vertex_point)));
const bool has_vpoints = !(is_default_parameter<CGAL_BGL_NP_CLASS, internal_np::vertex_point_t>());
if(has_vpoints)
return internal::write_OFF_with_or_without_vnormals(os, sm, np);

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

@ -247,21 +247,21 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
// get proxy map
approx.proxy_map( get_parameter(np, internal_np::face_proxy_map) );
if (!parameters::is_default_parameter(get_parameter(np, internal_np::face_proxy_map))
if (!parameters::is_default_parameter<NamedParameters, internal_np::face_proxy_map_t>()
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Filling face proxy map done." << std::endl;
// get proxies
approx.proxies( get_parameter(np, internal_np::proxies) );
if (!is_default_parameter( get_parameter(np, internal_np::proxies) )
if (!is_default_parameter<NamedParameters,internal_np::proxies>()
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get proxies done." << std::endl;
// meshing
bool is_manifold = false;
if (!is_default_parameter( get_parameter(np, internal_np::anchors))
|| !is_default_parameter( get_parameter(np, internal_np::triangles) ))
if (!is_default_parameter<NamedParameters, internal_np::anchors_t>()
|| !is_default_parameter<NamedParameters,internal_np::triangles_t>())
{
if (vl == VERBOSE) {
const FT subdivision_ratio = choose_parameter(get_parameter(np, internal_np::subdivision_ratio), FT(5.0));
@ -287,14 +287,14 @@ bool approximate_triangle_mesh(const TriangleMesh &tm, const NamedParameters &np
// get anchor points
approx.anchor_points( get_parameter(np, internal_np::anchors) );
if (!is_default_parameter( get_parameter(np, internal_np::anchors) )
if (!is_default_parameter<NamedParameters,internal_np::anchors_t>()
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get anchors done." << std::endl;
// get indexed triangles
approx.indexed_triangles( get_parameter(np, internal_np::triangles) );
if (!is_default_parameter( get_parameter(np, internal_np::triangles) )
if (!is_default_parameter<NamedParameters,internal_np::triangles_t>()
&& (vl == MAIN_STEPS || vl == VERBOSE))
std::cout << "Get indexed triangles done." << std::endl;