libigl 2.6.3.dev5__tar.gz → 2.6.4.dev1__tar.gz

{libigl-2.6.3.dev5 → libigl-2.6.4.dev1}/.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.dev1/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.dev1}/CMakeLists.txt

@@ -60,7 +60,9 @@ option(LIBIGL_CYCODEBASE           "Build igl::cycodebase bindings"        ON)
 FetchContent_Declare(
   libigl
   GIT_REPOSITORY https://github.com/libigl/libigl.git
-  GIT_TAG 0cbcaf886314ff331402c38fbb04cc4de8d7c033
+  # libigl main, including igl::lazy_cage and core igl::progressive_hulls (moved
+  # to core in libigl PR #2558).
+  GIT_TAG c07f8586733378c163aae57f08c9da2ce5352fb9
 )
 FetchContent_MakeAvailable(libigl)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libigl
-Version: 2.6.3.dev5
+Version: 2.6.4.dev1
 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.dev1}/pyproject.toml

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

libigl-2.6.4.dev1/src/LazyCageDistance.cpp

@@ -0,0 +1,16 @@
+#include "default_types.h"
+#include <igl/lazy_cage.h>
+#include <nanobind/nanobind.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void bind_LazyCageDistance(nb::module_ &m)
+{
+  nb::enum_<igl::LazyCageDistance>(m, "LazyCageDistance")
+    .value("LAZY_CAGE_DISTANCE_SIGNED", igl::LAZY_CAGE_DISTANCE_SIGNED)
+    .value("LAZY_CAGE_DISTANCE_UNSIGNED", igl::LAZY_CAGE_DISTANCE_UNSIGNED)
+    .value("NUM_LAZY_CAGE_DISTANCE", igl::NUM_LAZY_CAGE_DISTANCE)
+    .export_values()
+    ;
+}

libigl-2.6.4.dev1/src/LazyCageGridMode.cpp

@@ -0,0 +1,16 @@
+#include "default_types.h"
+#include <igl/lazy_cage.h>
+#include <nanobind/nanobind.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void bind_LazyCageGridMode(nb::module_ &m)
+{
+  nb::enum_<igl::LazyCageGridMode>(m, "LazyCageGridMode")
+    .value("LAZY_CAGE_GRID_DENSE", igl::LAZY_CAGE_GRID_DENSE)
+    .value("LAZY_CAGE_GRID_SPARSE", igl::LAZY_CAGE_GRID_SPARSE)
+    .value("NUM_LAZY_CAGE_GRID_MODE", igl::NUM_LAZY_CAGE_GRID_MODE)
+    .export_values()
+    ;
+}

libigl-2.6.4.dev1/src/LazyCageMetric.cpp

@@ -0,0 +1,17 @@
+#include "default_types.h"
+#include <igl/lazy_cage.h>
+#include <nanobind/nanobind.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void bind_LazyCageMetric(nb::module_ &m)
+{
+  nb::enum_<igl::LazyCageMetric>(m, "LazyCageMetric")
+    .value("LAZY_CAGE_METRIC_SIGMA", igl::LAZY_CAGE_METRIC_SIGMA)
+    .value("LAZY_CAGE_METRIC_VOLUME", igl::LAZY_CAGE_METRIC_VOLUME)
+    .value("LAZY_CAGE_METRIC_SURFACE_AREA", igl::LAZY_CAGE_METRIC_SURFACE_AREA)
+    .value("NUM_LAZY_CAGE_METRIC", igl::NUM_LAZY_CAGE_METRIC)
+    .export_values()
+    ;
+}

libigl-2.6.4.dev1/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.dev1}/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.dev1/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.dev1/src/lazy_cage.cpp

@@ -0,0 +1,123 @@
+#include "default_types.h"
+#include <igl/lazy_cage.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
+{
+  // Simple overload: {shortest edge, midpoint} decimation, the sigma metric, the
+  // dense grid, and the signed-distance field. grid_size <= 0 picks a heuristic.
+  auto lazy_cage(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const int num_faces,
+    const int grid_size)
+  {
+    const Eigen::MatrixXd Vd = V;
+    const Eigen::MatrixXi Fi = F.cast<int>();
+    Eigen::MatrixXd CV;
+    Eigen::MatrixXi CF;
+    double sigma;
+    const bool success = igl::lazy_cage(Vd, Fi, num_faces, grid_size, CV, CF, sigma);
+    return std::make_tuple(
+      success, Eigen::MatrixXN(CV), Eigen::MatrixXI(CF.cast<Integer>()), sigma);
+  }
+
+  // Full overload exposing every knob.
+  auto lazy_cage_full(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const int num_faces,
+    const int grid_size,
+    const double max_sigma,
+    const int num_iters,
+    const bool use_qslim,
+    const igl::LazyCageMetric metric,
+    const igl::LazyCageGridMode grid_mode,
+    const igl::LazyCageDistance distance)
+  {
+    const Eigen::MatrixXd Vd = V;
+    const Eigen::MatrixXi Fi = F.cast<int>();
+    Eigen::MatrixXd CV;
+    Eigen::MatrixXi CF;
+    double sigma;
+    const bool success = igl::lazy_cage(
+      Vd, Fi, num_faces, grid_size, max_sigma, num_iters, use_qslim,
+      metric, grid_mode, distance, CV, CF, sigma);
+    return std::make_tuple(
+      success, Eigen::MatrixXN(CV), Eigen::MatrixXI(CF.cast<Integer>()), sigma);
+  }
+}
+
+void bind_lazy_cage(nb::module_ &m)
+{
+  m.def(
+    "lazy_cage_default_grid_size",
+    &igl::lazy_cage_default_grid_size,
+    "num_faces"_a,
+R"(Heuristic isosurfacing grid resolution (cells across the largest side) for a
+lazy cage with num_faces faces.
+
+@param[in] num_faces  desired number of cage faces
+@return grid resolution)");
+
+  m.def(
+    "lazy_cage",
+    &pyigl::lazy_cage,
+    "V"_a,
+    "F"_a,
+    "num_faces"_a,
+    "grid_size"_a = 0,
+R"(Compute a "lazy cage" enclosing a closed input mesh: offset the surface and
+decimate it down to num_faces while it stays a valid cage (encloses the input,
+free of self-intersections, and not intersecting the input surface).
+
+Uses the default settings ({shortest edge, midpoint} decimation, the sigma
+metric, the dense grid, and the signed-distance field).
+
+@param[in] V  #V by 3 list of input vertex positions (closed, manifold)
+@param[in] F  #F by 3 list of input triangle indices into V
+@param[in] num_faces  desired number of faces in the cage
+@param[in] grid_size  isosurfacing resolution (cells along the largest side);
+    <= 0 uses lazy_cage_default_grid_size(num_faces)
+@param[out] success  true if a valid cage with num_faces faces was found
+@param[out] CV  #CV by 3 list of cage vertex positions
+@param[out] CF  #CF by 3 list of cage triangle indices into CV
+@param[out] sigma  the offset distance used to build the returned cage)");
+
+  m.def(
+    "lazy_cage",
+    &pyigl::lazy_cage_full,
+    "V"_a,
+    "F"_a,
+    "num_faces"_a,
+    "grid_size"_a,
+    "max_sigma"_a,
+    "num_iters"_a = 12,
+    "use_qslim"_a = false,
+    "metric"_a = igl::LAZY_CAGE_METRIC_SIGMA,
+    "grid_mode"_a = igl::LAZY_CAGE_GRID_DENSE,
+    "distance"_a = igl::LAZY_CAGE_DISTANCE_SIGNED,
+R"(Compute a "lazy cage" with full control over the offset-and-decimate search.
+
+@param[in] V  #V by 3 list of input vertex positions (closed, manifold)
+@param[in] F  #F by 3 list of input triangle indices into V
+@param[in] num_faces  desired number of faces in the cage
+@param[in] grid_size  isosurfacing resolution; <= 0 uses the heuristic
+@param[in] max_sigma  upper bound on the searched offset distance
+@param[in] num_iters  number of bisection iterations on sigma
+@param[in] use_qslim  decimate with igl.qslim (quadric error) instead of
+    {shortest edge, midpoint}
+@param[in] metric  objective minimized when choosing sigma (LazyCageMetric)
+@param[in] grid_mode  dense vs. sparse isosurface extraction (LazyCageGridMode)
+@param[in] distance  signed vs. unsigned distance field (LazyCageDistance)
+@param[out] success  true if a valid cage with num_faces faces was found
+@param[out] CV  #CV by 3 list of cage vertex positions
+@param[out] CF  #CF by 3 list of cage triangle indices into CV
+@param[out] sigma  the offset distance used to build the returned cage)");
+}

libigl-2.6.4.dev1/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.dev1}/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.dev1/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.dev1/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)");
+}