Add analytic plane-vertex collision support

cmake/ipc_toolkit/ipc_toolkit_warnings.cmake

@@ -42,6 +42,7 @@ else()
     -Werror=nonnull
     -Werror=init-self
     -Werror=main
+    -Werror=extra-semi
     -Werror=missing-braces
     -Werror=sequence-point
     -Werror=return-type

cmake/recipes/eigen.cmake

@@ -26,6 +26,10 @@ target_include_directories(Eigen3_Eigen SYSTEM INTERFACE
     $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
+set_target_properties(Eigen3_Eigen PROPERTIES
+  INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${eigen_SOURCE_DIR}"
+)
+
 if(EIGEN_DONT_VECTORIZE)
     target_compile_definitions(Eigen3_Eigen INTERFACE EIGEN_DONT_VECTORIZE=1)
 endif()

python/src/CMakeLists.txt

@@ -19,7 +19,6 @@ add_subdirectory(collisions)
 add_subdirectory(distance)
 add_subdirectory(friction)
 add_subdirectory(geometry)
-add_subdirectory(implicits)
 add_subdirectory(math)
 add_subdirectory(ogc)
 add_subdirectory(potentials)

python/src/bindings.cpp

@@ -40,6 +40,7 @@ PYBIND11_MODULE(ipctk, m)
     define_edge_vertex_candidate(m);
     define_face_face_candidate(m);
     define_face_vertex_candidate(m);
+    define_plane_vertex_candidate(m);
     define_vertex_vertex_candidate(m);
 
     // ccd
@@ -72,6 +73,7 @@ PYBIND11_MODULE(ipctk, m)
     define_edge_edge_tangential_collision(m);
     define_edge_vertex_tangential_collision(m);
     define_face_vertex_tangential_collision(m);
+    define_plane_vertex_tangential_collision(m);
     define_vertex_vertex_tangential_collision(m);
 
     // distance
@@ -97,9 +99,6 @@ PYBIND11_MODULE(ipctk, m)
     define_intersection(m);
     define_normal(m);
 
-    // implicits
-    define_plane_implicit(m);
-
     // math
     define_interval(m);
 

python/src/bindings.hpp

@@ -9,7 +9,6 @@
 #include <distance/bindings.hpp>
 #include <friction/bindings.hpp>
 #include <geometry/bindings.hpp>
-#include <implicits/bindings.hpp>
 #include <math/bindings.hpp>
 #include <ogc/bindings.hpp>
 #include <potentials/bindings.hpp>

python/src/candidates/CMakeLists.txt

@@ -5,6 +5,7 @@ set(SOURCES
   edge_vertex.cpp
   face_face.cpp
   face_vertex.cpp
+  plane_vertex.cpp
   vertex_vertex.cpp
   candidates.cpp
 )

python/src/candidates/bindings.hpp

@@ -10,4 +10,5 @@ void define_edge_face_candidate(py::module_& m);
 void define_edge_vertex_candidate(py::module_& m);
 void define_face_face_candidate(py::module_& m);
 void define_face_vertex_candidate(py::module_& m);
+void define_plane_vertex_candidate(py::module_& m);
 void define_vertex_vertex_candidate(py::module_& m);

python/src/candidates/candidates.cpp

@@ -267,5 +267,6 @@ void define_candidates(py::module_& m)
         .def_readwrite("vv_candidates", &Candidates::vv_candidates)
         .def_readwrite("ev_candidates", &Candidates::ev_candidates)
         .def_readwrite("ee_candidates", &Candidates::ee_candidates)
-        .def_readwrite("fv_candidates", &Candidates::fv_candidates);
+        .def_readwrite("fv_candidates", &Candidates::fv_candidates)
+        .def_readwrite("pv_candidates", &Candidates::pv_candidates);
 }

python/src/candidates/plane_vertex.cpp

@@ -0,0 +1,18 @@
+#include <ipc/candidates/plane_vertex.hpp>
+
+#include <common.hpp>
+
+using namespace ipc;
+
+void define_plane_vertex_candidate(py::module_& m)
+{
+    py::class_<PlaneVertexCandidate, CollisionStencil>(
+        m, "PlaneVertexCandidate")
+        .def(
+            py::init<Eigen::Hyperplane<double, 3>, index_t>(), "plane"_a,
+            "vertex_id"_a)
+        .def_readwrite(
+            "plane", &PlaneVertexCandidate::plane, "Plane of the candidate")
+        .def_readwrite(
+            "vertex_id", &PlaneVertexCandidate::vertex_id, "ID of the vertex");
+}

python/src/collision_mesh.cpp

@@ -135,7 +135,25 @@ void define_collision_mesh(py::module_& m)
             )ipc_Qu8mg5v7",
             "i"_a, "j"_a);
 
-    py::class_<CollisionMesh>(m, "CollisionMesh")
+    py::class_<Eigen::Hyperplane<double, 3>>(m, "Hyperplane")
+        .def(py::init<>())
+        .def(py::init<Eigen::Vector3d, Eigen::Vector3d>())
+        .def(
+            "normal",
+            [](const Eigen::Hyperplane<double, 3>& self) {
+                return self.normal();
+            })
+        .def(
+            "offset",
+            [](const Eigen::Hyperplane<double, 3>& self) {
+                return self.offset();
+            })
+        .def("origin", [](const Eigen::Hyperplane<double, 3>& self) {
+            return -self.offset() * self.normal();
+        });
+
+    py::class_<CollisionMesh, std::shared_ptr<CollisionMesh>>(
+        m, "CollisionMesh")
         .def(
             py::init<
                 Eigen::ConstRef<Eigen::MatrixXd>,
@@ -489,5 +507,16 @@ void define_collision_mesh(py::module_& m)
             A function that takes two vertex IDs and returns true if the vertices (and faces or edges containing the vertices) can collide.
 
             By default all primitives can collide with all other primitives.
+            )ipc_Qu8mg5v7")
+        .def_readwrite(
+            "planes", &CollisionMesh::planes,
+            R"ipc_Qu8mg5v7(
+            A vector of planes in the collision mesh.
+
+            Each plane is represented as a `Hyperplane` object (wrapping `Eigen::Hyperplane<double, 3>`).
+            In Python, a `Hyperplane` can be constructed from either:
+                * a normal and a point on the plane: `Hyperplane(normal, point)`, or
+                * a normal and an offset: `Hyperplane(normal, offset)`,
+            where `normal` and `point` are 3D vectors and `offset` is a scalar.
             )ipc_Qu8mg5v7");
 }

python/src/collisions/normal/plane_vertex.cpp

@@ -6,20 +6,10 @@ using namespace ipc;
 
 void define_plane_vertex_normal_collision(py::module_& m)
 {
-    py::class_<PlaneVertexNormalCollision, NormalCollision>(
+    py::class_<
+        PlaneVertexNormalCollision, PlaneVertexCandidate, NormalCollision>(
         m, "PlaneVertexNormalCollision")
         .def(
-            py::init<
-                Eigen::ConstRef<VectorMax3d>, Eigen::ConstRef<VectorMax3d>,
-                const index_t>(),
-            "plane_origin"_a, "plane_normal"_a, "vertex_id"_a)
-        .def_readwrite(
-            "plane_origin", &PlaneVertexNormalCollision::plane_origin,
-            "The plane's origin.")
-        .def_readwrite(
-            "plane_normal", &PlaneVertexNormalCollision::plane_normal,
-            "The plane's normal.")
-        .def_readwrite(
-            "vertex_id", &PlaneVertexNormalCollision::vertex_id,
-            "The vertex's id.");
+            py::init<Eigen::Hyperplane<double, 3>, index_t>(), "plane"_a,
+            "vertex_id"_a);
 }

python/src/collisions/tangential/CMakeLists.txt

@@ -2,6 +2,7 @@ set(SOURCES
   edge_edge.cpp
   edge_vertex.cpp
   face_vertex.cpp
+  plane_vertex.cpp
   tangential_collision.cpp
   tangential_collisions.cpp
   vertex_vertex.cpp

python/src/collisions/tangential/bindings.hpp

@@ -7,4 +7,5 @@ void define_tangential_collisions(py::module_& m);
 void define_edge_edge_tangential_collision(py::module_& m);
 void define_edge_vertex_tangential_collision(py::module_& m);
 void define_face_vertex_tangential_collision(py::module_& m);
+void define_plane_vertex_tangential_collision(py::module_& m);
 void define_vertex_vertex_tangential_collision(py::module_& m);

python/src/collisions/tangential/plane_vertex.cpp

@@ -0,0 +1,18 @@
+#include <ipc/collisions/tangential/plane_vertex.hpp>
+
+#include <common.hpp>
+
+using namespace ipc;
+
+void define_plane_vertex_tangential_collision(py::module_& m)
+{
+    py::class_<
+        PlaneVertexTangentialCollision, PlaneVertexCandidate,
+        TangentialCollision>(m, "PlaneVertexTangentialCollision")
+        .def(py::init<const PlaneVertexNormalCollision&>(), "collision"_a)
+        .def(
+            py::init<
+                const PlaneVertexNormalCollision&,
+                Eigen::ConstRef<VectorMax12d>, const NormalPotential&>(),
+            "collision"_a, "positions"_a, "normal_potential"_a);
+}