CGAL users discussion list

[Yongzhou Gu <>]

Hi,

My final purpose is to constrain some edges during isotropic_remseshing with proper splits on these edges.

However, when I use split_long_edge, the original edges are replaced by the new shorter edges. Thus the original constrained edges are no longer exist. 

So, I tried to reset the constrained_edge_map. This requires me to determine whether the edge lies on the original long edge which is split by the function before. Thus I need to get the coordinates of both end of an edge to compare the position with the original long edge.

I've got iterator of edge descriptor now and I want to get the points' coordinates of both ends. But I don't know how to get it from an edge descriptor. Follows is my code:

#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>

#include <CGAL/Surface_mesh.h>

#include <CGAL/boost/graph/graph_traits_Surface_mesh.h>

#include <CGAL/Polygon_mesh_processing/remesh.h>

#include <CGAL/Polygon_mesh_processing/border.h>

#include <boost/function_output_iterator.hpp>

#include <fstream>

#include <vector>

#include <map>

#include <string>

#include <stdio.h>

#include <boost/property_map/property_map.hpp>

#include <boost/graph/kruskal_min_spanning_tree.hpp>

typedef CGAL::Exact_predicates_inexact_constructions_kernel K;

typedef CGAL::Surface_mesh<K::Point_3> Mesh;

typedef boost::graph_traits<Mesh>::halfedge_descriptor halfedge_descriptor;

typedef boost::graph_traits<Mesh>::edge_descriptor     edge_descriptor;

typedef boost::graph_traits<Mesh>::vertex_descriptor     vertex_descriptor;

namespace PMP = CGAL::Polygon_mesh_processing;

struct halfedge2edge

{

  halfedge2edge(const Mesh& m, std::vector<edge_descriptor>& edges)

    : m_mesh(m), m_edges(edges)

  {}

  void operator()(const halfedge_descriptor& h) const

  {

    m_edges.push_back(edge(h, m_mesh));

  }

  const Mesh& m_mesh;

  std::vector<edge_descriptor>& m_edges;

};

int main(int argc, char* argv[])

{

  Mesh mesh;

  vertex_descriptor vd[12];

  vd[0] = mesh.add_vertex(K::Point_3(0,0,0));   // cons

  vd[1] = mesh.add_vertex(K::Point_3(1,0,0));

  vd[2] = mesh.add_vertex(K::Point_3(2,0,0));

  vd[3] = mesh.add_vertex(K::Point_3(0,1,0));

  vd[4] = mesh.add_vertex(K::Point_3(1,1,0));   // cons

  vd[5] = mesh.add_vertex(K::Point_3(2,1,0));

  vd[6] = mesh.add_vertex(K::Point_3(0,2,0));

  vd[7] = mesh.add_vertex(K::Point_3(1,2,0));   // cons

  vd[8] = mesh.add_vertex(K::Point_3(2,2,0));

  vd[9] = mesh.add_vertex(K::Point_3(0,3,0));

  vd[10] = mesh.add_vertex(K::Point_3(1,3,0));

  vd[11] = mesh.add_vertex(K::Point_3(2,3,0));  // cons

  mesh.add_face(vd[0], vd[1], vd[4]);

  mesh.add_face(vd[1], vd[2], vd[5]);

  mesh.add_face(vd[0], vd[4], vd[3]);

  mesh.add_face(vd[1], vd[5], vd[4]);

  mesh.add_face(vd[3], vd[4], vd[7]);

  mesh.add_face(vd[4], vd[5], vd[8]);

  mesh.add_face(vd[3], vd[7], vd[6]);

  mesh.add_face(vd[4], vd[8], vd[7]);

  mesh.add_face(vd[6], vd[7], vd[10]);

  mesh.add_face(vd[7], vd[8], vd[11]);

  mesh.add_face(vd[6], vd[10], vd[9]);

  mesh.add_face(vd[7], vd[11], vd[10]);

  double target_edge_length;

  std::cout << "input tartget_edge_length: ";

  std::cin >> target_edge_length;

  unsigned int nb_iter = 3;

  //std::cin >> nb_iter;

  std::cout << "Split border...";

  std::vector<edge_descriptor> border;

  std::map<edge_descriptor, bool> edgeMap;

  boost::associative_property_map< std::map<edge_descriptor, bool> >

    edge_map(edgeMap);

  std::map<vertex_descriptor, bool> vertexMap;

  boost::associative_property_map< std::map<vertex_descriptor, bool> >

    vertex_map(vertexMap);

  Mesh::Edge_range::iterator  eb, ee;

  Mesh::Edge_range r = mesh.edges();

  eb = r.begin();

  ee = r.end();

  auto it = eb;

// Let's split the outiside boundary

double outside_boundary_split_length = 0.1;

  std::cin >> outside_boundary_split_length;

// split the selected border

  for (; it != r.end(); it++){

        border.push_back(*it);

        edgeMap.insert(std::make_pair(*it, 

          true));

  }

printf("boder size = %d\n", border.size());

  

PMP::split_long_edges(border, outside_boundary_split_length, mesh);

// Set my constrained edge ends

  r = mesh.edges();

  it = r.begin();

int cnt = 0;

  for (; it != r.end(); it++){

/****************************** How do I get the coordinates of vertices here? ********************************************/

   it->???

    cnt ++;

  }

printf("num of edges %d\n", cnt);

  std::cout << "done." << std::endl;

  std::cout << "Start remeshing of "

    << " (" << num_faces(mesh) << " faces)..." << std::endl;

 

  PMP::isotropic_remeshing(

      faces(mesh),

      target_edge_length,

      mesh,

      PMP::parameters::number_of_iterations(nb_iter)

      .edge_is_constrained_map(edge_map)

      .protect_constraints(true)//i.e. protect border, here

      );

  //PMP::split_long_edges(border, target_edge_length, mesh);

  

  std::ofstream iso_off("isotropic.off");

  iso_off << mesh;

  iso_off.close();

  std::cout << "Remeshing done." << std::endl;

  return 0;

}