How to constrain edge in refine function in Polygon Mesh Processing Package

classic Classic list List threaded Threaded
3 messages Options
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

How to constrain edge in refine function in Polygon Mesh Processing Package

Yongzhou Gu
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;
}
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: How to constrain edge in refine function in Polygon Mesh Processing Package

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

--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://sympa.inria.fr/sympa/info/cgal-discuss


Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

Re: How to constrain edge in refine function in Polygon Mesh Processing Package

Yongzhou Gu
Thanks for your reply !

I've tried the isotropic_remeshing() and boost::associative_property_map. It works!

Best,
Yongzhou Gu

On Wed, Apr 5, 2017 at 2:37 AM, Andreas Fabri <[hidden email]> wrote:


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: <a href="tel:%2B33.492.954.912" value="+33492954912" target="_blank">+33.492.954.912    skype: andreas.fabri

--
You are currently subscribed to cgal-discuss.
To unsubscribe or access the archives, go to
https://sympa.inria.fr/sympa/info/cgal-discuss



Loading...