Create Surface_mesh optimally when all connectivity information is known

[vladgl]

I have a custom repairing pipeline for my triangular mesh that produces a manifold. As a byproduct, it has all the connectivity information needed to construct half edge mesh: map of incident faces for each canonical edge, vertex "stars" and border loops. After repairing, I want to use some CGAL functions, so I need to convert it to Surface_mesh, and that conversion must be as fast as possible, meaning that I want to do that conversion linearly and preallocate all the memory it requires. I am not a CGAL guru in the sense that I am not very familiar with its internal structure, therefore, I need some help to figure out where to start.

[sloriot]

I suggest to try to use CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh(). If it is too slow for your application, we can think of another low-level solution.

[vladgl]

I'm already using this, but it requires me to convert my triangular mesh into vector of vectors to represent polygons, which is inefficient (I need to process a lot of meshes, so performance is crucial in my application). Also, I'm not reusing connectivity information, which is bad, but avoiding polygon soup conversion would be nice too.

[sloriot]

what would be the signature of the function you'd like to use then?

[vladgl]

I have a std::vector<vec3> representing points and std::vector<ivec3> representing faces (both vec3 and ivec3 are Eigen 1D matrix types). I also have a std::unordered_map<edge, std::vector<int>> representing edge-face connections (edge is a sorted pair of indices) and std::vector<std::vector<int>> that represents "vertex stars": lists of faces connected to vertices. I want to convert this into CGAL::Surface_mesh reusing as much information as possible. For now I'm doing this by converting my points and faces arrays into CGAL points and polygons ("polygon soup"), but this seem to be bad approach, as I need to allocate a lot of vectors for polygons in polygon soup, and CGAL internally needs to recalculate some connectivity information that I have calculated on my side. I'm asking how can I avoid all of these seemingly redundant steps.

[sloriot]

I'm very curious to see how you designed your repair pipeline such that the performance bottleneck is the mesh creation.

Anyway, you first need to create the Surface_mesh and allocate memory. For that you can use reserve().

Then you need to add the vertices and set the points. For that you need to use add_vertex().

Then you need to create edges are link them together and to incident faces.
To add an edge, you can use add_edge(). Note that it is important to add edges only once. The function will return a halfedge, corresponding to the oriented edge, pointing in one of the two (at most) incident faces.

Then you need to add faces. You can use add_face().

I don't know what information exactly you have but if you only have edge->face connected and no edge connection, it might be better to first create faces so that you can associate the halfedges while creating them.

halfedges will need to be linked together using set_next().

halfedges and faces also need to be associated using set_face() and set_halfedge() (only for one halfedge of the face).

With all that done you should be done.