libigl 2.6.3.dev5__tar.gz → 2.6.4.dev0__tar.gz

{libigl-2.6.3.dev5 → libigl-2.6.4.dev0}/.github/workflows/wheels.yml

@@ -25,26 +25,37 @@ jobs:
 
   build_wheels:
     runs-on: ${{ matrix.os }}
+    # windows-11-arm is newly added; its native toolchain may not build every
+    # dependency yet (embree / predicates use x86 SIMD), so don't let that leg
+    # block a release if it fails.
+    continue-on-error: ${{ matrix.os == 'windows-11-arm' }}
     strategy:
       fail-fast: false
+      # One runner per *native* target architecture; cibuildwheel builds the
+      # runner's native arch by default. Do NOT reintroduce a cross `arch`
+      # dimension: previously `arch: arm64` on the x86 ubuntu-24.04 / windows-latest
+      # runners silently built x86_64 / amd64 wheels (only CIBW_ARCHS_MACOS was
+      # wired up), producing duplicate wheels that collided during the release
+      # artifact download and left win_arm64 uncovered.
       matrix:
-        os: [ubuntu-24.04, ubuntu-24.04-arm, macos-latest, macos-15-intel, windows-latest]  # Use specific versions for clarity
-        arch: [x86_64, arm64]
-        pybuilds: [cp38, cp39, cp310, cp311, cp312] # Define pybuilds at the top level
+        os: [ubuntu-24.04, ubuntu-24.04-arm, macos-latest, macos-15-intel, windows-latest, windows-11-arm]
+        pybuilds: [cp38, cp39, cp310, cp311, cp312]
         exclude:
-          - os: ubuntu-24.04-arm  # No need to specify arch, it's already implicit
-            arch: x86_64  # Exclude x86_64 on ARM
+          # No macOS CPython 3.8 wheels are shipped.
           - os: macos-latest
-            arch: x86_64   # Exclude x86_64 explicitly
-          - os: macos-latest # Exclude cp38
             pybuilds: cp38
           - os: macos-15-intel
-            arch: arm64   # Exclude arm64 on macOS 13
-          - os: macos-15-intel
             pybuilds: cp38
+          # Windows on ARM64 has official CPython only for 3.11+.
+          - os: windows-11-arm
+            pybuilds: cp38
+          - os: windows-11-arm
+            pybuilds: cp39
+          - os: windows-11-arm
+            pybuilds: cp310
 
     name: >
-      ${{ matrix.pybuilds }} ${{ matrix.os }} ${{ matrix.arch }}
+      ${{ matrix.pybuilds }} ${{ matrix.os }}
 
     steps:
       - uses: actions/checkout@v4
@@ -59,15 +70,21 @@ jobs:
           CIBW_ENVIRONMENT_LINUX: "CC=clang CXX=clang++"
           CIBW_MANYLINUX_X86_64_IMAGE: "manylinux_2_28"
           CIBW_MANYLINUX_AARCH64_IMAGE: "manylinux_2_28"
-          CIBW_BUILD: "${{ matrix.pybuilds }}-*"  # Use matrix.pybuilds and matrix.arch
-          CIBW_ARCHS_MACOS: ${{ matrix.arch }}
+          CIBW_BUILD: "${{ matrix.pybuilds }}-*"
+          # No CIBW_ARCHS_* override: each runner builds its native architecture.
           CIBW_SKIP: "cp*-manylinux_i686 cp*-musllinux* cp*-win32"
+          # embree only enables its NEON (sse2neon) path when its build detects an
+          # ARM target; on Windows/MSVC-ARM64 that detection falls back to SSE2 and
+          # fails to compile (x86 immintrin.h). Drop embree on win_arm64 (the
+          # igl.embree submodule is simply absent from that wheel).
+          CIBW_ENVIRONMENT_WINDOWS: ${{ matrix.os == 'windows-11-arm' && 'CMAKE_ARGS=-DLIBIGL_EMBREE=OFF' || '' }}
       - name: Upload Artifact
         uses: actions/upload-artifact@v4
         continue-on-error: true  # Important: Continue if upload fails
         with:
-          # Include pybuilds in the artifact name
-          name: wheels-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.pybuilds }}
+          # Unique per (os, python); one native arch per runner so wheel
+          # filenames never collide when the release job merges artifacts.
+          name: wheels-${{ matrix.os }}-${{ matrix.pybuilds }}
           path: ./wheelhouse/*.whl
           if-no-files-found: error  # Fail if no wheels are found
           compression-level: 6
@@ -171,6 +188,9 @@ jobs:
           name: ${{ needs.check_version.outputs.version }}
           prerelease: ${{ needs.check_version.outputs.prerelease }}
           allowUpdates: true
+          # Auto-populate the release body with the merged PRs since the
+          # previous tag (curated highlights live in CHANGELOG.md).
+          generateReleaseNotes: true
           artifacts: "./artifacts/**/*"
           token: ${{ secrets.GITHUB_TOKEN }}
       - name: Publish to PyPI

libigl-2.6.4.dev0/CHANGELOG.md

@@ -0,0 +1,70 @@
+# Changelog
+
+All notable, user-facing changes to the `libigl` Python bindings are recorded
+here. The project loosely follows [Semantic Versioning](https://semver.org) and
+version numbers match the [PyPI releases](https://pypi.org/project/libigl/#history).
+
+> Historical note: releases up to and including 2.6.2 were published to PyPI
+> without matching git tags or GitHub releases (see #235). Starting with 2.6.3,
+> pushing a version bump to `main` automatically creates the git tag, the GitHub
+> release, and the PyPI upload together (#313). The 2.6.3 section below therefore
+> folds in changes first shipped in the tag-less interim 2.6.2 release, i.e. it
+> covers everything since the last tagged release, 2.6.1.
+
+## 2.6.3 — 2026-08-31
+
+### Added
+
+New function bindings:
+
+- **Distances & closest points:** `simplex_simplex_squared_distance`,
+  `point_simplex_squared_distance`, `offset_surface`.
+- **Rotations / ARAP:** `polar_svd3x3`, `fit_rotations`.
+- **Quad meshes:** `quad_planarity`, `planarize_quad_mesh`, `quad_edges`.
+- **Curves & mesh topology:** `ramer_douglas_peucker`, `path_to_edges`,
+  `connect_boundary_to_infinity`, `smooth_corner_adjacency`,
+  `per_face_normals_stable`, `resolve_duplicated_faces`, `vertex_components`,
+  `is_vertex_manifold`, `is_intrinsic_delaunay`.
+- **Remeshing:** `triangle.remesh_at_points`.
+- **Winding numbers & distance fields:** `swept_volume`,
+  `swept_volume_bounding_box`, `swept_volume_signed_distance`,
+  point-cloud and pre-built-tree support for `fast_winding_number`,
+  `lipschitz_octree`, `unique_sparse_voxel_corners`, and an edge→vertex (`E2V`)
+  output for sparse `marching_cubes`.
+- **Ambient occlusion:** core `ambient_occlusion` binding.
+- **Solvers & energies:** `active_set`, `boundary_conditions`,
+  `harmonic_integrated_from_laplacian_and_mass`, Hessian and Hessian-energy
+  operators, and cross-field bindings.
+- **Bounding boxes:** oriented-bounding-box functions, `bounding_box_diagonal`.
+- **Curves & predicates:** cubic Bézier evaluation and roots, additional
+  `igl::predicates` bindings, `igl::spectra` bindings, and
+  `lexicographic_triangulation`.
+- **Misc:** `centroid`, a `face_areas` overload taking intrinsic edge lengths,
+  and an optional `seed` parameter for `random_points_on_mesh`.
+
+### Changed
+
+- Bumped the bundled libigl to
+  [`f68f01c2`](https://github.com/libigl/libigl/commit/f68f01c23ac82351e2543ce8c529b6d4c89fdf16).
+- `cycodebase` distance queries can now reuse a prebuilt AABB tree / precomputed
+  bases for fast repeated queries.
+- Releases are now cut by pushing a version bump to `main`, which tags the
+  commit and creates the GitHub release and PyPI upload in one step (#313).
+
+### Packaging / CI
+
+- Added CPython 3.13 wheels.
+- Switched the Linux CI builds to Clang to fix a 2.6.1 performance regression.
+- Bumped `pypa/gh-action-pypi-publish` to 1.13.0.
+
+## 2.6.2 — PyPI only
+
+Interim release published to PyPI on 2025 without a git tag or GitHub release.
+Its changes are folded into the 2.6.3 entry above.
+
+## 2.6.1 — 2025-05-15
+
+Last release before this changelog was introduced. See the
+[git history](https://github.com/libigl/libigl-python-bindings/commits/2.6.1)
+and the [PyPI release history](https://pypi.org/project/libigl/#history) for
+earlier changes.

{libigl-2.6.3.dev5 → libigl-2.6.4.dev0}/CMakeLists.txt

@@ -60,7 +60,7 @@ option(LIBIGL_CYCODEBASE           "Build igl::cycodebase bindings"        ON)
 FetchContent_Declare(
   libigl
   GIT_REPOSITORY https://github.com/libigl/libigl.git
-  GIT_TAG 0cbcaf886314ff331402c38fbb04cc4de8d7c033
+  GIT_TAG f68f01c23ac82351e2543ce8c529b6d4c89fdf16
 )
 FetchContent_MakeAvailable(libigl)
 

{libigl-2.6.3.dev5 → libigl-2.6.4.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libigl
-Version: 2.6.3.dev5
+Version: 2.6.4.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)

{libigl-2.6.3.dev5 → libigl-2.6.4.dev0}/pyproject.toml

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

libigl-2.6.4.dev0/src/connect_boundary_to_infinity.cpp

@@ -0,0 +1,57 @@
+#include "default_types.h"
+#include <igl/connect_boundary_to_infinity.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 connect_boundary_to_infinity_F(
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::MatrixXI FO;
+    igl::connect_boundary_to_infinity(F, FO);
+    return FO;
+  }
+
+  auto connect_boundary_to_infinity_VF(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::MatrixXN VO;
+    Eigen::MatrixXI FO;
+    igl::connect_boundary_to_infinity(V, F, VO, FO);
+    return std::make_tuple(VO, FO);
+  }
+}
+
+void bind_connect_boundary_to_infinity(nb::module_ &m)
+{
+  m.def(
+    "connect_boundary_to_infinity",
+    &pyigl::connect_boundary_to_infinity_F,
+    "F"_a,
+R"(Connect all boundary edges to a fictitious point at infinity, closing an
+open mesh (the result is edge-manifold if the input was manifold).
+
+@param[in] F  #F by 3 list of face indices into some V
+@param[out] FO  #F+#O by 3 list of face indices into [V; inf], original F come
+                first)");
+  m.def(
+    "connect_boundary_to_infinity",
+    &pyigl::connect_boundary_to_infinity_VF,
+    "V"_a,
+    "F"_a,
+R"(Connect all boundary edges to a fictitious point at infinity, also
+returning the augmented vertex list.
+
+@param[in] V  #V by 3 list of vertex positions
+@param[in] F  #F by 3 list of face indices into rows of V
+@param[out] VO  #V+1 by 3 list of vertex positions; original V come first and
+                the last row is (inf, inf, inf)
+@param[out] FO  #F+#O by 3 list of face indices into rows of VO)");
+}

{libigl-2.6.3.dev5 → libigl-2.6.4.dev0}/src/face_areas.cpp

@@ -17,6 +17,14 @@ namespace pyigl
     igl::face_areas(V, T, A);
     return A;
   }
+
+  auto face_areas_intrinsic(
+    const nb::DRef<const Eigen::MatrixXN>& L)
+  {
+    Eigen::MatrixXN A;
+    igl::face_areas(L, A);
+    return A;
+  }
 }
 
 void bind_face_areas(nb::module_ &m)
@@ -27,6 +35,13 @@ void bind_face_areas(nb::module_ &m)
     R"(Constructs a list of face areas of faces opposite each index in a tet list
 @param[in] V  #V by 3 list of mesh vertex positions
 @param[in] T  #T by 3 list of tet mesh indices into V
+@param[out] A   #T by 4 list of face areas corresponding to faces opposite vertices
+    0,1,2,3)");
+  m.def("face_areas", &pyigl::face_areas_intrinsic,
+    "L"_a,
+    R"(Compute tet-mesh face areas from edge lengths.
+@param[in] L  #T by 6 list of tet-mesh edge lengths corresponding to edges
+    [1,2],[2,0],[0,1],[3,0],[3,1],[3,2]
 @param[out] A   #T by 4 list of face areas corresponding to faces opposite vertices
     0,1,2,3)");
 }

libigl-2.6.4.dev0/src/fit_rotations.cpp

@@ -0,0 +1,35 @@
+#include "default_types.h"
+#include <igl/fit_rotations.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto fit_rotations(
+    const nb::DRef<const Eigen::MatrixXN> &S,
+    const bool single_precision)
+  {
+    Eigen::MatrixXN R;
+    igl::fit_rotations(S, single_precision, R);
+    return R;
+  }
+}
+
+void bind_fit_rotations(nb::module_ &m)
+{
+  m.def(
+    "fit_rotations",
+    &pyigl::fit_rotations,
+    "S"_a,
+    "single_precision"_a = false,
+R"(Given a stack of covariance matrices, find the closest rotation to each
+(e.g. the local step of an as-rigid-as-possible optimization).
+
+@param[in] S  (n*dim) by dim stack of covariance matrices
+@param[in] single_precision  whether to use single precision (faster)
+@param[out] R  dim by (dim*n) list of rotations)");
+}

libigl-2.6.4.dev0/src/path_to_edges.cpp

@@ -0,0 +1,35 @@
+#include "default_types.h"
+#include <igl/path_to_edges.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto path_to_edges(
+    const nb::DRef<const Eigen::VectorXI> &I,
+    const bool make_loop)
+  {
+    Eigen::MatrixXI E;
+    igl::path_to_edges(I, E, make_loop);
+    return E;
+  }
+}
+
+void bind_path_to_edges(nb::module_ &m)
+{
+  m.def(
+    "path_to_edges",
+    &pyigl::path_to_edges,
+    "I"_a,
+    "make_loop"_a = false,
+R"(Given an ordered list of vertex indices describing a path, return the list
+of undirected edges connecting consecutive entries.
+
+@param[in] I  #I list of vertex indices along the path
+@param[in] make_loop  whether to also connect the last vertex back to the first
+@param[out] E  #E by 2 list of edges (E = #I-1, or #I if make_loop))");
+}

{libigl-2.6.3.dev5 → libigl-2.6.4.dev0}/src/per_face_normals.cpp

@@ -20,6 +20,15 @@ namespace pyigl
     igl::per_face_normals(V,F,Z,N);
     return N;
   }
+  // Wrapper for per_face_normals_stable function
+  auto per_face_normals_stable(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::MatrixXN N;
+    igl::per_face_normals_stable(V,F,N);
+    return N;
+  }
   // Wrapper for per_face_normals function
   auto per_face_normals_VIC(
     const nb::DRef<const Eigen::MatrixXN> &V,
@@ -69,4 +78,17 @@ R"(Compute face normals via vertex position list, polygon stream
 @param[out] FF  #I by 3 list of triangle indices into rows of VV
 @param[out] J  #I list of indices into original polygons)"
     );
+  m.def(
+    "per_face_normals_stable",
+    &pyigl::per_face_normals_stable,
+    "V"_a,
+    "F"_a,
+R"(Special version of per_face_normals where the order of the face indices is
+guaranteed not to affect the output (i.e. cross products are accumulated in a
+consistent order). Degenerate faces are given a zero normal.
+
+@param[in] V  #V by 3 eigen Matrix of mesh vertex 3D positions
+@param[in] F  #F by 3 eigen Matrix of face (triangle) indices
+@param[out] N  #F by 3 eigen Matrix of mesh face (triangle) 3D normals)"
+    );
 }

libigl-2.6.4.dev0/src/planarize_quad_mesh.cpp

@@ -0,0 +1,43 @@
+#include "default_types.h"
+#include <igl/planarize_quad_mesh.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto planarize_quad_mesh(
+    const nb::DRef<const Eigen::MatrixXN> &Vin,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const int maxIter,
+    const Numeric threshold)
+  {
+    // Vout must share Vin's (deduced) type, so pass a concrete copy of the input
+    Eigen::MatrixXN Vin_copy = Vin;
+    Eigen::MatrixXN Vout;
+    igl::planarize_quad_mesh(Vin_copy, F, maxIter, threshold, Vout);
+    return Vout;
+  }
+}
+
+void bind_planarize_quad_mesh(nb::module_ &m)
+{
+  m.def(
+    "planarize_quad_mesh",
+    &pyigl::planarize_quad_mesh,
+    "Vin"_a,
+    "F"_a,
+    "maxIter"_a = 100,
+    "threshold"_a = 0.005,
+R"(Planarize a quad mesh, moving vertices so that each quad becomes as planar
+as possible while staying close to the original surface.
+
+@param[in] Vin  #V by 3 list of input mesh vertex positions
+@param[in] F  #F by 4 list of quad face indices into rows of Vin
+@param[in] maxIter  maximum number of optimization iterations
+@param[in] threshold  planarity threshold at which to stop
+@param[out] Vout  #V by 3 list of planarized vertex positions)");
+}

libigl-2.6.4.dev0/src/point_simplex_squared_distance.cpp

@@ -0,0 +1,64 @@
+#include "default_types.h"
+#include <igl/point_simplex_squared_distance.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 point_simplex_squared_distance(
+    const nb::DRef<const Eigen::RowVectorXN> &p,
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &Ele,
+    const Integer i)
+  {
+    // Use concrete Eigen types (template deduction is finicky with DRef maps here).
+    // DIM (the ambient dimension) is a non-deduced template parameter, so we must
+    // supply it explicitly; dispatch on the number of columns of V.
+    const Eigen::RowVectorXN pc = p;
+    const Eigen::MatrixXN Vc = V;
+    const Eigen::MatrixXI Elec = Ele;
+    Numeric sqr_d;
+    Eigen::RowVectorXN c;
+    Eigen::RowVectorXN b;
+    switch (Vc.cols())
+    {
+      case 2:
+        igl::point_simplex_squared_distance<2>(pc, Vc, Elec, i, sqr_d, c, b);
+        break;
+      case 3:
+        igl::point_simplex_squared_distance<3>(pc, Vc, Elec, i, sqr_d, c, b);
+        break;
+      default:
+        throw std::runtime_error(
+          "point_simplex_squared_distance: only 2D and 3D points are supported");
+    }
+    return std::make_tuple(sqr_d, c, b);
+  }
+}
+
+void bind_point_simplex_squared_distance(nb::module_ &m)
+{
+  m.def(
+    "point_simplex_squared_distance",
+    &pyigl::point_simplex_squared_distance,
+    "p"_a,
+    "V"_a,
+    "Ele"_a,
+    "i"_a,
+R"(Determine the squared distance from a point p to the i-th linear simplex
+(point/segment/triangle) of a mesh, along with the closest point and its
+barycentric coordinates.
+
+@param[in] p  dim-long query point
+@param[in] V  #V by dim list of simplex-corner vertex positions
+@param[in] Ele  #Ele by (1|2|3) list of simplex indices into rows of V
+@param[in] i  index of the simplex (row of Ele) to measure against
+@param[out] sqr_d  squared distance from p to the i-th simplex
+@param[out] c  dim-long closest point on the i-th simplex
+@param[out] b  barycentric coordinates of the closest point c)");
+}

libigl-2.6.4.dev0/src/polar_svd3x3.cpp

@@ -0,0 +1,32 @@
+#include "default_types.h"
+#include <igl/polar_svd3x3.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto polar_svd3x3(const nb::DRef<const Eigen::MatrixXN> &A)
+  {
+    Eigen::Matrix<Numeric, 3, 3> Am = A;
+    Eigen::Matrix<Numeric, 3, 3> R;
+    igl::polar_svd3x3(Am, R);
+    return Eigen::MatrixXN(R);
+  }
+}
+
+void bind_polar_svd3x3(nb::module_ &m)
+{
+  m.def(
+    "polar_svd3x3",
+    &pyigl::polar_svd3x3,
+    "A"_a,
+R"(Compute the closest rotation matrix R to a 3x3 matrix A via the polar
+decomposition (using a fast fixed-size SVD).
+
+@param[in] A  3 by 3 matrix
+@param[out] R  3 by 3 closest rotation matrix (det(R) = +1))");
+}

libigl-2.6.4.dev0/src/quad_edges.cpp

@@ -0,0 +1,33 @@
+#include "default_types.h"
+#include <igl/quad_edges.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto quad_edges(const nb::DRef<const Eigen::MatrixXI> &Q)
+  {
+    // igl::quad_edges is instantiated only for 32-bit int matrices (it builds an
+    // Eigen::MatrixXi internally), so cast to int and back.
+    Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic> Qi = Q.cast<int>();
+    Eigen::Matrix<int, Eigen::Dynamic, Eigen::Dynamic> Ei;
+    igl::quad_edges(Qi, Ei);
+    return Eigen::MatrixXI(Ei.cast<Integer>());
+  }
+}
+
+void bind_quad_edges(nb::module_ &m)
+{
+  m.def(
+    "quad_edges",
+    &pyigl::quad_edges,
+    "Q"_a,
+R"(Compute the list of unique undirected edges of a quad mesh.
+
+@param[in] Q  #Q by 4 list of quad face indices
+@param[out] E  #E by 2 list of unique edges)");
+}

libigl-2.6.4.dev0/src/quad_planarity.cpp

@@ -0,0 +1,36 @@
+#include "default_types.h"
+#include <igl/quad_planarity.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto quad_planarity(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::VectorXN P;
+    igl::quad_planarity(V, F, P);
+    return P;
+  }
+}
+
+void bind_quad_planarity(nb::module_ &m)
+{
+  m.def(
+    "quad_planarity",
+    &pyigl::quad_planarity,
+    "V"_a,
+    "F"_a,
+R"(Compute a planarity value for each quad in a quad mesh. Planarity is the
+distance between the two diagonals of the quad divided by the average of the
+diagonals' lengths (0 for a perfectly planar quad).
+
+@param[in] V  #V by 3 list of mesh vertex positions
+@param[in] F  #F by 4 list of quad face indices into rows of V
+@param[out] P  #F list of planarity values)");
+}

libigl-2.6.4.dev0/src/ramer_douglas_peucker.cpp

@@ -0,0 +1,38 @@
+#include "default_types.h"
+#include <igl/ramer_douglas_peucker.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 ramer_douglas_peucker(
+    const nb::DRef<const Eigen::MatrixXN> &P,
+    const Numeric tol)
+  {
+    Eigen::MatrixXN S;
+    Eigen::VectorXI J;
+    igl::ramer_douglas_peucker(P, tol, S, J);
+    return std::make_tuple(S, J);
+  }
+}
+
+void bind_ramer_douglas_peucker(nb::module_ &m)
+{
+  m.def(
+    "ramer_douglas_peucker",
+    &pyigl::ramer_douglas_peucker,
+    "P"_a,
+    "tol"_a,
+R"(Ramer-Douglas-Peucker piecewise-linear curve simplification.
+
+@param[in] P  #P by dim ordered list of vertices along the curve
+@param[in] tol  tolerance (maximal Euclidean distance allowed between the new
+                line and a removed vertex)
+@param[out] S  #S by dim ordered list of points along the simplified curve
+@param[out] J  #S list of indices into P so that S = P[J,:])");
+}

libigl-2.6.4.dev0/src/simplex_simplex_squared_distance.cpp

@@ -0,0 +1,44 @@
+#include "default_types.h"
+#include <igl/simplex_simplex_squared_distance.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
+{
+  // Wrapper for simplex_simplex_squared_distance function
+  auto simplex_simplex_squared_distance(
+    const nb::DRef<const Eigen::MatrixXN> &V1,
+    const nb::DRef<const Eigen::MatrixXN> &V2)
+  {
+    Numeric sqrdDist;
+    Eigen::VectorXN B1;
+    Eigen::VectorXN B2;
+    igl::simplex_simplex_squared_distance(V1, V2, sqrdDist, B1, B2);
+    return std::make_tuple(sqrdDist, B1, B2);
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_simplex_simplex_squared_distance(nb::module_ &m)
+{
+  m.def(
+    "simplex_simplex_squared_distance",
+    &pyigl::simplex_simplex_squared_distance,
+    "V1"_a,
+    "V2"_a,
+R"(Find the squared distance between closest points on simplices with corners
+V1 and V2, respectively. V1 and V2 don't have to be the same simplex size,
+but they must have the same number of columns (dimension). This function
+works recursively.
+
+@param[in] V1  #V1 by dim list of simplex corners
+@param[in] V2  #V2 by dim list of simplex corners
+@param[out] sqrdDist  squared distance between closest points on simplices
+@param[out] B1  #V1 list of barycentric coordinates of closest point on simplex 1
+@param[out] B2  #V2 list of barycentric coordinates of closest point on simplex 2)");
+}