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

Use a full CGAL version of named function parameters 

no longer rely on boost
This commit is contained in:
Sébastien Loriot 2019-07-14 22:45:47 +02:00
parent 40eb9922d8
commit cebf0657d8
66 changed files with 863 additions and 795 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -148,9 +148,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(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(parameters::choose_parameter(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);
}
@ -203,9 +203,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(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(parameters::choose_parameter(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);
}
@ -248,9 +248,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(get_parameter(np, internal_np::face_index), get_const_property_map(face_index, graph)))
, vimap(parameters::choose_parameter(get_parameter(np, internal_np::vertex_index), get_const_property_map(boost::vertex_index, graph)))
, himap(parameters::choose_parameter(get_parameter(np, internal_np::halfedge_index), get_const_property_map(halfedge_index, graph)))
{
set_selected_faces(selected_faces);
}

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

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

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

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

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)

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

@ -244,7 +244,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();
}
@ -336,18 +336,19 @@ void copy_face_graph(const SourceMesh& sm, TargetMesh& tm,
#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)));
}

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

@ -59,8 +59,11 @@ 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),
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));
@ -175,6 +178,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;
@ -183,7 +188,7 @@ 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),
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;
@ -286,7 +291,10 @@ 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),
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";

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

@ -1,94 +1,42 @@
//=======================================================================
// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
// Copyright (c) 2019 GeometryFactory (France). All rights reserved.
//
// This file is part of the Boost Graph Library
// 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.
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
// Copyright (c) 2007 GeometryFactory (France). All rights reserved.
// 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: BSL-1.0
// SPDX-License-Identifier: LGPL-3.0+
//
// Author(s) : Andreas Fabri, Fernando Cacciola
//
// Author(s) : Sebastien Loriot
#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
#include <boost/mpl/if.hpp>
#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;
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) \
@ -96,22 +44,113 @@ using boost::graph_visitor;
#include <CGAL/boost/graph/parameters_interface.h>
#undef CGAL_add_named_parameter
}//internal_np
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)
{}
};
template <typename T, typename Tag, typename Base = boost::no_property>
struct cgal_bgl_named_params : boost::bgl_named_params<T, Tag, Base>
// 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 cgal_bgl_named_params
: internal_np::Named_params_impl<T, Tag, Base>
{
typedef internal_np::Named_params_impl<T, Tag, Base> base;
typedef cgal_bgl_named_params<T, Tag, Base> 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 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);
}
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
@ -124,27 +163,25 @@ using boost::graph_visitor;
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();
}
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();
}
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) \
@ -156,50 +193,46 @@ namespace parameters {
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
// 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 cgal_bgl_named_params<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>
const 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
// 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

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

@ -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
@ -153,21 +153,21 @@ namespace CGAL {
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
@ -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
@ -349,7 +349,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
@ -363,13 +363,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
@ -392,7 +392,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
@ -405,7 +405,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
@ -416,7 +416,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>
@ -437,7 +437,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)

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

@ -22,161 +22,157 @@ 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_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);
// 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::projection_functor).v == 42);
assert(get_param(np, CGAL::internal_np::apply_per_connected_component).v == 46);
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::projection_functor).v == 42);
assert(get_parameter(np, CGAL::internal_np::apply_per_connected_component).v == 46);
// 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<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));
// 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<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<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<42>(get_parameter(np, CGAL::internal_np::projection_functor));
check_same_type<46>(get_parameter(np, CGAL::internal_np::apply_per_connected_component));
}
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>

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>

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

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

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

@ -468,12 +468,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));

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

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

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

@ -863,7 +863,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;
@ -874,8 +875,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,

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

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

@ -285,10 +285,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

@ -68,7 +68,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;
@ -77,8 +78,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());

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

@ -429,7 +429,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;
@ -438,8 +439,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(

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

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

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

@ -444,7 +444,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;
@ -459,8 +460,8 @@ 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 cpp11::function<bool(double)>& callback = choose_param(get_param(np, internal_np::callback),
double sharpness_angle = choose_parameter(get_parameter(np, internal_np::sharpness_angle), 30.);
const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
CGAL_point_set_processing_precondition(points.begin() != points.end());
@ -473,8 +474,8 @@ 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());
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());
// copy points and normals
Pwns pwns;

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

@ -196,7 +196,8 @@ compute_average_spacing(
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>::const_type PointMap;
@ -204,8 +205,8 @@ compute_average_spacing(
typedef typename Kernel::Point_3 Point;
PointMap point_map = choose_param(get_param(np, internal_np::point_map), PointMap());
const cpp11::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());
const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
// types for K nearest neighbors search structure

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

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

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

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

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

@ -208,11 +208,12 @@ 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 cpp11::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());
const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
// actual type of input points

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

@ -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,10 +173,10 @@ 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 cpp11::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());
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 cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
typedef typename std::iterator_traits<typename PointRange::iterator>::value_type Input_type;

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

@ -212,7 +212,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");
@ -229,10 +230,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);
const cpp11::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());
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);
const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
typedef typename Kernel::Point_3 Point;

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

@ -216,7 +216,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;
@ -227,10 +228,10 @@ 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());
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 cpp11::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());
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 cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
typedef typename Kernel::Point_3 Point;

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

@ -539,7 +539,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;
@ -550,8 +552,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());
Kernel kernel;
// Bring private stuff to scope

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

@ -199,7 +199,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
@ -211,9 +213,9 @@ 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());
const cpp11::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());
NormalMap normal_map = choose_parameter(get_parameter(np, internal_np::normal_map), NormalMap());
const cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
typedef typename Kernel::Point_3 Point;

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

@ -162,16 +162,17 @@ 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());
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.);
const cpp11::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());
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 cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
typedef typename Kernel::FT FT;

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

@ -235,7 +235,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;
@ -250,11 +251,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());
@ -1553,7 +1554,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;

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

@ -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
@ -345,7 +347,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;
@ -356,8 +360,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 cpp11::array<double, 6> Covariance;

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

@ -472,18 +472,19 @@ 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 cpp11::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());
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 cpp11::function<bool(double)>& callback = choose_parameter(get_parameter(np, internal_np::callback),
cpp11::function<bool(double)>());
typedef typename Kernel::Point_3 Point;

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

@ -66,14 +66,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;
@ -116,14 +116,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) );
@ -159,14 +159,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)) ) +
@ -203,14 +203,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

@ -200,8 +200,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);
}

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

@ -64,7 +64,7 @@ clip_open_impl( TriangleMesh& tm,
// vector of clipper triangles
Clipper_triangles clipper_triangles;
clipper_triangles.reserve( num_faces(clipper) );
Vpm vpm_c = boost::choose_param(boost::get_param(np_c, internal_np::vertex_point),
Vpm vpm_c = parameters::choose_parameter(parameters::get_parameter(np_c, internal_np::vertex_point),
get_property_map(vertex_point, clipper));
BOOST_FOREACH(face_descriptor f, faces(clipper))
{
@ -94,9 +94,9 @@ clip_open_impl( TriangleMesh& tm,
typedef typename GetFaceIndexMap<TriangleMesh,
NamedParameters1>::type Fid_map;
Fid_map fid_map = boost::choose_param(boost::get_param(np_tm, internal_np::face_index),
Fid_map fid_map = parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::face_index),
get_property_map(boost::face_index, tm));
Vpm vpm1 = boost::choose_param(boost::get_param(np_tm, internal_np::vertex_point),
Vpm vpm1 = parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::vertex_point),
get_property_map(vertex_point, tm));
typedef CGAL::dynamic_vertex_property_t<std::size_t> Vid_tag;
@ -150,7 +150,7 @@ clip_open_impl( TriangleMesh& tm,
{
// A patch with no vertex incident to a non-constrained edges
// is a coplanar patch: drop it or keep it!
if (!boost::choose_param(boost::get_param(np_tm, internal_np::use_compact_clipper), true))
if (!parameters::choose_parameter(parameters::get_parameter(np_tm, internal_np::use_compact_clipper), true))
{
for (std::size_t cc_id = cc_not_handled.find_first();
cc_id < cc_not_handled.npos;
@ -201,7 +201,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));
@ -451,7 +451,7 @@ clip( TriangleMesh& tm,
const NamedParameters2& np_c)
{
const bool close =
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 (close && 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

@ -132,14 +132,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;
@ -230,18 +230,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

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

@ -133,16 +133,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;
@ -213,16 +213,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;
@ -234,7 +234,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,
@ -296,12 +296,12 @@ 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),
FaceIndexMap fimap = choose_parameter(get_parameter(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
//vector_property_map
@ -379,12 +379,12 @@ 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),
FaceIndexMap fim = choose_parameter(get_parameter(np, internal_np::face_index),
get_property_map(boost::face_index, pmesh));
//vector_property_map
@ -433,8 +433,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;
@ -446,7 +446,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;
@ -683,12 +683,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
@ -741,12 +741,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

70
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,13 +249,13 @@ 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(cpp11::get<I>(nps_out), internal_np::edge_is_constrained), \
parameters::choose_parameter( parameters::get_parameter(cpp11::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;
@ -495,21 +495,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;
@ -534,17 +534,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
@ -828,7 +828,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,
@ -840,28 +840,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;
@ -874,12 +874,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
@ -932,27 +932,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>() ) );
@ -1007,28 +1007,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

@ -147,11 +147,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,
@ -214,7 +214,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;
@ -284,10 +284,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));
}
@ -363,7 +363,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
}
@ -438,7 +438,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

@ -341,32 +341,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)
@ -381,7 +381,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
@ -408,9 +408,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.) )
@ -489,7 +489,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)
{
@ -505,7 +505,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)
{
@ -631,7 +631,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)));
}
@ -688,7 +688,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)));
}
@ -735,8 +735,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);
}

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

@ -176,9 +176,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;
@ -269,7 +272,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

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

81
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));
@ -425,9 +425,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<
@ -453,7 +453,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,
@ -520,8 +520,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));
@ -529,8 +529,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,
@ -575,7 +575,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,
@ -644,8 +644,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));
@ -653,8 +653,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(
@ -707,7 +707,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,
@ -1205,11 +1205,11 @@ bool do_intersect(const TriangleMesh& tm1,
const NamedParameters1& np1,
const NamedParameters2& np2)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
bool test_overlap = choose_param(get_param(np1, internal_np::overlap_test),false) ||
choose_param(get_param(np2, internal_np::overlap_test),false);
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));
@ -1228,12 +1228,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);
@ -1486,18 +1486,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(),
@ -1570,12 +1570,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;
@ -1593,7 +1593,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)
@ -1668,7 +1668,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;
@ -1679,12 +1679,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);
@ -1728,9 +1726,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,

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

@ -99,11 +99,11 @@ public:
, 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));
return CGAL::approximate_sqrt(CGAL::squared_distance(get(vpm, source(h, pmesh)),
@ -318,13 +318,13 @@ public:
, const TriangleMesh& tmesh
, const CGAL_PMP_NP_CLASS& np)
{
using boost::choose_param;
using boost::get_param;
using parameters::choose_parameter;
using parameters::get_parameter;
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),
vpm = choose_parameter(get_parameter(np, internal_np::vertex_point),
get_const_property_map(CGAL::vertex_point, tmesh));
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
@ -501,11 +501,11 @@ volume(const TriangleMesh& tmesh, const CGAL_PMP_NP_CLASS& np)
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);

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

@ -70,18 +70,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;
@ -183,16 +183,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);
@ -483,16 +483,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));
@ -590,16 +590,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));

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

@ -151,8 +151,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;
@ -165,22 +165,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,
internal::No_constraint_pmap<vertex_descriptor>//default
> ::type VCMap;
VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained),
VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
internal::No_constraint_pmap<vertex_descriptor>());
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);
}

52
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,44 +160,44 @@ 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;
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,
internal::No_constraint_pmap<edge_descriptor>//default
> ::type ECMap;
ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained)
ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained)
, internal::No_constraint_pmap<edge_descriptor>());
typedef typename boost::lookup_named_param_def <
typedef typename internal_np::Lookup_named_param_def <
internal_np::vertex_is_constrained_t,
NamedParameters,
internal::No_constraint_pmap<vertex_descriptor>//default
> ::type VCMap;
VCMap vcmap = choose_param(get_param(np, internal_np::vertex_is_constrained),
VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
internal::No_constraint_pmap<vertex_descriptor>());
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
@ -235,10 +235,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;
@ -259,8 +259,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
@ -336,24 +336,24 @@ 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;
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,
internal::No_constraint_pmap<edge_descriptor>//default
> ::type ECMap;
ECMap ecmap = choose_param(get_param(np, internal_np::edge_is_constrained),
ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
internal::No_constraint_pmap<edge_descriptor>());
typename internal::Incremental_remesher<PM, VPMap, GT, ECMap,

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

@ -372,8 +372,8 @@ std::size_t remove_null_edges(
{
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;
@ -383,10 +383,10 @@ std::size_t remove_null_edges(
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());
std::size_t nb_deg_faces = 0;
@ -699,8 +699,8 @@ std::size_t remove_degenerate_faces(TriangleMesh& tmesh,
{
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;
@ -710,10 +710,10 @@ std::size_t remove_degenerate_faces(TriangleMesh& tmesh,
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;
@ -1881,12 +1881,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";

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

@ -341,8 +341,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));
BOOST_FOREACH(face_descriptor f, face_range)
{
@ -367,7 +367,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);

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

@ -177,14 +177,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);
}
@ -591,8 +591,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);
}
@ -626,15 +626,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));
internal::collect_duplicated_stitchable_boundary_edges(pmesh,

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));
BOOST_FOREACH(typename boost::graph_traits<PolygonMesh>::vertex_descriptor vd, vertices(mesh))
{

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

@ -431,20 +431,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);
@ -486,20 +486,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

@ -88,14 +88,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());
@ -103,9 +103,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;
}
@ -333,14 +333,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;
@ -360,7 +360,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());

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

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

@ -137,9 +137,9 @@ void Polyhedron_demo_inside_out_plugin::on_actionOrientCC_triggered()
Polyhedron* pMesh = poly_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);
poly_item->invalidateOpenGLBuffers();
}
}
@ -147,9 +147,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();
}
}

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

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

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

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

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

@ -125,13 +125,13 @@ void CatmullClark_subdivision(PolygonMesh& pmesh, int step = 1) {
**/
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++)
@ -170,13 +170,13 @@ void Loop_subdivision(PolygonMesh& pmesh, int step = 1) {
**/
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++)
@ -215,13 +215,13 @@ void DooSabin_subdivision(PolygonMesh& pmesh, int step = 1) {
**/
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++)
@ -265,13 +265,13 @@ void Sqrt3_subdivision(PolygonMesh& pmesh, int step = 1) {
**/
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++)

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

@ -2099,13 +2099,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;
@ -2190,8 +2193,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;

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

@ -105,9 +105,8 @@ int edge_collapse ( TM& aSurface
, cgal_bgl_named_params<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,13 +114,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_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())
);
}
@ -131,9 +130,8 @@ int edge_collapse ( TM& aSurface
, cgal_bgl_named_params<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())
);
}