Merge branch 'libigl:main' into sample-with-seed

berendbaas · web-flow · commit 80a57332f95c · 2025-06-04T10:51:16.000+02:00
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
@@ -42,6 +42,9 @@ jobs:
           - os: macos-13
             pybuilds: cp38
 
+    name: >
+      ${{ matrix.pybuilds }} ${{ matrix.os }} ${{ matrix.arch }}
+
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v5
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -14,13 +14,9 @@ set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15")
 # <20 for embree
 set(CMAKE_CXX_STANDARD 17)
 
-if (CMAKE_VERSION VERSION_LESS 3.18)
-  set(DEV_MODULE Development)
-else()
-  set(DEV_MODULE Development.Module)
-endif()
-
-find_package(Python 3.8 COMPONENTS Interpreter ${DEV_MODULE} REQUIRED)
+find_package(Python 3.8
+  REQUIRED COMPONENTS Interpreter Development.Module
+  OPTIONAL_COMPONENTS Development.SABIModule)
 
 if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
@@ -36,7 +32,7 @@ include(FetchContent)
 FetchContent_Declare(
   nanobind
   GIT_REPOSITORY https://github.com/wjakob/nanobind.git
-  GIT_TAG        v2.2.0
+  GIT_TAG        v2.7.0
 )
 FetchContent_MakeAvailable(nanobind)
 
@@ -49,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 788871103938ce92112714d11ea491e8e6b4d972
+  GIT_TAG cf9ed7f492209590c42dc7247281dfdfb6618487
 )
 FetchContent_MakeAvailable(libigl)
 
@@ -125,7 +121,10 @@ function(pyigl_include prefix name)
     file(WRITE "${generated_dir}/BINDING_INVOCATIONS.in" "${BINDING_INVOCATIONS}")
 
     set(target_name "pyigl${prefix_lc}_${name}")
-    nanobind_add_module(${target_name} ${sources})
+    nanobind_add_module(
+      ${target_name} 
+      STABLE_ABI
+      ${sources})
 
     # important for scikit-build
     install(TARGETS ${target_name} LIBRARY DESTINATION  "igl/${subpath}")
diff --git a/README.md b/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
@@ -45,9 +44,11 @@ According to the [scikit-build-core documentation](https://scikit-build-core.rea
  2. Then use this very long command:
 
 ```
-python -m pip install --no-build-isolation --config-settings=editable.rebuild=true -Cbuild-dir=build -ve.
+CMAKE_BUILD_PARALLEL_LEVEL=10  python -m pip install --no-build-isolation --config-settings=editable.rebuild=true -Cbuild-dir=build -ve.
 ```
 
+The `CMAKE_BUILD_PARALLEL_LEVEL=10` will invoke with 10 parallel build threads.
+
 ### Adding a missing binding
 
 Bindings are fairly mechanical to write. For example, suppose we didn't have a
diff --git a/priority.txt b/priority.txt
@@ -7,13 +7,11 @@ euler_characteristic.cpp
 grad_intrinsic.cpp
 hessian.cpp
 hessian_energy.cpp
-internal_angles.cpp
 is_delaunay.cpp
 is_intrinsic_delaunay.cpp
 is_irregular_vertex.cpp
 iterative_closest_point.cpp
 lbs_matrix.cpp
-map_vertices_to_circle.cpp
 marching_tets.cpp
 mvc.cpp
 offset_surface.cpp
@@ -35,7 +33,6 @@ sparse_voxel_grid.cpp
 tet_tet_adjacency.cpp
 
 active_set.cpp
-all_pairs_distances.cpp
 ambient_occlusion.cpp
 arap_linear_block.cpp
 arap_rhs.cpp
diff --git a/pyproject.toml b/pyproject.toml
@@ -14,7 +14,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "libigl"
-version = "2.5.4dev"
+version = "2.6.1.dev0"
 description = "libigl: A simple C++ geometry processing library"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -42,6 +42,7 @@ build-dir = "build/{wheel_tag}"
 # Build stable ABI wheels for CPython 3.12+
 wheel.py-api = "cp312"
 
+
 [tool.scikit-build.cmake]
 build-type = "Release"
 
diff --git a/src/OrientedBoundingBoxMinimizeType.cpp b/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()
+    ;
+}
+
diff --git a/src/all_pairs_distances.cpp b/src/all_pairs_distances.cpp
@@ -0,0 +1,37 @@
+#include "default_types.h"
+#include <igl/all_pairs_distances.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+namespace pyigl
+{
+  auto all_pairs_distances(
+      const Eigen::MatrixXd &V,
+      const Eigen::MatrixXd &U,
+      const bool squared)
+  {
+    Eigen::MatrixXd D;
+    igl::all_pairs_distances(V, U, squared, D);
+    return D;
+  }
+}
+
+void bind_all_pairs_distances(nb::module_ &m)
+{
+  m.def("all_pairs_distances", &pyigl::all_pairs_distances,
+        "V"_a,
+        "U"_a,
+        "squared"_a,
+        R"(Compute distances between each point i in V and point j in U
+    D = all_pairs_distances(V,U)
+@tparam matrix class like MatrixXd
+@param[in] V  #V by dim list of points
+@param[in] U  #U by dim list of points
+@param[in] squared  whether to return squared distances
+@param[out] D  #V by #U matrix of distances, where D(i,j) gives the distance or
+    squareed distance between V(i,:) and U(j,:)
+)");
+}
diff --git a/src/copyleft/cgal/oriented_bounding_box.cpp b/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
+  )");
+
+}
+
+
diff --git a/src/copyleft/cgal/remesh_self_intersections.cpp b/src/copyleft/cgal/remesh_self_intersections.cpp
@@ -61,7 +61,9 @@ void bind_remesh_self_intersections(nb::module_ &m)
       - VV: remeshed vertex positions
       - FF: remeshed face indices
       - IF: intersecting face pairs
-      - J: birth triangle indices)");
-
+      - J: birth triangle indices
+      - IM if stitch_all = true   #VV list from 0 to #VV-1
+           elseif stitch_all = false  #VV list of indices into VV of unique vertices.
+      )");
 }
 
diff --git a/src/internal_angles.cpp b/src/internal_angles.cpp
@@ -0,0 +1,31 @@
+#include "default_types.h"
+#include <igl/internal_angles.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+namespace pyigl
+{
+  auto internal_angles(
+      const nb::DRef<const Eigen::MatrixXN> &V,
+      const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::MatrixXN K;
+    igl::internal_angles(V, F, K);
+    return K;
+  }
+}
+
+void bind_internal_angles(nb::module_ &m)
+{
+  m.def("internal_angles", &pyigl::internal_angles,
+        "V"_a,
+        "F"_a,
+        R"(Compute internal angles for all tets of a given tet mesh (V,T).
+@param[in] V  #V by dim eigen Matrix of mesh vertex nD positions
+@param[in] F  #F by poly-size eigen Matrix of face (triangle) indices
+@param[out] K  #F by poly-size eigen Matrix of internal angles
+    for triangles, columns correspond to edges [1,2],[2,0],[0,1])");
+}
diff --git a/src/map_vertices_to_circle.cpp b/src/map_vertices_to_circle.cpp
@@ -0,0 +1,33 @@
+#include "default_types.h"
+#include <igl/map_vertices_to_circle.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/vector.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+namespace pyigl
+{
+  auto map_vertices_to_circle(
+      const Eigen::MatrixXd &V,
+      const Eigen::VectorXi &bnd)
+  {
+    Eigen::MatrixXd UV;
+    igl::map_vertices_to_circle(V, bnd, UV);
+    return UV;
+  }
+}
+
+void bind_map_vertices_to_circle(nb::module_ &m)
+{
+  m.def("map_vertices_to_circle", &pyigl::map_vertices_to_circle,
+        "V"_a,
+        "bnd"_a,
+        R"(Map the vertices whose indices are in a given boundary loop (bnd) on the
+unit circle with spacing proportional to the original boundary edge
+lengths.
+@param[in] V  #V by dim list of mesh vertex positions
+@param[in] b  #W list of vertex ids
+@param[out] UV   #W by 2 list of 2D position on the unit circle for the vertices in b)");
+}
diff --git a/src/offset_surface.cpp b/src/offset_surface.cpp
@@ -0,0 +1,51 @@
+#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))");
+}
diff --git a/src/oriented_bounding_box.cpp b/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
+  )");
+
+}
+
diff --git a/src/remove_unreferenced.cpp b/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
diff --git a/src/sparse_map_noop.cpp b/src/sparse_map_noop.cpp
diff --git a/src/sparse_map_shape.cpp b/src/sparse_map_shape.cpp
diff --git a/src/sparse_noop.cpp b/src/sparse_noop.cpp
diff --git a/src/sparse_shape.cpp b/src/sparse_shape.cpp
diff --git a/tests/test_all.py b/tests/test_all.py
