Add MinGap function

.vscode/settings.json

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

bindings/c/include/manifoldc.h

@@ -190,6 +190,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

@@ -550,6 +550,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

@@ -111,6 +111,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

@@ -165,6 +165,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

@@ -845,6 +845,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,55 @@ 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> faceBox;
+  Vec<uint32_t> faceMorton;
+
+  this->GetFaceBoxMorton(faceBox, faceMorton);
+  this->SortFaceBoxMorton(faceBox, faceMorton);
+
+  transform(autoPolicy(faceBox.size()), faceBox.begin(), faceBox.end(),
+            faceBox.begin(), [searchLength](const Box& box) {
+              return Box(box.min - glm::vec3(searchLength),
+                         box.max + glm::vec3(searchLength));
+            });
+
+  Vec<Box> faceBoxOther;
+  Vec<uint32_t> faceMortonOther;
+
+  other.GetFaceBoxMorton(faceBoxOther, faceMortonOther);
+  other.SortFaceBoxMorton(faceBoxOther, faceMortonOther);
+
+  Collider collider{faceBox, faceMorton};
+
+  SparseIndices collisions = collider.Collisions(faceBoxOther.cview());
+
+  float minDistanceSquared = searchLength * searchLength;
+
+  for (int i = 0; i < collisions.size(); ++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];
+    }
+
+    float distanceSquared = DistanceTriangleTriangleSquared(p, q);
+
+    minDistanceSquared = std::min(minDistanceSquared, distanceSquared);
+  }
+
+  return sqrt(minDistanceSquared);
+};
+
 }  // namespace manifold

src/manifold/src/impl.h

@@ -81,6 +81,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(); }
@@ -111,6 +112,8 @@ struct Manifold::Impl {
   void CompactProps();
   void GetFaceBoxMorton(Vec<Box>& faceBox, Vec<uint32_t>& faceMorton) const;
   void SortFaces(Vec<Box>& faceBox, Vec<uint32_t>& faceMorton);
+  void SortFaceBoxMorton(Vec<Box>& faceBox, Vec<uint32_t>& faceMorton) const;
+
   void GatherFaces(const Vec<int>& faceNew2Old);
   void GatherFaces(const Impl& old, const Vec<int>& faceNew2Old);
 

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;
@@ -926,4 +927,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/manifold/src/sort.cpp

@@ -418,6 +418,27 @@ void Manifold::Impl::SortFaces(Vec<Box>& faceBox, Vec<uint32_t>& faceMorton) {
   GatherFaces(faceNew2Old);
 }
 
+/**
+ * Sorts the bounding box and Morton code arrays based on the Morton codes.
+ * Leaves the original manifold untouched.
+ */
+void Manifold::Impl::SortFaceBoxMorton(Vec<Box>& faceBox,
+                                       Vec<uint32_t>& faceMorton) const {
+  ZoneScoped;
+  Vec<int> faceNew2Old(NumTri());
+  auto policy = autoPolicy(faceNew2Old.size());
+  sequence(policy, faceNew2Old.begin(), faceNew2Old.end());
+
+  stable_sort(policy, zip(faceMorton.begin(), faceNew2Old.begin()),
+              zip(faceMorton.end(), faceNew2Old.end()),
+              [](const thrust::tuple<uint32_t, int>& a,
+                 const thrust::tuple<uint32_t, int>& b) {
+                return thrust::get<0>(a) < thrust::get<0>(b);
+              });
+
+  Permute(faceBox, faceNew2Old);
+}
+
 /**
  * Creates the halfedge_ vector for this manifold by copying a set of faces from
  * another manifold, given by oldHalfedge. Input faceNew2Old defines the old

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})