[algorithms] export triangulated face indices to buffer

Author: alemuntoni

examples/core/007-mesh-conversion/main.cpp

@@ -56,5 +56,12 @@ int main()
 
     vcl::save(m, VCLIB_RESULTS_PATH "/cube_from_poly.ply", s);
 
+    pm = vcl::loadObj<vcl::PolyMesh>(VCLIB_EXAMPLE_MESHES_PATH
+                                         "/rhombicosidodecahedron.obj");
+
+    m.importFrom(pm);
+
+    vcl::save(m, VCLIB_RESULTS_PATH "/tri_rhombicosidodecahedron.ply", s);
+
     return 0;
 }

tests/core/019-export-matrix/main.cpp

@@ -107,8 +107,7 @@ void testCoordsMatrix(const auto& tm)
     REQUIRE(verts.rows() == tm.vertexNumber());
     REQUIRE(verts.cols() == 3);
 
-    vcl::uint i = 0;
-    for (const auto& c : tm.vertices() | vcl::views::coords) {
+    for (vcl::uint i = 0; const auto& c : tm.vertices() | vcl::views::coords) {
         REQUIRE(verts(i, 0) == c.x());
         REQUIRE(verts(i, 1) == c.y());
         REQUIRE(verts(i, 2) == c.z());
@@ -124,8 +123,7 @@ void testTrianglesMatrix(const auto& tm)
     REQUIRE(tris.rows() == tm.faceNumber());
     REQUIRE(tris.cols() == 3);
 
-    vcl::uint i = 0;
-    for (const auto& f : tm.faces()) {
+    for (vcl::uint i = 0; const auto& f : tm.faces()) {
         for (vcl::uint j = 0; j < 3; ++j) {
             REQUIRE(tris(i, j) == f.vertexIndex(j));
         }
@@ -140,8 +138,7 @@ void testFaceSizesVector(const auto& pm)
 
     REQUIRE(sizes.size() == pm.faceNumber());
 
-    vcl::uint i = 0;
-    for (const auto& f : pm.faces()) {
+    for (vcl::uint i = 0; const auto& f : pm.faces()) {
         REQUIRE(sizes[i] == f.vertexNumber());
         ++i;
     }
@@ -155,8 +152,7 @@ void testFaceVector(const auto& pm)
     vcl::uint nIndices = countPerFaceVertexReferences(pm);
     REQUIRE(faces.size() == nIndices);
 
-    vcl::uint i = 0;
-    for (const auto& f : pm.faces()) {
+    for (vcl::uint i = 0; const auto& f : pm.faces()) {
         for (const auto* v : f.vertices()) {
             REQUIRE(faces[i] == pm.index(v));
             ++i;
@@ -172,8 +168,7 @@ void testFaceMatrix(const auto& pm)
     REQUIRE(faces.rows() == pm.faceNumber());
     REQUIRE(faces.cols() == vcl::largestFaceSize(pm));
 
-    vcl::uint i = 0;
-    for (const auto& f : pm.faces()) {
+    for (vcl::uint i = 0; const auto& f : pm.faces()) {
         vcl::uint j = 0;
         for (j = 0; j < f.vertexNumber(); ++j) {
             REQUIRE(faces(i, j) == f.vertexIndex(j));
@@ -186,15 +181,37 @@ void testFaceMatrix(const auto& pm)
     }
 }
 
+template<typename MatrixType>
+void testTriangulatedFaceMatrix(const auto& pm)
+{
+    vcl::TriPolyIndexBiMap indexMap;
+    auto tris = vcl::triangulatedFaceIndicesMatrix<MatrixType>(pm, indexMap);
+
+    vcl::uint tNumber = countTriangulatedTriangles(pm);
+
+    REQUIRE(tris.rows() == tNumber);
+    REQUIRE(tris.cols() == 3);
+
+    for (vcl::uint i = 0; i < 3; ++i) {
+        // polygon associated to ith triangle
+        vcl::uint fIdx = indexMap.polygon(i);
+        const auto& f   = pm.face(fIdx);
+
+        for (vcl::uint j = 0; j < 3; ++j) {
+            REQUIRE(f.containsVertex(tris(i, j)));
+        }
+        ++i;
+    }
+}
+
 template<typename VectorType>
 void testVertexSelectionVector(const auto& tm)
 {
     auto sel = vcl::vertexSelectionVector<VectorType>(tm);
 
     REQUIRE(sel.size() == tm.vertexNumber());
 
-    vcl::uint i = 0;
-    for (const auto& v : tm.vertices()) {
+    for (vcl::uint i = 0; const auto& v : tm.vertices()) {
         REQUIRE((bool) sel[i] == v.selected());
         ++i;
     }
@@ -207,8 +224,7 @@ void testFaceSelectionVector(const auto& tm)
 
     REQUIRE(sel.size() == tm.faceNumber());
 
-    vcl::uint i = 0;
-    for (const auto& f : tm.faces()) {
+    for (vcl::uint i = 0; const auto& f : tm.faces()) {
         REQUIRE((bool) sel[i] == f.selected());
         ++i;
     }
@@ -222,8 +238,7 @@ void testVertNormalsMatrix(const auto& tm)
     REQUIRE(vertNormals.rows() == tm.vertexNumber());
     REQUIRE(vertNormals.cols() == 3);
 
-    vcl::uint i = 0;
-    for (const auto& n : tm.vertices() | vcl::views::normals) {
+    for (vcl::uint i = 0; const auto& n : tm.vertices() | vcl::views::normals) {
         REQUIRE(vertNormals(i, 0) == n.x());
         REQUIRE(vertNormals(i, 1) == n.y());
         REQUIRE(vertNormals(i, 2) == n.z());
@@ -239,8 +254,7 @@ void testFaceNormalsMatrix(const auto& tm)
     REQUIRE(faceNormals.rows() == tm.faceNumber());
     REQUIRE(faceNormals.cols() == 3);
 
-    vcl::uint i = 0;
-    for (const auto& n : tm.faces() | vcl::views::normals) {
+    for (vcl::uint i = 0; const auto& n : tm.faces() | vcl::views::normals) {
         REQUIRE(faceNormals(i, 0) == n.x());
         REQUIRE(faceNormals(i, 1) == n.y());
         REQUIRE(faceNormals(i, 2) == n.z());
@@ -256,8 +270,7 @@ void testVertColorsMatrix(const auto& tm)
     REQUIRE(vertColors.rows() == tm.vertexNumber());
     REQUIRE(vertColors.cols() == 4);
 
-    vcl::uint i = 0;
-    for (const auto& c : tm.vertices() | vcl::views::colors) {
+    for (vcl::uint i = 0; const auto& c : tm.vertices() | vcl::views::colors) {
         REQUIRE(vertColors(i, 0) == c.red());
         REQUIRE(vertColors(i, 1) == c.green());
         REQUIRE(vertColors(i, 2) == c.blue());
@@ -274,8 +287,7 @@ void testVertColorsVector(const auto& tm)
 
     REQUIRE(vertColors.size() == tm.vertexNumber());
 
-    vcl::uint i = 0;
-    for (const auto& c : tm.vertices() | vcl::views::colors) {
+    for (vcl::uint i = 0; const auto& c : tm.vertices() | vcl::views::colors) {
         REQUIRE(vertColors[i] == c.rgba());
         ++i;
     }
@@ -289,8 +301,7 @@ void testFaceColorsMatrix(const auto& tm)
     REQUIRE(faceColors.rows() == tm.faceNumber());
     REQUIRE(faceColors.cols() == 4);
 
-    vcl::uint i = 0;
-    for (const auto& c : tm.faces() | vcl::views::colors) {
+    for (vcl::uint i = 0; const auto& c : tm.faces() | vcl::views::colors) {
         REQUIRE(faceColors(i, 0) == c.red());
         REQUIRE(faceColors(i, 1) == c.green());
         REQUIRE(faceColors(i, 2) == c.blue());
@@ -307,8 +318,7 @@ void testFaceColorsVector(const auto& tm)
 
     REQUIRE(faceColors.size() == tm.faceNumber());
 
-    vcl::uint i = 0;
-    for (const auto& c : tm.faces() | vcl::views::colors) {
+    for (vcl::uint i = 0; const auto& c : tm.faces() | vcl::views::colors) {
         REQUIRE(faceColors[i] == c.rgba());
         ++i;
     }
@@ -321,8 +331,7 @@ void testVertexQualityVector(const auto& tm)
 
     REQUIRE(qual.size() == tm.vertexNumber());
 
-    vcl::uint i = 0;
-    for (const auto& v : tm.vertices()) {
+    for (vcl::uint i = 0; const auto& v : tm.vertices()) {
         REQUIRE(qual[i] == v.quality());
         ++i;
     }
@@ -335,8 +344,7 @@ void testFaceQualityVector(const auto& tm)
 
     REQUIRE(qual.size() == tm.faceNumber());
 
-    vcl::uint i = 0;
-    for (const auto& f : tm.faces()) {
+    for (vcl::uint i = 0; const auto& f : tm.faces()) {
         REQUIRE(qual[i] == f.quality());
         ++i;
     }
@@ -475,6 +483,30 @@ TEMPLATE_TEST_CASE(
         }
     }
 
+    SECTION("Triangulated Faces...")
+    {
+        SECTION("Eigen Row Major")
+        {
+            testTriangulatedFaceMatrix<EigenRowMatrix<vcl::uint>>(pm);
+        }
+        SECTION("Eigen 3 Row Major")
+        {
+            testTriangulatedFaceMatrix<Eigen3RowMatrix<vcl::uint>>(pm);
+        }
+        SECTION("Eigen Col Major")
+        {
+            testTriangulatedFaceMatrix<EigenColMatrix<vcl::uint>>(pm);
+        }
+        SECTION("Eigen 3 Col Major")
+        {
+            testTriangulatedFaceMatrix<Eigen3ColMatrix<vcl::uint>>(pm);
+        }
+        SECTION("vcl::Array2")
+        {
+            testTriangulatedFaceMatrix<vcl::Array2<vcl::uint>>(pm);
+        }
+    }
+
     SECTION("Vertex selection...")
     {
         randomSelection<vcl::ElemId::VERTEX>(tm);

vclib/core/include/vclib/algorithms/mesh/import_export/export_buffer.h

@@ -23,11 +23,19 @@
 #ifndef VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_BUFFER_H
 #define VCL_ALGORITHMS_MESH_IMPORT_EXPORT_EXPORT_BUFFER_H
 
+#include <vclib/algorithms/core/polygon/ear_cut.h>
 #include <vclib/mesh/requirements.h>
+#include <vclib/space/complex/tri_poly_index_bimap.h>
 #include <vclib/views/mesh.h>
 
 namespace vcl {
 
+namespace detail {
+
+inline static TriPolyIndexBiMap indexMap;
+
+} // namespace detail
+
 /**
  * @brief Export the vertex coordinates of a mesh to a buffer.
  *
@@ -266,6 +274,100 @@ void faceIndicesToBuffer(
     }
 }
 
+/**
+ * @brief Export into a buffer the vertex indices for each triangle computed
+ * by triangulating the faces of a Mesh.
+ *
+ * This function exports the vertex indices of the triangles computed by
+ * triangulating the faces of a mesh to a buffer. Indices are stored following
+ * the order the faces appear in the mesh. The buffer must be preallocated with
+ * the correct size (number of *resulting triangles* times 3).
+ *
+ * You can use the function @ref vcl::countTriangulatedTriangles to get the
+ * number of resulting triangles and allocate the buffer accordingly:
+ *
+ * @code{.cpp}
+ * uint numTris = vcl::countTriangulatedTriangles(myMesh);
+ * Eigen::MatrixXi triIndices(numTris, 3);
+ * vcl::TriPolyIndexBiMap indexMap;
+ * vcl::triangulatedFaceIndicesToBuffer(
+ *     myMesh, triIndices.data(), indexMap, MatrixStorageType::COLUMN_MAJOR,
+ *     numTris);
+ * @endcode
+ *
+ * The input indexMap is used to map each triangle to the face index. If the
+ * storage of the buffer is column major, the number of resulting triangles
+ * (that should be known when calling this function) should be given as input.
+ * If the number of resulting triangles is not given, the function will compute
+ * it again.
+ *
+ * @note This function does not guarantee that the vertex indices stored in the
+ * buffer correspond to the vertex indices of the mesh. This scenario is
+ * possible when the mesh has deleted vertices. To be sure to have a direct
+ * correspondence, compact the vertex container before calling this function.
+ *
+ * @param[in] mesh: input mesh
+ * @param[out] buffer: preallocated buffer
+ * @param[out] indexMap: map from triangle index to face index
+ * @param[in] storage: storage type of the matrix (row or column major)
+ * @param[in] numTriangles: number of resulting triangles (necessary only if
+ * the storage is column major)
+ */
+template<FaceMeshConcept MeshType>
+void triangulatedFaceIndicesToBuffer(
+    const MeshType&    mesh,
+    auto*              buffer,
+    TriPolyIndexBiMap& indexMap = detail::indexMap,
+    MatrixStorageType  storage = MatrixStorageType::ROW_MAJOR,
+    uint               numTriangles = UINT_NULL)
+{
+    // there will be at least a triangle for each polygon
+    indexMap.clear();
+    indexMap.reserve(mesh.faceNumber(), mesh.faceContainerSize());
+
+    if constexpr (TriangleMeshConcept<MeshType>) {
+        // construct the indexMap, which maps each triangle to the face index
+        for (uint t = 0; const auto& f : mesh.faces()) {
+            // map the ith triangle to the f face
+            indexMap.insert(t, f.index());
+            ++t;
+        }
+
+        return triangleIndicesToBuffer(mesh, buffer, storage);
+    }
+    else {
+        // if the user did not give the number of triangles, and the buffer
+        // storage is column major, we need to compute the number of resulting
+        // triangles
+        if (numTriangles == UINT_NULL &&
+            storage == MatrixStorageType::COLUMN_MAJOR &&
+            mesh.faceNumber() > 0) {
+            numTriangles = countTriangulatedTriangles(mesh);
+        }
+        for (uint t = 0; const auto& f : mesh.faces()) {
+            std::vector<uint> vind = vcl::earCut(f);
+
+            // for each triangle of the triangulation (t is the triangle index)
+            for (uint vi = 0; vi < vind.size(); vi += 3) {
+                // map the t-th triangle to the f polygonal face
+                indexMap.insert(t, f.index());
+
+                if (storage == MatrixStorageType::ROW_MAJOR) {
+                    buffer[t * 3 + 0] = f.vertexIndex(vind[vi + 0]);
+                    buffer[t * 3 + 1] = f.vertexIndex(vind[vi + 1]);
+                    buffer[t * 3 + 2] = f.vertexIndex(vind[vi + 2]);
+                }
+                else {
+                    buffer[0 * numTriangles + t] = f.vertexIndex(vind[vi + 0]);
+                    buffer[1 * numTriangles + t] = f.vertexIndex(vind[vi + 1]);
+                    buffer[2 * numTriangles + t] = f.vertexIndex(vind[vi + 2]);
+                }
+                ++t;
+            }
+        }
+    }
+}
+
 /**
  * @brief Export into a buffer the vertex indices for each edge of a Mesh.
  *