CGAL users discussion list

[Andreas Fabri <>]

Hello,

I agree that we should improve the manual and add an example
where we use property maps.

A property map must be lightweight and your class RMap is not
as it stores a std::map.

You should follow the example in
http://www.boost.org/doc/libs/1_59_0/libs/property_map/doc/associative_property_map.html

where one wraps a reference to a std::map in a
boost::associative_property_map

Instead of a std::map you might also use a boost::unordered_map.

In case you used the class CGAL::Surface_mesh,  it has
a property mechanism, which has the property API for
the Polygon Mesh Procesing package.

Concerning the refine() function it does not offer a way
to constrain edges. Only isotropic_remeshing() does.

Best,

Andreas


On 05/04/2017 05:54, Yongzhou Gu wrote:
> Subject: How to constrain edge in refine function in Polygon Mesh
> Processing Package
> Hi,
> I want to use the refine function in Polygon Mesh Processing Package to
> refine a triangulation mesh. During the mesh, I want to constrain some
> edges from being deleted. I found that the refine function can add a
> "edge_is_constrained_map" as parameter, but I don't know how to create a
> edge map. (I don't know how to get edge_descripter from a polyhedron)
>
> Here is my code:
>
>
> #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
> #include <CGAL/Polyhedron_3.h>
> #include <CGAL/boost/graph/graph_traits_Polyhedron_3.h>
> #include <CGAL/IO/Polyhedron_iostream.h>
> #include <CGAL/Polygon_mesh_processing/refine.h>
> //#include <CGAL/Polygon_mesh_processing/fair.h>
> #include <boost/graph/graph_traits.hpp>
> #include <fstream>
> #include <map>
> using namespace std;
> typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel;
> typedef CGAL::Polyhedron_3<Kernel>  Polyhedron;
> typedef Polyhedron::Vertex_handle   Vertex_handle;
> typedef boost::graph_traits<Polyhedron>::edge_descriptor ED;
> typedef boost::graph_traits<Polyhedron>::vertex_descriptor VD;
> typedef Polyhedron::Halfedge    edge;
> // extract vertices which are at most k (inclusive)
> // far from vertex v in the graph of edges
> void extract_k_ring(Vertex_handle v,
>                     int k,
>                     std::vector<Vertex_handle>& qv)
> {
>   std::map<Vertex_handle, int>  D;
>   qv.push_back(v);
>   D[v] = 0;
>   std::size_t current_index = 0;
>   int dist_v;
>   while (current_index < qv.size() && (dist_v = D[qv[current_index]]) < k)
>   {
>     v = qv[current_index++];
>     Polyhedron::Halfedge_around_vertex_circulator e(v->vertex_begin()),
> e_end(e);
>     do {
>       Vertex_handle new_v = e->opposite()->vertex();
>       if (D.insert(std::make_pair(new_v, dist_v + 1)).second) {
>         qv.push_back(new_v);
>       }
>     } while (++e != e_end);
>   }
> }
>
> class RMap{
> private:
>     map<ED, bool> mymap;
> public:
>     bool get(ED& ed){
>         return mymap[ed];
>     }
>     void put(ED ed, bool v){
>         mymap[ed] = v;
>     }
> };
>
> class VMap{
> private:
>     map<VD, bool> mymap;
> public:
>     bool get(VD& ed){
>         return mymap[ed];
>     }
>     void put(VD ed, bool v){
>         mymap[ed] = v;
>     }
> };
>
> int main(int argc, char* argv[])
> {
>   const char* filename = (argc > 1) ? argv[1] : "data/OFF.off";
>   std::ifstream input(filename);
>   Polyhedron poly;
>   if ( !input || !(input >> poly) || poly.empty() ) {
>     std::cerr << "Not a valid off file." << std::endl;
>     return 1;
>   }
>   std::vector<Polyhedron::Facet_handle>  new_facets;
>   std::vector<Vertex_handle> new_vertices;
>
>   RMap mymap;
>   VMap imap;
>   ED e1,e2;
>   //auto it = poly.vertices_begin();
>   //auto it = poly.halfedges_begin();
>   //mymap.put(*it, true);
>     auto a = add_edge(poly);
>     mymap.put(a, true);
>   //imap.put(a, true);
>   //cout << *it << endl;
>
>
>   CGAL::Polygon_mesh_processing::refine(poly,
>                   faces(poly),
>                   std::back_inserter(new_facets),
>                   std::back_inserter(new_vertices),
>
> CGAL::Polygon_mesh_processing::parameters::density_control_factor(100.).
>                   protect_constraints(true).
>                   edge_is_constrained_map(mymap));//.
>                   //vertex_is_constrained_map(imap));
>   std::ofstream refined_off("refined.off");
>   refined_off << poly;
>   refined_off.close();
>   std::cout << "Refinement added " << new_vertices.size() << "
> vertices." << std::endl;
>   Polyhedron::Vertex_iterator v = poly.vertices_begin();
>   std::advance(v, 82);
>   std::vector<Vertex_handle> region;
>   extract_k_ring(v, 12, region);
>   //bool success = CGAL::Polygon_mesh_processing::fair(poly, region);
>   //std::cout << "Fairing : " << (success ? "succeeded" : "failed") <<
> std::endl;
>   //std::ofstream faired_off("faired.off");
>   //faired_off << poly;
>   //faired_off.close();
>   return 0;
> }

--
Andreas Fabri, PhD
Chief Officer, GeometryFactory
Editor, The CGAL Project

phone: +33.492.954.912    skype: andreas.fabri