Integrate SimpleBVH Broad Phase (#75)

Author: zfergus

.gitignore

@@ -265,3 +265,4 @@ tests/src/tests/config.hpp
 docs/_doxygen
 
 notebooks/*.[ch]pp
+tests/data/cloth_ball_bf_ccd_candidated.json

CMakeLists.txt

@@ -149,6 +149,10 @@ else()
   target_link_libraries(ipc_toolkit PUBLIC evouga::ccd)
 endif()
 
+# SimpleBVH
+include(simple_bvh)
+target_link_libraries(ipc_toolkit PUBLIC simple_bvh::simple_bvh)
+
 # Logger
 include(spdlog)
 target_link_libraries(ipc_toolkit PUBLIC spdlog::spdlog)

README.md

@@ -63,6 +63,7 @@ The following libraries are used in this project:
 * [libigl](https://github.com/libigl/libigl): basic geometry functions and predicates
 * [TBB](https://github.com/wjakob/tbb): parallelization
 * [Tight-Inclusion](https://github.com/Continuous-Collision-Detection/Tight-Inclusion): correct (conservative) CCD
+* [SimpleBVH](https://github.com/ipc-sim/SimpleBVH): a simple bounding volume hierarchy data structure
 * [spdlog](https://github.com/gabime/spdlog): logging information
 
 #### Optional

cmake/recipes/simple_bvh.cmake

@@ -0,0 +1,11 @@
+# BVH
+# License: MIT
+
+if(TARGET simple_bvh::simple_bvh)
+    return()
+endif()
+
+message(STATUS "Third-party: creating target 'simple_bvh::simple_bvh'")
+
+include(CPM)
+CPMAddPackage("gh:ipc-sim/SimpleBVH#2117898eb366647d6aacdb82860b9315fb42d6ad")

docs/source/cpp-api/broad_phase.rst

@@ -25,6 +25,11 @@ Spatial Hash
 
 .. doxygenclass:: ipc::SpatialHash
 
+BVH
+---
+
+.. doxygenclass:: ipc::BVH
+
 Sweep and Tiniest Queue
 -----------------------
 

docs/source/python-api/broad_phase.rst

@@ -35,6 +35,13 @@ Spatial Hash
 
     .. autoclasstoc::
 
+BVH
+---
+
+.. autoclass:: ipctk.BVH
+
+    .. autoclasstoc::
+
 Sweep and Tiniest Queue
 -----------------------
 

python/CMakeLists.txt

@@ -11,6 +11,7 @@ pybind11_add_module(ipctk
   src/broad_phase/aabb.cpp
   src/broad_phase/broad_phase.cpp
   src/broad_phase/brute_force.cpp
+  src/broad_phase/bvh.cpp
   src/broad_phase/hash_grid.cpp
   src/broad_phase/spatial_hash.cpp
   src/broad_phase/sweep_and_tiniest_queue.cpp

python/src/bindings.cpp

@@ -18,6 +18,7 @@ PYBIND11_MODULE(ipctk, m)
     define_aabb(m);
     define_broad_phase(m);
     define_brute_force(m);
+    define_bvh(m);
     define_hash_grid(m);
     define_spatial_hash(m);
     define_sweep(m);

python/src/broad_phase/bindings.hpp

@@ -7,6 +7,7 @@ namespace py = pybind11;
 void define_aabb(py::module_& m);
 void define_broad_phase(py::module_& m);
 void define_brute_force(py::module_& m);
+void define_bvh(py::module_& m);
 void define_hash_grid(py::module_& m);
 void define_spatial_hash(py::module_& m);
 void define_sweep(py::module_& m);

python/src/broad_phase/bvh.cpp

@@ -0,0 +1,114 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/iostream.h>
+#include <pybind11/operators.h>
+
+#include <ipc/broad_phase/bvh.hpp>
+
+namespace py = pybind11;
+using namespace ipc;
+
+void define_bvh(py::module_& m)
+{
+    py::class_<BVH, BroadPhase>(m, "BVH")
+        .def(
+            "build",
+            py::overload_cast<
+                const Eigen::MatrixXd&, const Eigen::MatrixXi&,
+                const Eigen::MatrixXi&, const double>(&BVH::build),
+            R"ipc_Qu8mg5v7(
+            Build the broad phase for static collision detection.
+
+            Parameters:
+                V0: Positions of the vertices.
+                E: Edges of the mesh.
+                F: Faces of the mesh.
+                inflation_radius: Radius of inflation around all elements.
+            )ipc_Qu8mg5v7",
+            py::arg("V"), py::arg("E"), py::arg("F"),
+            py::arg("inflation_radius") = 0)
+        .def(
+            "build",
+            py::overload_cast<
+                const Eigen::MatrixXd&, const Eigen::MatrixXd&,
+                const Eigen::MatrixXi&, const Eigen::MatrixXi&, const double>(
+                &BVH::build),
+            R"ipc_Qu8mg5v7(
+            Build the broad phase for continuous collision detection.
+
+            Parameters:
+                V0: Starting positions of the vertices.
+                V1: Ending positions of the vertices.
+                E: Edges of the mesh.
+                F: Faces of the mesh.
+                inflation_radius: Radius of inflation around all elements.
+            )ipc_Qu8mg5v7",
+            py::arg("V0"), py::arg("V1"), py::arg("E"), py::arg("F"),
+            py::arg("inflation_radius") = 0)
+        .def("clear", &BVH::clear, "Clear any built data.")
+        .def(
+            "detect_vertex_vertex_candidates",
+            [](BVH& self) {
+                std::vector<VertexVertexCandidate> candidates;
+                self.detect_vertex_vertex_candidates(candidates);
+                return candidates;
+            },
+            R"ipc_Qu8mg5v7(
+            Find the candidate vertex-vertex collisions.
+
+            Returns:
+                The candidate vertex-vertex collisions.
+            )ipc_Qu8mg5v7")
+        .def(
+            "detect_edge_vertex_candidates",
+            [](BVH& self) {
+                std::vector<EdgeVertexCandidate> candidates;
+                self.detect_edge_vertex_candidates(candidates);
+                return candidates;
+            },
+            R"ipc_Qu8mg5v7(
+            Find the candidate edge-vertex collisions.
+
+            Returns:
+                The candidate edge-vertex collisions.
+            )ipc_Qu8mg5v7")
+        .def(
+            "detect_edge_edge_candidates",
+            [](BVH& self) {
+                std::vector<EdgeEdgeCandidate> candidates;
+                self.detect_edge_edge_candidates(candidates);
+                return candidates;
+            },
+            R"ipc_Qu8mg5v7(
+            Find the candidate edge-edge collisions.
+
+            Returns:
+                The candidate edge-edge collisions.
+            )ipc_Qu8mg5v7")
+        .def(
+            "detect_face_vertex_candidates",
+            [](BVH& self) {
+                std::vector<FaceVertexCandidate> candidates;
+                self.detect_face_vertex_candidates(candidates);
+                return candidates;
+            },
+            R"ipc_Qu8mg5v7(
+            Find the candidate face-vertex collisions.
+
+            Returns:
+                The candidate face-vertex collisions.
+            )ipc_Qu8mg5v7")
+        .def(
+            "detect_edge_face_candidates",
+            [](BVH& self) {
+                std::vector<EdgeFaceCandidate> candidates;
+                self.detect_edge_face_candidates(candidates);
+                return candidates;
+            },
+            R"ipc_Qu8mg5v7(
+            Find the candidate edge-face intersections.
+
+            Returns:
+                The candidate edge-face intersections.
+            )ipc_Qu8mg5v7");
+}