libigl 2.6.3.dev4__tar.gz → 2.6.4.dev0__tar.gz

{libigl-2.6.3.dev4 → libigl-2.6.4.dev0}/.github/workflows/pip.yml

@@ -5,7 +5,7 @@ on:
   pull_request:
   push:
     branches:
-      - master
+      - main
 
 jobs:
   build:

libigl-2.6.4.dev0/.github/workflows/wheels.yml

@@ -0,0 +1,200 @@
+name: Wheels
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build_sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - run: pipx run build --sdist
+      - run: pipx run twine check dist/* || exit 1  # Ensure failure on twine check errors
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist-sdist
+          path: dist/*.tar.gz
+
+  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, windows-11-arm]
+        pybuilds: [cp38, cp39, cp310, cp311, cp312]
+        exclude:
+          # No macOS CPython 3.8 wheels are shipped.
+          - os: macos-latest
+            pybuilds: cp38
+          - 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 }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+      - run: pip install cibuildwheel==3.1.4
+      - name: Build wheels
+        run: python -m cibuildwheel --output-dir wheelhouse
+        env:
+          CIBW_BEFORE_ALL_LINUX: "yum install -y clang"
+          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 }}-*"
+          # 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:
+          # 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
+          overwrite: false
+          include-hidden-files: false
+
+  check_version:
+    name: Check for a version bump
+    # Only a push to main can release; PRs and workflow_dispatch never do.
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    outputs:
+      should_release: ${{ steps.check.outputs.should_release }}
+      version: ${{ steps.check.outputs.version }}
+      prerelease: ${{ steps.check.outputs.prerelease }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Need history to read pyproject.toml as of the previous commit
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'   # tomllib needs >=3.11
+      - name: Compare pyproject.toml version against the previous commit
+        id: check
+        env:
+          BEFORE: ${{ github.event.before }}
+        run: |
+          set -euo pipefail
+
+          # Read project.version from pyproject.toml at a given revision
+          # (empty revision = the working tree)
+          read_version() {
+            if [ -z "${1:-}" ]; then cat pyproject.toml; else git show "$1:pyproject.toml"; fi \
+              | python3 -c 'import sys,tomllib; print(tomllib.loads(sys.stdin.read())["project"]["version"])'
+          }
+
+          version=$(read_version)
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+          # PEP 440 pre-releases (aN/bN/rcN/.devN) are flagged as such on GitHub.
+          # Note `.postN` is deliberately not a pre-release.
+          if printf '%s' "$version" | grep -Eq '(a[0-9]+|b[0-9]+|rc[0-9]+|\.dev[0-9]*)$'; then
+            echo "prerelease=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "prerelease=false" >> "$GITHUB_OUTPUT"
+          fi
+
+          # `before` is all-zeros when the branch is first created, and can point
+          # at a vanished commit after a force-push; fall back to the first parent.
+          base="$BEFORE"
+          if [ -z "$base" ] || [ "$base" = "0000000000000000000000000000000000000000" ] \
+             || ! git cat-file -e "$base^{commit}" 2>/dev/null; then
+            base=$(git rev-parse --verify --quiet HEAD^ || true)
+          fi
+          if [ -z "$base" ]; then
+            echo "No previous commit to compare against; not releasing."
+            echo "should_release=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          previous=$(read_version "$base")
+          echo "previous version: $previous"
+          echo "current version:  $version"
+          if [ "$version" = "$previous" ]; then
+            echo "Version unchanged; not releasing."
+            echo "should_release=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          # Belt and braces: PyPI refuses to overwrite an existing version, and a
+          # re-run of this workflow would otherwise try to. Also covers the case
+          # where a bump was published by some other route.
+          if curl -sfL -o /dev/null "https://pypi.org/pypi/libigl/$version/json"; then
+            echo "libigl $version is already on PyPI; not releasing."
+            echo "should_release=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          echo "Version bumped $previous -> $version; releasing."
+          echo "should_release=true" >> "$GITHUB_OUTPUT"
+
+  release_artifacts:
+    name: Publish ${{ needs.check_version.outputs.version }} to PyPI
+    needs: [check_version, build_sdist, build_wheels]
+    if: needs.check_version.outputs.should_release == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write   # for PyPI trusted publishing
+      contents: write   # to create the tag and GitHub release
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: ./artifacts
+          merge-multiple: true
+      - run: ls -R ./artifacts
+      - name: Tag and create a GitHub release
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ needs.check_version.outputs.version }}
+          commit: ${{ github.sha }}
+          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
+        uses: pypa/gh-action-pypi-publish@v1.13.0
+        with:
+          packages-dir: ./artifacts
+          skip-existing: true

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.dev4 → 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 477e15a3d566a21f415aa5ee62992b12a836b01b
+  GIT_TAG f68f01c23ac82351e2543ce8c529b6d4c89fdf16
 )
 FetchContent_MakeAvailable(libigl)
 
@@ -208,4 +208,3 @@ if(LIBIGL_CYCODEBASE)
 endif()
 
 
-

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libigl
-Version: 2.6.3.dev4
+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.dev4 → libigl-2.6.4.dev0}/include/default_types.h

@@ -1,3 +1,4 @@
+#pragma once
 #include <Eigen/Dense>
 #include <Eigen/Sparse>
 #include <cstdint>

libigl-2.6.4.dev0/include/parse_transforms.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "default_types.h"
+#include <Eigen/Geometry>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace pyigl
+{
+  typedef Eigen::Transform<Numeric,3,Eigen::Affine> AffineN3;
+  typedef std::vector<AffineN3,Eigen::aligned_allocator<AffineN3> > AffineN3List;
+
+  /// Convert a Python list of 4×4 (or 3×4) matrices into the list of
+  /// Eigen::Transforms that the igl::swept_volume* functions expect.
+  ///
+  /// @param[in] transforms  #transforms list of 4×4 or 3×4 matrices
+  /// @param[in] caller  name used to prefix error messages
+  /// @return #transforms list of affine transformations
+  inline AffineN3List parse_transforms(
+    const std::vector<Eigen::MatrixXN> &transforms,
+    const char * const caller)
+  {
+    if(transforms.empty())
+    {
+      throw std::runtime_error(
+        std::string(caller)+": transforms must be non-empty");
+    }
+    AffineN3List T;
+    T.reserve(transforms.size());
+    for(const auto & M : transforms)
+    {
+      if(M.cols() != 4 || (M.rows() != 3 && M.rows() != 4))
+      {
+        throw std::runtime_error(
+          std::string(caller)+": each transform must be 3×4 or 4×4");
+      }
+      AffineN3 Ti;
+      // A 3×4 input leaves the implicit bottom row as [0 0 0 1]
+      Ti.matrix().setIdentity();
+      Ti.matrix().topRows(M.rows()) = M;
+      T.emplace_back(Ti);
+    }
+    return T;
+  }
+}

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

@@ -13,7 +13,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "libigl"
-version = "2.6.3.dev4"
+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/active_set.cpp

@@ -0,0 +1,100 @@
+#include "default_types.h"
+#include <igl/active_set.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/eigen/sparse.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  // Wrapper for active_set function
+  auto active_set(
+    const Eigen::SparseMatrixN &A,
+    const nb::DRef<const Eigen::VectorXN> &B,
+    const nb::DRef<const Eigen::VectorXI> &known,
+    const nb::DRef<const Eigen::VectorXN> &Y,
+    const Eigen::SparseMatrixN &Aeq,
+    const nb::DRef<const Eigen::VectorXN> &Beq,
+    const Eigen::SparseMatrixN &Aieq,
+    const nb::DRef<const Eigen::VectorXN> &Bieq,
+    const nb::DRef<const Eigen::VectorXN> &lx,
+    const nb::DRef<const Eigen::VectorXN> &ux,
+    const bool Auu_pd,
+    const int max_iter,
+    const double inactive_threshold,
+    const double constraint_threshold,
+    const double solution_diff_threshold)
+  {
+    igl::active_set_params params;
+    params.Auu_pd = Auu_pd;
+    params.max_iter = max_iter;
+    params.inactive_threshold = inactive_threshold;
+    params.constraint_threshold = constraint_threshold;
+    params.solution_diff_threshold = solution_diff_threshold;
+
+    Eigen::VectorXN Z;
+    igl::SolverStatus status = igl::active_set(
+      A, B, known, Y, Aeq, Beq, Aieq, Bieq, lx, ux, params, Z);
+
+    if(status == igl::SOLVER_STATUS_ERROR)
+    {
+      throw std::runtime_error("active_set: solver failed");
+    }
+    return Z;
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_active_set(nb::module_ &m)
+{
+  igl::active_set_params params;
+  m.def(
+    "active_set",
+    &pyigl::active_set,
+    "A"_a,
+    "B"_a,
+    "known"_a      = Eigen::VectorXI(),
+    "Y"_a          = Eigen::VectorXN(),
+    "Aeq"_a        = Eigen::SparseMatrixN(),
+    "Beq"_a        = Eigen::VectorXN(),
+    "Aieq"_a       = Eigen::SparseMatrixN(),
+    "Bieq"_a       = Eigen::VectorXN(),
+    "lx"_a         = Eigen::VectorXN(),
+    "ux"_a         = Eigen::VectorXN(),
+    "Auu_pd"_a     = params.Auu_pd,
+    "max_iter"_a   = params.max_iter,
+    "inactive_threshold"_a      = params.inactive_threshold,
+    "constraint_threshold"_a    = params.constraint_threshold,
+    "solution_diff_threshold"_a = params.solution_diff_threshold,
+R"(Minimize a convex quadratic energy subject to linear constraints.
+
+Solves:
+    min  0.5 * Z' * A * Z + Z' * B
+     Z
+    subject to
+        Z(known) = Y
+        Aeq * Z = Beq
+        Aieq * Z <= Bieq
+        lx <= Z <= ux
+
+@param[in] A  n by n matrix of quadratic coefficients
+@param[in] B  n by 1 column of linear coefficients
+@param[in] known  list of indices to known rows in Z
+@param[in] Y  list of fixed values corresponding to known rows in Z
+@param[in] Aeq  meq by n list of linear equality constraint coefficients
+@param[in] Beq  meq by 1 list of linear equality constraint constant values
+@param[in] Aieq  mieq by n list of linear inequality constraint coefficients
+@param[in] Bieq  mieq by 1 list of linear inequality constraint constant values
+@param[in] lx  n by 1 list of lower bounds [] implies -Inf
+@param[in] ux  n by 1 list of upper bounds [] implies Inf
+@param[in] Auu_pd  whether Auu is positive definite {false}
+@param[in] max_iter  maximum number of iterations {100}
+@param[in] inactive_threshold  threshold on Lagrange multiplier values {1e-14}
+@param[in] constraint_threshold  threshold on constraint violation {1e-14}
+@param[in] solution_diff_threshold  threshold on solution difference {1e-14}
+@return Z  n by 1 solution vector)"
+  );
+}

libigl-2.6.4.dev0/src/ambient_occlusion.cpp

@@ -0,0 +1,49 @@
+#include "default_types.h"
+#include <igl/ambient_occlusion.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  // Core (embree-free) ambient occlusion: builds an AABB over (V,F) and shoots
+  // rays with libigl's own intersector, so it is available in every wheel
+  // regardless of whether the embree module was built.
+  auto ambient_occlusion(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const nb::DRef<const Eigen::MatrixXN> &P,
+    const nb::DRef<const Eigen::MatrixXN> &N,
+    const int num_samples)
+  {
+    Eigen::VectorXN S;
+    igl::ambient_occlusion(V, F, P, N, num_samples, S);
+    return S;
+  }
+}
+
+void bind_ambient_occlusion(nb::module_ &m)
+{
+  m.def(
+    "ambient_occlusion",
+    &pyigl::ambient_occlusion,
+    "V"_a,
+    "F"_a,
+    "P"_a,
+    "N"_a,
+    "num_samples"_a,
+    R"(Compute ambient occlusion per given point for a mesh (V,F).
+
+This is the embree-free implementation from igl::core; for the (typically
+faster) embree-accelerated version see igl.embree.ambient_occlusion.
+
+@param[in] V  #V by 3 list of mesh vertex positions
+@param[in] F  #F by 3 list of mesh triangle indices into rows of V
+@param[in] P  #P by 3 list of origin points
+@param[in] N  #P by 3 list of origin normals
+@param[in] num_samples  number of rays to shoot per point (e.g. 1000)
+@return S  #P list of ambient occlusion values between 1 (fully occluded) and
+  0 (not occluded))");
+}

libigl-2.6.4.dev0/src/boundary_conditions.cpp

@@ -0,0 +1,67 @@
+#include "default_types.h"
+#include <igl/boundary_conditions.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 boundary_conditions(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &Ele,
+    const nb::DRef<const Eigen::MatrixXN> &C,
+    const nb::DRef<const Eigen::VectorXI> &P,
+    const nb::DRef<const Eigen::MatrixXI> &BE,
+    const nb::DRef<const Eigen::MatrixXI> &CE,
+    const nb::DRef<const Eigen::MatrixXI> &CF)
+  {
+
+    Eigen::VectorXI b;
+    Eigen::MatrixXN bc;
+    if(!igl::boundary_conditions(V, Ele, C, P, BE, CE, CF, b, bc))
+    {
+      throw std::runtime_error("boundary_conditions: failed to compute");
+    }
+    return std::make_tuple(b, bc);
+  }
+}
+
+void bind_boundary_conditions(nb::module_ &m)
+{
+  m.def(
+    "boundary_conditions", 
+    &pyigl::boundary_conditions,
+    "V"_a,
+    "Ele"_a,
+    "C"_a,
+    "P"_a=Eigen::VectorXI(),
+    "BE"_a=Eigen::MatrixXI(),
+    "CE"_a=Eigen::MatrixXI(),
+    "CF"_a=Eigen::MatrixXI(),
+R"(Compute boundary conditions for automatic weights computation. This
+function expects that the given mesh (V,Ele) has sufficient samples
+(vertices) exactly at point handle locations and exactly along bone and
+cage edges/faces.
+@param[in] V  #V by dim list of domain vertices
+@param[in] Ele  #Ele by simplex-size list of simplex indices
+@param[in] C  #C by dim list of handle positions
+@param[in] P  #P by 1 list of point handle indices into C
+@param[in] BE  #BE by 2 list of bone edge indices into C
+@param[in] CE  #CE by 2 list of cage edge indices into *P*
+@param[in] CF  #CF by 3 list of (triangular) cage face indices into *P*
+@param[out] b  #b list of boundary indices (indices into V of vertices which have
+    known, fixed values)
+@param[out] bc #b by #weights list of known/fixed values for boundary vertices
+    (notice the #b != #weights in general because #b will include all the
+    intermediary samples along each bone, etc.. The ordering of the
+    weights corresponds to [P;BE]
+throws error if boundary conditions are suspicious:
+  P and BE are empty
+  bc is empty
+  some column of bc doesn't have a 0 (assuming bc has >1 columns)
+  some column of bc doesn't have a 1 (assuming bc has >1 columns))"
+  );
+}

{libigl-2.6.3.dev4 → libigl-2.6.4.dev0}/src/boundary_loop.cpp

@@ -16,7 +16,7 @@ namespace pyigl
     igl::boundary_loop(F, loops);
     return loops;
   }
-  // Wrapper for boundary_loop that returns all loops as a vector of vectors
+  // Wrapper for boundary_loop that returns only the longest loop as a vector
   auto boundary_loop(const nb::DRef<const Eigen::MatrixXI> &F)
   {
     Eigen::VectorXI longest;

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)");
+}