Add MinGap function (#765)

* Add tests for intersection

* Add POC MinGap implementation and tests

* Add tests where closest point falls on the triangle's face or on one of the edges

* Create TriangleDistance declaration

* Delete intersect tests

* Add stub MinGap definition

* Add triangle distance impl

* Add comments

* Fix tests

* Fix build

* Use collider

* Collider exploration

* Collider impl, cleanup

* Use par transform

* Revert settings.json, add comments

* Add comments

* Move tri_dist to utils

* Delete unnecessary include

* Create lambda for bounding box expansion

* Move duplicate logic to lambda

* Cleanup

* Use floats instead of doubles, use glm::clamp instead of own implementation

* User ternaries

* Remove DistanceTriangleTriangleSquared out params

* Move MinGap impl to Impl

* Use std::array instead of C-style

* Modify MinGap test cases for clarity, add overlapping tri_dist test

* Add c, wasm, python bindings

* Fix formatting

* Clean up comments

* Test whether faceboxes need to be sorted

* Add min_gap example to all_apis.py

* Fix formatting

* Clean up python binding

* Fix edge to edge test case

* Test BVH culling

* Remove sorting of other manifold's boxes

* Use collider_ member, remove sorting

* Move tests to manifold_test.cpp

* Remove whitespace

* Rename some tests for clarity

* Remove redundant test, modify test for edge to edge test for clarity

* Fix comments

* Parallelize narrow phase

* Reduce sphere res in test case to not cause out of memory error

* Add complex test case

* Remove unnecessary cast

* Refactor functor is lambda

Author: mleleszi

.vscode/settings.json

@@ -150,4 +150,4 @@
   },
   "python.formatting.provider": "none",
   "clang-format.executable": "clang-format",
-}
+}

bindings/c/include/manifoldc.h

@@ -192,6 +192,8 @@ ManifoldManifold *manifold_set_properties(
     void (*fun)(float *new_prop, ManifoldVec3 position, const float *old_prop));
 ManifoldManifold *manifold_calculate_curvature(void *mem, ManifoldManifold *m,
                                                int gaussian_idx, int mean_idx);
+float manifold_min_gap(ManifoldManifold *m, ManifoldManifold *other,
+                       float searchLength);
 ManifoldManifold *manifold_calculate_normals(void *mem, ManifoldManifold *m,
                                              int normal_idx,
                                              int min_sharp_angle);

bindings/c/manifoldc.cpp

@@ -556,6 +556,11 @@ ManifoldManifold *manifold_calculate_curvature(void *mem, ManifoldManifold *m,
   return to_c(new (mem) Manifold(man));
 }
 
+float manifold_min_gap(ManifoldManifold *m, ManifoldManifold *other,
+                       float searchLength) {
+  return from_c(m)->MinGap(*from_c(other), searchLength);
+}
+
 ManifoldManifold *manifold_calculate_normals(void *mem, ManifoldManifold *m,
                                              int normal_idx,
                                              int min_sharp_angle) {

bindings/python/examples/all_apis.py

@@ -112,6 +112,9 @@ def all_manifold():
     m = m.trim_by_plane((0, 0, 1), 0)
     m = m.warp(lambda p: (p[0] + 1, p[1] / 2, p[2] * 2))
     m = m.warp_batch(lambda ps: ps * [1, 0.5, 2] + [1, 0, 0])
+    m = Manifold.cube()
+    m2 = Manifold.cube().translate([2, 0, 0])
+    d = m.min_gap(m2, 2)
 
 
 def run():

bindings/python/manifold3d.cpp

@@ -315,6 +315,10 @@ NB_MODULE(manifold3d, m) {
       .def("calculate_curvature", &Manifold::CalculateCurvature,
            nb::arg("gaussian_idx"), nb::arg("mean_idx"),
            manifold__calculate_curvature__gaussian_idx__mean_idx)
+      .def("min_gap", &Manifold::MinGap, nb::arg("other"),
+           nb::arg("search_length"),
+           "Returns the minimum gap between two manifolds."
+           "Returns a float between 0 and searchLength.")
       .def("calculate_normals", &Manifold::CalculateNormals,
            nb::arg("normal_idx"), nb::arg("min_sharp_angle") = 60,
            manifold__calculate_normals__normal_idx__min_sharp_angle)

bindings/wasm/bindings.cpp

@@ -166,6 +166,7 @@ EMSCRIPTEN_BINDINGS(whatever) {
       .function("precision", &Manifold::Precision)
       .function("genus", &Manifold::Genus)
       .function("getProperties", &Manifold::GetProperties)
+      .function("minGap", &Manifold::MinGap)
       .function("calculateCurvature", &Manifold::CalculateCurvature)
       .function("calculateNormals", &Manifold::CalculateNormals)
       .function("originalID", &Manifold::OriginalID)

bindings/wasm/manifold-encapsulated-types.d.ts

@@ -858,6 +858,13 @@ export class Manifold {
    */
   getProperties(): Properties;
 
+
+  /*
+   * Returns the minimum gap between two manifolds. Returns a float between
+   * 0 and searchLength.
+   */
+  minGap(other: Manifold, searchLength: number): number;
+
   // Export
 
   /**

src/manifold/include/manifold.h

@@ -218,6 +218,7 @@ class Manifold {
   float Precision() const;
   int Genus() const;
   Properties GetProperties() const;
+  float MinGap(const Manifold& other, float searchLength) const;
   ///@}
 
   /** @name Mesh ID

src/manifold/src/impl.cpp

@@ -23,6 +23,7 @@
 #include "mesh_fixes.h"
 #include "par.h"
 #include "svd.h"
+#include "tri_dist.h"
 
 namespace {
 using namespace manifold;
@@ -902,4 +903,48 @@ SparseIndices Manifold::Impl::VertexCollisionsZ(
   else
     return collider_.Collisions<false, false>(vertsIn);
 }
+
+/*
+ * Returns the minimum gap between two manifolds. Returns a float between
+ * 0 and searchLength.
+ */
+float Manifold::Impl::MinGap(const Manifold::Impl& other,
+                             float searchLength) const {
+  ZoneScoped;
+  Vec<Box> faceBoxOther;
+  Vec<uint32_t> faceMortonOther;
+
+  other.GetFaceBoxMorton(faceBoxOther, faceMortonOther);
+
+  transform(autoPolicy(faceBoxOther.size()), faceBoxOther.begin(),
+            faceBoxOther.end(), faceBoxOther.begin(),
+            [searchLength](const Box& box) {
+              return Box(box.min - glm::vec3(searchLength),
+                         box.max + glm::vec3(searchLength));
+            });
+
+  SparseIndices collisions = collider_.Collisions(faceBoxOther.cview());
+
+  float minDistanceSquared = transform_reduce<float>(
+      autoPolicy(collisions.size()), thrust::counting_iterator<int>(0),
+      thrust::counting_iterator<int>(collisions.size()),
+      [&collisions, this, &other](int i) {
+        const int tri = collisions.Get(i, 1);
+        const int triOther = collisions.Get(i, 0);
+
+        std::array<glm::vec3, 3> p;
+        std::array<glm::vec3, 3> q;
+
+        for (const int j : {0, 1, 2}) {
+          p[j] = vertPos_[halfedge_[3 * tri + j].startVert];
+          q[j] = other.vertPos_[other.halfedge_[3 * triOther + j].startVert];
+        }
+
+        return DistanceTriangleTriangleSquared(p, q);
+      },
+      searchLength * searchLength, thrust::minimum<float>());
+
+  return sqrt(minDistanceSquared);
+};
+
 }  // namespace manifold

src/manifold/src/impl.h

@@ -104,6 +104,7 @@ struct Manifold::Impl {
   SparseIndices EdgeCollisions(const Impl& B, bool inverted = false) const;
   SparseIndices VertexCollisionsZ(VecView<const glm::vec3> vertsIn,
                                   bool inverted = false) const;
+  float MinGap(const Impl& other, float searchLength) const;
 
   bool IsEmpty() const { return NumVert() == 0; }
   int NumVert() const { return vertPos_.size(); }

src/manifold/src/manifold.cpp

@@ -21,6 +21,7 @@
 #include "csg_tree.h"
 #include "impl.h"
 #include "par.h"
+#include "tri_dist.h"
 
 namespace {
 using namespace manifold;
@@ -945,4 +946,21 @@ Manifold Manifold::Hull() const { return Hull(GetMesh().vertPos); }
 Manifold Manifold::Hull(const std::vector<Manifold>& manifolds) {
   return Compose(manifolds).Hull();
 }
+
+/**
+ * Returns the minimum gap between two manifolds. Returns a float between
+ * 0 and searchLength.
+ *
+ * @param other The other manifold to compute the minimum gap to.
+ * @param searchLength The maximum distance to search for a minimum gap.
+ */
+float Manifold::MinGap(const Manifold& other, float searchLength) const {
+  auto intersect = *this ^ other;
+  auto prop = intersect.GetProperties();
+
+  if (prop.volume != 0) return 0.0f;
+
+  return GetCsgLeafNode().GetImpl()->MinGap(*other.GetCsgLeafNode().GetImpl(),
+                                            searchLength);
+}
 }  // namespace manifold

src/utilities/CMakeLists.txt

@@ -83,4 +83,4 @@ endif()
 target_compile_features(${PROJECT_NAME} INTERFACE cxx_std_17)
 
 install(TARGETS ${PROJECT_NAME} EXPORT manifoldTargets)
-install(FILES include/public.h include/vec_view.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${CMAKE_PROJECT_NAME})
+install(FILES include/public.h include/vec_view.h include/tri_dist.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${CMAKE_PROJECT_NAME})