libigl 2.6.1__tar.gz → 2.6.2.dev0__tar.gz

{libigl-2.6.1 → libigl-2.6.2.dev0}/CMakeLists.txt

@@ -45,7 +45,7 @@ option(LIBIGL_RESTRICTED_TRIANGLE  "Build target igl_restricted::triangle" ON)
 FetchContent_Declare(
   libigl
   GIT_REPOSITORY https://github.com/libigl/libigl.git
-  GIT_TAG v2.6.0
+  GIT_TAG 678e1fff76815e0c4c5d1f025ee2129181cc7d86
 )
 FetchContent_MakeAvailable(libigl)
 

{libigl-2.6.1 → libigl-2.6.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libigl
-Version: 2.6.1
+Version: 2.6.2.dev0
 Summary: libigl: A simple C++ geometry processing library
 Author-Email: Alec Jacobson <alecjacobson@gmail.com>
 Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
@@ -12,7 +12,6 @@ Description-Content-Type: text/markdown
 
 # libigl Python Bindings
 [![PyPI version](https://badge.fury.io/py/libigl.svg)](https://pypi.org/project/libigl/)
-[![buildwheels](https://github.com/libigl/libigl-python-bindings/actions/workflows/wheels.yml/badge.svg)](https://github.com/libigl/libigl-python-bindings/actions/workflows/wheels.yml?query=branch%3Amain)
 
 This repository contains the source code for the python bindings for the C++
 [libigl](https://github.com/libigl/libigl) library written using

{libigl-2.6.1 → libigl-2.6.2.dev0}/README.md

@@ -1,6 +1,5 @@
 # libigl Python Bindings
 [![PyPI version](https://badge.fury.io/py/libigl.svg)](https://pypi.org/project/libigl/)
-[![buildwheels](https://github.com/libigl/libigl-python-bindings/actions/workflows/wheels.yml/badge.svg)](https://github.com/libigl/libigl-python-bindings/actions/workflows/wheels.yml?query=branch%3Amain)
 
 This repository contains the source code for the python bindings for the C++
 [libigl](https://github.com/libigl/libigl) library written using

{libigl-2.6.1 → libigl-2.6.2.dev0}/pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "libigl"
-version = "2.6.1"
+version = "2.6.2.dev0"
 description = "libigl: A simple C++ geometry processing library"
 readme = "README.md"
 requires-python = ">=3.8"

libigl-2.6.2.dev0/src/OrientedBoundingBoxMinimizeType.cpp

@@ -0,0 +1,20 @@
+#include "default_types.h"
+#include <igl/oriented_bounding_box.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+
+void bind_OrientedBoundingBoxMinimizeType(nb::module_ &m)
+{
+  nb::enum_<igl::OrientedBoundingBoxMinimizeType>(m, "OrientedBoundingBoxMinimizeType")
+    .value("ORIENTED_BOUNDING_BOX_MINIMIZE_VOLUME", igl::ORIENTED_BOUNDING_BOX_MINIMIZE_VOLUME)
+    .value("ORIENTED_BOUNDING_BOX_MINIMIZE_SURFACE_AREA", igl::ORIENTED_BOUNDING_BOX_MINIMIZE_SURFACE_AREA)
+    .value("ORIENTED_BOUNDING_BOX_MINIMIZE_DIAGONAL_LENGTH", igl::ORIENTED_BOUNDING_BOX_MINIMIZE_DIAGONAL_LENGTH)
+    .export_values()
+    ;
+}
+

libigl-2.6.2.dev0/src/copyleft/cgal/oriented_bounding_box.cpp

@@ -0,0 +1,40 @@
+#include "default_types.h"
+#include <igl/copyleft/cgal/oriented_bounding_box.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto oriented_bounding_box(
+    const nb::DRef<const Eigen::MatrixXN> &P)
+  {
+    Eigen::MatrixXN R;
+    igl::copyleft::cgal::oriented_bounding_box(P, R);
+    return R;
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_oriented_bounding_box(nb::module_ &m)
+{
+  m.def(
+    "oriented_bounding_box",
+    &pyigl::oriented_bounding_box, 
+    "P"_a,
+    R"(Given a set of points compute the rotation transformation of them such
+that their axis-aligned bounding box is as small as possible.
+
+igl::oriented_bounding_box is often faster and better
+
+  @param[in] P  #P by 3 list of point locations
+  @param[out] R  rotation matrix
+  )");
+
+}
+
+

libigl-2.6.2.dev0/src/lipschitz_octree.cpp

@@ -0,0 +1,62 @@
+#include "default_types.h"
+#include <igl/lipschitz_octree.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/function.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  // Hopefully this will avoid a copy by matching the type in lipschitz_octree_prune
+  using MatrixNX3R = Eigen::Matrix<Numeric, Eigen::Dynamic, 3, Eigen::RowMajor>;
+  auto lipschitz_octree(
+    const nb::DRef<const Eigen::VectorXN> &origin,
+    const Numeric h0,
+    const Integer max_depth,
+    const nb::typed<
+      nb::callable,
+      Eigen::VectorXN(const nb::DRef<const MatrixNX3R> &)> & udf)
+  {
+    Eigen::MatrixXI ijk;
+    // Instead of MatrixXN if use use MatrixNX3R we might avoid a copy
+    const std::function<Eigen::VectorXN(const MatrixNX3R &)> udf_wrapper =
+      [&](const MatrixNX3R &Q) -> Eigen::VectorXN
+    {
+      return nb::cast<Eigen::VectorXN>(udf(Q));
+    };
+    igl::lipschitz_octree<true>(origin, h0, max_depth, udf_wrapper, ijk);
+    return ijk;
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_lipschitz_octree(nb::module_ &m)
+{
+  m.def(
+    "lipschitz_octree",
+    &pyigl::lipschitz_octree, 
+    "origin"_a, 
+    "h0"_a,
+    "max_depth"_a,
+    "udf"_a,
+R"(Given a minimum corner position (origin) and a side length (h0) and a
+maximum depth (max_depth), determine the possible active leaf octree cells
+based on an one-Lipschitz non-negative function to a level set (e.g.,
+"unsigned distance function").
+
+  @param[in] origin  3-vector of root cell origin (minimum corner)
+  @param[in] h0   side length of root cell
+  @param[in] max_depth  maximum depth of octree (root is depth=0)
+  @param[in] udf  1-Lipschitz function of (unsigned) distance to level set to a
+    list of batched query points
+  @param[out] ijk #ijk by 3 list of octree leaf cell minimum corner
+    subscripts
+)");
+}
+
+
+

{libigl-2.6.1 → libigl-2.6.2.dev0}/src/marching_cubes.cpp

@@ -77,7 +77,7 @@ EV = np.array([[k & 0xFFFFFFFF, k >> 32, v] for k, v in E2V.items()], dtype=np.i
     "S"_a, 
     "GV"_a,
     "GI"_a,
-    "isovalue"_a=0,
+    "isovalue"_a=0.0,
 R"(Performs marching cubes reconstruction on a grid defined by values, and
 points, and generates a mesh defined by vertices and faces
 

libigl-2.6.2.dev0/src/offset_surface.cpp

@@ -0,0 +1,53 @@
+#include "default_types.h"
+#include <igl/offset_surface.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/vector.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl {
+  auto offset_surface(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const Numeric isolevel, 
+    const Integer s,
+    const igl::SignedDistanceType signed_distance_type) 
+  {
+    Eigen::MatrixXN SV;
+    Eigen::MatrixXI SF;
+    Eigen::MatrixXN GV;
+  
+    Eigen::VectorXI side;
+    Eigen::MatrixXN so;
+    igl::offset_surface(
+      V, F, isolevel, s, signed_distance_type, SV, SF, GV, side,
+      so);
+  
+    return std::make_tuple(SV, SF, GV, side, so);
+  }
+} // namespace pyigl
+
+// Bind the wrapper to the Python module
+void bind_offset_surface(nb::module_ &m) {
+  m.def(
+      "offset_surface", &pyigl::offset_surface, "V"_a, "F"_a, "isolevel"_a,
+      "s"_a, "signed_distance_type"_a,
+      R"(Compute a triangulated offset surface using matching cubes on a grid of signed distance values from the input triangle mesh.
+
+@param[in] V  #V by 3 list of mesh vertex positions
+@param[in] F  #F by 3 list of mesh triangle indices into V
+@param[in] isolevel  iso level to extract (signed distance: negative inside)
+@param[in] s  number of grid cells along longest side (controls resolution)
+@param[in] signed_distance_type  type of signing to use one of SIGNED_DISTANCE_TYPE_PSEUDONORMAL, SIGNED_DISTANCE_TYPE_WINDING_NUMBER, SIGNED_DISTANCE_TYPE_DEFAULT, SIGNED_DISTANCE_TYPE_UNSIGNED, SIGNED_DISTANCE_TYPE_FAST_WINDING_NUMBER
+
+@return Tuple containing:
+   - SV: #SV by 3 list of output surface mesh vertex positions
+   - SF: #SF by 3 list of output mesh triangle indices into SV
+   - GV: #GV=side(0)*side(1)*side(2) by 3 list of grid cell centers
+   - side: list of number of grid cells in x, y, and z directions
+   - so: #GV by 3 list of signed distance values _near_ `isolevel` ('far' from `isolevel` these values are incorrect))");
+}

libigl-2.6.2.dev0/src/oriented_bounding_box.cpp

@@ -0,0 +1,45 @@
+#include "default_types.h"
+#include <igl/oriented_bounding_box.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto oriented_bounding_box(
+    const nb::DRef<const Eigen::MatrixXN> &P,
+    const int n,
+    const igl::OrientedBoundingBoxMinimizeType minimize_type)
+  {
+    Eigen::MatrixXN R;
+    igl::oriented_bounding_box(P, n, minimize_type, R);
+    return R;
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_oriented_bounding_box(nb::module_ &m)
+{
+  m.def(
+    "oriented_bounding_box",
+    &pyigl::oriented_bounding_box, 
+    "P"_a,
+    "n"_a=10000,
+    "minimize_type"_a=igl::ORIENTED_BOUNDING_BOX_MINIMIZE_VOLUME,
+R"(Given a set of points compute the rotation transformation of them such
+that their axis-aligned bounding box is as small as possible.
+  
+Consider passing the points on the convex hull of original list of points.
+  
+   @param[in] P  #P by 3 list of point locations
+   @param[in] n  number of rotations to try
+   @param[in] minimize_type  which quantity to minimize
+   @param[out] R  rotation matrix
+  )");
+
+}
+

{libigl-2.6.1 → libigl-2.6.2.dev0}/src/random_points_on_mesh.cpp

@@ -1,8 +1,10 @@
 #include "default_types.h"
 #include <igl/random_points_on_mesh.h>
+#include <igl/generate_default_urbg.h>
 #include <nanobind/nanobind.h>
 #include <nanobind/eigen/dense.h>
 #include <nanobind/stl/tuple.h>
+#include <nanobind/stl/optional.h>
 
 namespace nb = nanobind;
 using namespace nb::literals;
@@ -13,11 +15,13 @@ namespace pyigl
   auto random_points_on_mesh(
     const Integer n,
     const nb::DRef<const Eigen::MatrixXN> &V,
-    const nb::DRef<const Eigen::MatrixXI> &F)
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const std::optional<int> seed)
   {
+    std::mt19937 urbg = seed.has_value() ? std::mt19937(*seed) : igl::generate_default_urbg();
     Eigen::VectorXI FI;
     Eigen::MatrixXN B,X;
-    igl::random_points_on_mesh(n, V, F,  B, FI, X);
+    igl::random_points_on_mesh(n, V, F,  B, FI, X, urbg);
     return std::make_tuple(B, FI, X);
   }
 }
@@ -32,6 +36,7 @@ void bind_random_points_on_mesh(nb::module_ &m)
     "n"_a,
     "V"_a,
     "F"_a,
+    "seed"_a = nb::none(),
     R"(
  Randomly sample a mesh (V,F) n times.
 

{libigl-2.6.1 → libigl-2.6.2.dev0}/src/remove_unreferenced.cpp

@@ -33,6 +33,7 @@ void bind_remove_unreferenced(nb::module_ &m)
 R"(Remove unreferenced vertices from V, updating F accordingly
 @param[in] V  #V by dim list of mesh vertex positions
 @param[in] F  #F by ss list of simplices (Values of -1 are quitely skipped)
+@param[out] NV  #NV by dim list of simplices
 @param[out] NF  #NF by ss list of simplices
 @param[out] I   #V by 1 list of indices such that: NF = IM(F) and NT = IM(T)
      and V(find(IM<=size(NV,1)),:) = NV

libigl-2.6.2.dev0/src/unique_sparse_voxel_corners.cpp

@@ -0,0 +1,60 @@
+#include "default_types.h"
+#include <igl/unique_sparse_voxel_corners.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto unique_sparse_voxel_corners(
+    const nb::DRef<const Eigen::VectorXN> &origin,
+    const Numeric h0,
+    const Integer depth,
+    const nb::DRef<const Eigen::MatrixXI> &ijk)
+  {
+    Eigen::MatrixXI unique_ijk;
+    Eigen::MatrixXI J;
+    Eigen::MatrixXN unique_corners;
+    
+    igl::unique_sparse_voxel_corners(
+      origin, h0, depth, ijk, unique_ijk, J, unique_corners);
+    
+    return std::make_tuple(unique_ijk, J, unique_corners);
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_unique_sparse_voxel_corners(nb::module_ &m)
+{
+  m.def(
+    "unique_sparse_voxel_corners",
+    &pyigl::unique_sparse_voxel_corners, 
+    "origin"_a, 
+    "h0"_a,
+    "depth"_a,
+    "ijk"_a,
+    R"(
+Give a list of octree cells subscripts (ijk) (minimum corners) at a given depth,
+determine a unique list of subscripts to all incident corners of those
+cells (de-replicating shared corners).
+
+ @param[in] origin  3-vector of root cell minimum
+ @param[in] h0   side length of current depth level
+ @param[in] depth  current depth (single root cell is depth = 0)
+ @param[in] ijk #ijk by 3 list of octree leaf cell minimum corner
+   subscripts
+ @param[out] unique_ijk #unique_ijk by 3 list of unique corner subscripts
+ @param[out] J  #ijk by 8 list of indices into unique_ijk in yxz binary
+   counting order
+ @param[out] unique_corners #unique_ijk by 3 list of unique corner
+   positions
+    )");
+
+}
+
+
+

{libigl-2.6.1 → libigl-2.6.2.dev0}/tests/test_all.py

@@ -261,6 +261,10 @@ def test_volume():
     F = np.array([[2,1,3]],dtype=np.int64)
     NV,NF,I,J = igl.remove_unreferenced(V,F)
 
+def test_offset_surface():
+    V,F = triangulated_square()
+    v, f, _, _, _ = igl.offset_surface(V, F, -0.1, 1, igl.SIGNED_DISTANCE_TYPE_DEFAULT)
+
 def test_oriented_facets():
     V,F,T = single_tet()
     E = igl.oriented_facets(F)
@@ -328,6 +332,19 @@ def test_sample():
     I = igl.knn(X,X,1,point_indices,CH,CN,W)
     B,FI,P = igl.blue_noise(V,F,0.5)
 
+    # Test equal seed yields same result
+    B1,I1,X1 = igl.random_points_on_mesh(10,V,F, 1)
+    B1_,I1_,X1_ = igl.random_points_on_mesh(10,V,F, 1)
+    assert np.all(B1 == B1_)
+    assert np.all(I1 == I1_)
+    assert np.all(X1 == X1_)
+    # Test different seed yields different result
+    B2,I2,X2 = igl.random_points_on_mesh(10,V,F,2)
+    assert not np.all(B1 == B2)
+    assert not np.all(I1 == I2)
+    assert not np.all(X1 == X2)
+
+
 def test_curvature():
     V,F = igl.icosahedron()
     K = igl.gaussian_curvature(V,F)
@@ -491,6 +508,8 @@ def test_cgal():
     point_indices, CH,CN,W = igl.octree(X)
     I = igl.knn(X,X,20,point_indices,CH,CN,W)
     A,T = igl.copyleft.cgal.point_areas(X,I,N)
+
+    R = igl.copyleft.cgal.oriented_bounding_box(VC)
     
 def test_embree():
     # octahedron
@@ -553,6 +572,21 @@ def test_misc():
     theta, cos_theta = igl.dihedral_angles_intrinsic(L,A)
     D = igl.all_pairs_distances(V,V,squared=False)
     D = igl.all_pairs_distances(V,V,squared=True)
-
-
-
+    R = igl.oriented_bounding_box(V)
+    R = igl.oriented_bounding_box(V,n=100,minimize_type=igl.ORIENTED_BOUNDING_BOX_MINIMIZE_SURFACE_AREA)
+
+def test_octree():
+
+    def sdf_sphere(Q):
+        return np.linalg.norm(Q,axis=1) - 0.5
+    def udf_sphere(Q):
+        return np.abs(sdf_sphere(Q))
+
+    origin = np.array([-1,-1,-1],dtype=np.float64)
+    h0 = 2.0
+    max_depth = 4
+    ijk = igl.lipschitz_octree(origin,h0,max_depth,udf_sphere)
+    h = h0 / (2**max_depth)
+    unique_ijk, J, unique_corners = igl.unique_sparse_voxel_corners(origin,h0,max_depth,ijk)
+    unique_S = sdf_sphere(unique_corners)
+    V,F = igl.marching_cubes(unique_S,unique_corners,J,0.0)