orientable flag

Author: Huangzizhou

python/src/collision_mesh.cpp

@@ -153,7 +153,7 @@ void define_collision_mesh(py::module_& m)
             py::arg("displacement_map") = Eigen::SparseMatrix<double>())
         .def(
             py::init<
-                const std::vector<bool>&, Eigen::ConstRef<Eigen::MatrixXd>,
+                const std::vector<bool>&, const std::vector<bool>&, Eigen::ConstRef<Eigen::MatrixXd>,
                 Eigen::ConstRef<Eigen::MatrixXi>,
                 Eigen::ConstRef<Eigen::MatrixXi>,
                 const Eigen::SparseMatrix<double>&>(),
@@ -162,12 +162,13 @@ void define_collision_mesh(py::module_& m)
 
             Parameters:
                 include_vertex: Vector of bools indicating whether each vertex should be included in the collision mesh.
+                orient_vertex: Vector of bools indicating whether each vertex is orientable.
                 full_rest_positions: The vertices of the full mesh at rest (#V × dim).
                 edges: The edges of the collision mesh indexed into the full mesh vertices (#E × 2).
                 faces: The faces of the collision mesh indexed into the full mesh vertices (#F × 3).
                 displacement_map: The displacement mapping from displacements on the full mesh to the collision mesh.
             )ipc_Qu8mg5v7",
-            py::arg("include_vertex"), py::arg("full_rest_positions"),
+            py::arg("include_vertex"), py::arg("orient_vertex"), py::arg("full_rest_positions"),
             py::arg("edges") = Eigen::MatrixXi(),
             py::arg("faces") = Eigen::MatrixXi(),
             py::arg("displacement_map") = Eigen::SparseMatrix<double>())

src/ipc/collision_mesh.cpp

@@ -21,6 +21,7 @@ CollisionMesh::CollisionMesh(
     const Eigen::SparseMatrix<double>& displacement_map)
     : CollisionMesh(
           std::vector<bool>(rest_positions.rows(), true),
+          std::vector<bool>(rest_positions.rows(), false),
           rest_positions,
           edges,
           faces,
@@ -30,6 +31,7 @@ CollisionMesh::CollisionMesh(
 
 CollisionMesh::CollisionMesh(
     const std::vector<bool>& include_vertex,
+    const std::vector<bool>& orient_vertex,
     Eigen::ConstRef<Eigen::MatrixXd> full_rest_positions,
     Eigen::ConstRef<Eigen::MatrixXi> edges,
     Eigen::ConstRef<Eigen::MatrixXi> faces,
@@ -90,6 +92,12 @@ CollisionMesh::CollisionMesh(
     m_rest_positions = m_select_vertices * full_rest_positions;
     // m_rest_positions = vertices(full_rest_positions);
 
+    assert(orient_vertex.size() == full_rest_positions.rows());
+    m_is_orient_vertex.assign(m_rest_positions.rows(), false);
+    for (int i = 0; i < m_is_orient_vertex.size(); i++) {
+        m_is_orient_vertex[i] = orient_vertex[m_vertex_to_full_vertex[i]];
+    }
+
     // Map faces and edges to only included vertices
     if (!include_all_vertices) {
         for (int i = 0; i < m_edges.rows(); i++) {

src/ipc/collision_mesh.hpp

@@ -26,12 +26,14 @@ class CollisionMesh {
 
     /// @brief Construct a new Collision Mesh object from a full mesh vertices.
     /// @param include_vertex Vector of bools indicating whether each vertex should be included in the collision mesh.
+    /// @param orient_vertex Vector of bools indicating whether each vertex is orientable.
     /// @param full_rest_positions The vertices of the full mesh at rest (|V| × dim).
     /// @param edges The edges of the collision mesh indexed into the full mesh vertices (|E| × 2).
     /// @param faces The faces of the collision mesh indexed into the full mesh vertices (|F| × 3).
     /// @param displacement_map The displacement mapping from displacements on the full mesh to the collision mesh.
     CollisionMesh(
         const std::vector<bool>& include_vertex,
+        const std::vector<bool>& orient_vertex,
         Eigen::ConstRef<Eigen::MatrixXd> full_rest_positions,
         Eigen::ConstRef<Eigen::MatrixXi> edges = Eigen::MatrixXi(),
         Eigen::ConstRef<Eigen::MatrixXi> faces = Eigen::MatrixXi(),
@@ -49,7 +51,7 @@ class CollisionMesh {
         Eigen::ConstRef<Eigen::MatrixXi> faces = Eigen::MatrixXi())
     {
         return CollisionMesh(
-            construct_is_on_surface(full_rest_positions.rows(), edges),
+            construct_is_on_surface(full_rest_positions.rows(), edges), std::vector<bool>(full_rest_positions.rows(), false),
             full_rest_positions, edges, faces);
     }
 
@@ -99,6 +101,8 @@ class CollisionMesh {
 
     bool is_codim_vertex(const long& v) const { return m_is_codim_vertex[v]; }
 
+    bool is_orient_vertex(const long& v) const { return m_is_orient_vertex[v]; }
+
     /// @brief Get the indices of codimensional edges of the collision mesh (#CE x 1).
     const Eigen::VectorXi& codim_edges() const { return m_codim_edges; }
 
@@ -322,6 +326,8 @@ class CollisionMesh {
     Eigen::MatrixXd m_rest_positions;
     /// @brief The mask of codimensional vertices (#V).
     std::vector<bool> m_is_codim_vertex;
+    /// @brief The mask of orientable vertices (#V).
+    std::vector<bool> m_is_orient_vertex;
     /// @brief The indices of codimensional vertices (#CV x 1).
     Eigen::VectorXi m_codim_vertices;
     /// @brief The mask of codimensional edges (#E).

src/ipc/smooth_contact/primitives/edge2.cpp

@@ -11,7 +11,7 @@ Edge2::Edge2(
 {
     _vert_ids = { { mesh.edges()(id, 0), mesh.edges()(id, 1) } };
 
-    is_active_ = mesh.is_codim_edge(id)
+    is_active_ = (mesh.is_orient_vertex(_vert_ids[0]) && mesh.is_orient_vertex(_vert_ids[1]))
         || Math<double>::cross2(
                d, vertices.row(_vert_ids[1]) - vertices.row(_vert_ids[0]))
             > 0;

src/ipc/smooth_contact/primitives/edge3.cpp

@@ -375,7 +375,7 @@ Edge3::Edge3(
     const ParameterType& param)
     : Primitive(id, param)
 {
-    orientable = !mesh.is_codim_edge(id);
+    orientable = (mesh.is_orient_vertex(mesh.edges()(id, 0)) && mesh.is_orient_vertex(mesh.edges()(id, 0)));
 
     std::array<long, 4> neighbors { { -1, -1, -1, -1 } };
     {

src/ipc/smooth_contact/primitives/face.cpp

@@ -33,9 +33,9 @@ Face::Face(
     Vector3d a = vertices.row(_vert_ids[1]) - vertices.row(_vert_ids[0]);
     Vector3d b = vertices.row(_vert_ids[2]) - vertices.row(_vert_ids[0]);
 
-    bool orientable = !mesh.is_codim_vertex(_vert_ids[0])
-        && !mesh.is_codim_vertex(_vert_ids[1])
-        && !mesh.is_codim_vertex(_vert_ids[2]);
+    bool orientable = mesh.is_orient_vertex(_vert_ids[0])
+        && mesh.is_orient_vertex(_vert_ids[1])
+        && mesh.is_orient_vertex(_vert_ids[2]);
     is_active_ = !orientable || a.cross(b).dot(d) > 0;
 }
 int Face::n_vertices() const { return n_face_neighbors_3d; }

src/ipc/smooth_contact/primitives/point2.cpp

@@ -86,7 +86,7 @@ Point2::Point2(
     const ParameterType& param)
     : Primitive(id, param)
 {
-    orientable = !mesh.is_codim_vertex(id);
+    orientable = mesh.is_orient_vertex(id);
     auto neighbor_verts = mesh.find_vertex_adjacent_vertices(id);
     has_neighbor_1 = neighbor_verts[0] >= 0;
     has_neighbor_2 = neighbor_verts[1] >= 0;

src/ipc/smooth_contact/primitives/point3.cpp

@@ -13,7 +13,7 @@ Point3::Point3(
     : Primitive(id, param)
 {
     orientable =
-        !mesh.is_codim_vertex(id) && mesh.vertices_to_faces()[id].size() > 0;
+        mesh.is_orient_vertex(id) && mesh.vertices_to_faces()[id].size() > 0;
 
     // Build index mapping from all vertices to one-ring neighbors
     {

tests/src/tests/friction/test_force_jacobian.cpp

@@ -318,7 +318,7 @@ TEST_CASE(
 
     std::vector<bool> is_on_surface =
         CollisionMesh::construct_is_on_surface(X.rows(), E);
-    CollisionMesh mesh(is_on_surface, X, E, F);
+    CollisionMesh mesh(is_on_surface, std::vector<bool>(X.rows(), false), X, E, F);
     mesh.init_area_jacobians();
 
     X = mesh.vertices(X);