Added more viewer options:

Author: rjc8237

include/holonomy/holonomy/core/viewer.h

@@ -26,6 +26,10 @@ std::tuple<Eigen::MatrixXd, Eigen::VectorXd> generate_cone_vertices(
     const std::vector<int>& vtx_reindex,
     const Mesh<Scalar>& m);
 
+std::tuple<Eigen::MatrixXd, Eigen::VectorXd> generate_closed_cone_vertices(
+    const Eigen::MatrixXd& V,
+    const std::vector<Scalar>& Th_hat);
+
 std::tuple<Eigen::MatrixXi, Eigen::MatrixXi> generate_mesh_faces(
     const Mesh<Scalar>& m,
     const std::vector<int>& vtx_reindex);

include/util/util/linear_algebra.h

@@ -110,5 +110,15 @@ void compute_submatrix(
  */
 Matrix2x2 compute_rotation(Scalar theta);
 
+/**
+ * @brief Generate equally spaced values in an interval [a, b]
+ * 
+ * @param a: starting value
+ * @param b: ending value
+ * @param num_steps: number of steps to use in the linspace
+ * @return a vector of equally spaced values between a and b
+ */
+std::vector<Scalar> generate_linspace(Scalar a, Scalar b, int num_steps);
+
 
 } // namespace Penner

include/util/util/vf_mesh.h

@@ -55,6 +55,18 @@ void remove_unreferenced(
     Eigen::MatrixXi& FN,
     std::vector<int>& new_to_old_map);
 
+/// Given a mesh with a parametrization, generate the 3D seam polylines
+///
+/// @param[in] V: mesh vertices
+/// @param[in] F: mesh faces
+/// @param[in] FT: parametrization faces
+/// @return seam vertices
+/// @return seam edges
+std::tuple<Eigen::MatrixXd, Eigen::MatrixXi> generate_seams(
+    const Eigen::MatrixXd& V,
+    const Eigen::MatrixXi& F,
+    const Eigen::MatrixXi& FT);
+
 /// Given a mesh with a parametrization, cut the mesh along the parametrization seams to
 /// create a vertex set corresponding to the faces of the uv domain.
 ///

src/holonomy/core/viewer.cpp

@@ -325,6 +325,32 @@ std::tuple<Eigen::MatrixXd, Eigen::VectorXd> generate_cone_vertices(
     return std::make_tuple(cone_positions, cone_values);
 }
 
+std::tuple<Eigen::MatrixXd, Eigen::VectorXd> generate_closed_cone_vertices(
+    const Eigen::MatrixXd& V,
+    const std::vector<Scalar>& Th_hat)
+{
+    // get cone indices
+    int num_vertices = V.rows();
+    std::vector<int> cone_indices;
+    cone_indices.reserve(num_vertices);
+    for (int vi = 0; vi < num_vertices; ++vi) {
+        if (float_equal(Th_hat[vi], 2 * M_PI)) continue;
+        cone_indices.push_back(vi);
+    }
+
+    // build cone positions and values
+    int num_cones = cone_indices.size();
+    Eigen::MatrixXd cone_positions(num_cones, 3);
+    Eigen::VectorXd cone_values(num_cones);
+    for (int i = 0; i < num_cones; ++i) {
+        int vi = cone_indices[i];
+        cone_positions.row(i) = V.row(vi);
+        cone_values[i] = (double)(Th_hat[vi]) - (2 * M_PI);
+    }
+
+    return std::make_tuple(cone_positions, cone_values);
+}
+
 Eigen::MatrixXd generate_subset_vertices(
     const Eigen::MatrixXd& V,
     const std::vector<int>& vertex_indices)

src/util/linear_algebra.cpp

@@ -185,5 +185,22 @@ MatrixX solve_linear_system(const MatrixX& A, const MatrixX&B)
     return solver.solve(B);
 }
 
+std::vector<Scalar> generate_linspace(Scalar a, Scalar b, int num_steps)
+{
+    std::vector<Scalar> linspace(num_steps + 1);
+
+    // iteratively compute linspace
+    Scalar delta = (b - a) / static_cast<Scalar>(num_steps);
+    linspace[0] = a;
+    for (int i = 0; i < num_steps; ++i)
+    {
+        linspace[i + 1] = linspace[i] + delta;
+    }
+
+    // clamp last value exactly to b
+    linspace.back() = b;
+
+    return linspace;
+}
 
 } // namespace Penner

src/util/vf_mesh.cpp

@@ -34,6 +34,7 @@
 
 #include <igl/facet_components.h>
 #include <igl/boundary_facets.h>
+#include <igl/remove_unreferenced.h>
 #include <igl/unique.h>
 #include <igl/per_vertex_normals.h>
 
@@ -52,11 +53,12 @@ void remove_unreferenced(
     std::vector<int>& new_to_old_map)
 {
     int num_faces = F.rows();
+    int cols = F.cols();
 
     // Iterate over faces to find all referenced vertices in sorted order
     std::vector<int> referenced_vertices;
     for (int fi = 0; fi < num_faces; ++fi) {
-        for (int j = 0; j < 3; ++j) {
+        for (int j = 0; j < cols; ++j) {
             int vk = F(fi, j);
             referenced_vertices.push_back(vk);
         }
@@ -78,9 +80,9 @@ void remove_unreferenced(
     }
 
     // Reindex the vertices in the face list
-    FN.resize(num_faces, 3);
+    FN.resize(num_faces, cols);
     for (int fi = 0; fi < num_faces; ++fi) {
-        for (int j = 0; j < 3; ++j) {
+        for (int j = 0; j < cols; ++j) {
             int vk = F(fi, j);
             int k = old_to_new_map[vk];
             FN(fi, j) = k;
@@ -115,6 +117,40 @@ void cut_mesh_along_parametrization_seams(
     }
 }
 
+std::tuple<Eigen::MatrixXd, Eigen::MatrixXi> generate_seams(
+    const Eigen::MatrixXd& V,
+    const Eigen::MatrixXi& F,
+    const Eigen::MatrixXi& FT)
+{
+    // get boundary edges of the uv map
+    Eigen::MatrixXi uv_edges;
+    Eigen::VectorXi J, K;
+    igl::boundary_facets(FT, uv_edges, J, K);
+
+    // get 3D vertices on seam
+    int num_seam_edges = J.size();
+    Eigen::MatrixXi edges(num_seam_edges, 2);
+    for (int i = 0; i < num_seam_edges; ++i)
+    {
+        edges(i, 0) = F(J[i], (K[i] + 1)%3);
+        edges(i, 1) = F(J[i], (K[i] + 2)%3);
+    }
+
+    // reindex to remove redundant
+    Eigen::MatrixXi seam_edges;
+    std::vector<int> new_to_old_map;
+    remove_unreferenced(edges, seam_edges, new_to_old_map);
+
+    // get new vertices
+    int num_seam_vertices = new_to_old_map.size();
+    Eigen::MatrixXd seam_vertices(num_seam_vertices, 3);
+    for (int i = 0; i < num_seam_vertices; ++i) {
+        seam_vertices.row(i) = V.row(new_to_old_map[i]);
+    }
+
+    return std::make_tuple(seam_vertices, seam_edges);
+}
+
 std::vector<int> find_boundary_vertices(const Eigen::MatrixXi& F)
 {
     // Get the boundary edges