signed distance

Author: fwilliams

cmake/PyiglDownloadExternal.cmake

@@ -27,7 +27,7 @@ endfunction()
 function(pyigl_download_igl)
     pyigl_download_project(libigl
         GIT_REPOSITORY https://github.com/skoch9/libigl.git
-        GIT_TAG        964beea9bfe373f0d398cc78ea3bd044a5c78315
+        GIT_TAG        9b51e2225e44e3f265f4d3179370e27791392b85
     )
 endfunction()
 

src/signed_distance.cpp

@@ -0,0 +1,73 @@
+#include <common.h>
+#include <npe.h>
+#include <typedefs.h>
+
+
+#include <igl/signed_distance.h>
+
+const char *ds_signed_distance = R"igl_Qu8mg5v7(
+SIGNED_DISTANCE computes signed distance to a mesh
+
+
+Parameters
+----------
+     P  #P by 3 list of query point positions
+     V  #V by 3 list of vertex positions
+     F  #F by ss list of triangle indices, ss should be 3 unless sign_type
+     return_normals  (Optional, defaults to False) If set to True, will return pseudonormals of
+                     closest points to each query point in P
+Returns
+-------
+    S  #P list of smallest signed distances
+    I  #P list of facet indices corresponding to smallest distances
+    C  #P by 3 list of closest points
+
+See also
+--------
+
+
+Notes
+-----
+    Known issue: This only computes distances to triangles. So unreferenced
+    vertices and degenerate triangles are ignored.
+
+Examples
+--------
+>>> S, I, C = signed_distance(P, V, F, return_normals=False)
+
+)igl_Qu8mg5v7";
+
+npe_function(signed_distance)
+npe_doc(ds_signed_distance)
+
+npe_arg(p, dense_float, dense_double)
+npe_arg(v, dense_float, dense_double)
+npe_arg(f, dense_int, dense_long, dense_longlong)
+npe_default_arg(return_normals, bool, false)
+
+npe_begin_code()
+    assert_cols_equals(p, 3, "p");
+    assert_nonzero_rows(p, "p");
+    assert_valid_3d_tri_mesh(v, f, "v", "f");
+
+    Eigen::MatrixXd V = v.template cast<double>();
+    Eigen::MatrixXd P = p.template cast<double>();
+    Eigen::MatrixXi F = f.template cast<int>();
+
+    EigenDenseLike<npe_Matrix_p> S;
+    EigenDenseLike<npe_Matrix_f> I;
+    EigenDenseLike<npe_Matrix_v> C;
+    EigenDenseLike<npe_Matrix_v> N;
+
+    if (return_normals) {
+        igl::signed_distance(P, V, F, igl::SIGNED_DISTANCE_TYPE_PSEUDONORMAL, S, I, C, N);
+        return pybind11::make_tuple(npe::move(S), npe::move(I), npe::move(C), npe::move(N));
+    } else {
+        igl::signed_distance(P, V, F, igl::SIGNED_DISTANCE_TYPE_DEFAULT, S, I, C, N);
+        return pybind11::make_tuple(npe::move(S), npe::move(I), npe::move(C));
+    }
+
+npe_end_code()
+
+
+

tests/test_basic.py

@@ -946,6 +946,24 @@ def test_hessian_energy(self):
         self.assertEqual(q.dtype, self.v1.dtype)
         self.assertEqual(q.shape, (self.v1.shape[0], self.v1.shape[0]))
 
+    def test_signed_distance(self):
+        min_v = np.min(self.v1, axis=0)
+        max_v = np.max(self.v1, axis=0)
+        n = 64
+        g = np.mgrid[min_v[0]:max_v[0]:complex(n), min_v[1]:max_v[1]:complex(n), min_v[2]:max_v[2]:complex(n)]
+        p = np.vstack(map(np.ravel, g)).T
+        s, i, c = igl.signed_distance(p, self.v1, self.f1)
+
+        self.assertEqual(s.shape[0], p.shape[0])
+        self.assertEqual(i.shape[0], p.shape[0])
+        self.assertEqual(c.shape, p.shape)
+
+        s, i, c, n = igl.signed_distance(p, self.v1, self.f1, return_normals=True)
+        self.assertEqual(s.shape[0], p.shape[0])
+        self.assertEqual(i.shape[0], p.shape[0])
+        self.assertEqual(c.shape, p.shape)
+        self.assertEqual(n.shape, p.shape)
+
     # def test_offset_surface(self):
     #     sv, sf, gv, side, so = igl.offset_surface(self.v1, self.f1, 1, 10, igl.SIGNED_DISTANCE_TYPE_DEFAULT)
     #     self.assertEqual(sv.dtype, self.v1.type)