libigl 2.6.2.dev0__tar.gz → 2.6.3__tar.gz

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

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

libigl-2.6.3/.github/workflows/wheels.yml

@@ -0,0 +1,183 @@
+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 }}
+    strategy:
+      fail-fast: false
+      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
+        exclude:
+          - os: ubuntu-24.04-arm  # No need to specify arch, it's already implicit
+            arch: x86_64  # Exclude x86_64 on ARM
+          - 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
+
+    name: >
+      ${{ matrix.pybuilds }} ${{ matrix.os }} ${{ matrix.arch }}
+
+    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 }}-*"  # Use matrix.pybuilds and matrix.arch
+          CIBW_ARCHS_MACOS: ${{ matrix.arch }}
+          CIBW_SKIP: "cp*-manylinux_i686 cp*-musllinux* cp*-win32"
+      - 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 }}
+          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.2.dev0 → libigl-2.6.3}/.gitignore

@@ -5,6 +5,7 @@ external
 bin
 bin_rel
 build
+build-full
 
 tutorial/data
 tutorial/.ipynb_*
@@ -18,7 +19,7 @@ __pycache__
 igl.egg-info
 libigl.egg-info
 *.code-workspace
-out.obj
+out.*
 test.off
 .vscode
 
@@ -40,3 +41,5 @@ junit
 *~
 dist/
 igl/*
+CLAUDE.md
+wheelhouse/

libigl-2.6.3/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.2.dev0 → libigl-2.6.3}/CMakeLists.txt

@@ -36,16 +36,31 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(nanobind)
 
+# Pin Eigen to 3.4.0. Recent libigl bumped its Eigen dependency to 5.0.1, whose
+# stricter ScalarBinaryOpTraits rejects the int64-vs-int comparisons in some
+# libigl headers (e.g. unique_edge_map), which the 64-bit-index Python bindings
+# instantiate. Declaring Eigen first makes FetchContent use this version instead
+# of the one requested by libigl's own recipe.
+FetchContent_Declare(
+  eigen
+  GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
+  GIT_TAG        tags/3.4.0
+  GIT_SHALLOW    TRUE
+)
+
 # Download and set up libigl
 option(LIBIGL_COPYLEFT_CORE        "Build target igl_copyleft::core"       ON)
 option(LIBIGL_COPYLEFT_CGAL        "Build target igl_copyleft::cgal"       ON)
 option(LIBIGL_EMBREE               "Build target igl::embree"              ON)
 option(LIBIGL_COPYLEFT_TETGEN      "Build target igl_copyleft::tetgen"     ON)
 option(LIBIGL_RESTRICTED_TRIANGLE  "Build target igl_restricted::triangle" ON)
+option(LIBIGL_SPECTRA              "Build igl::spectra bindings"           ON)
+option(LIBIGL_PREDICATES           "Build igl::predicates bindings"        ON)
+option(LIBIGL_CYCODEBASE           "Build igl::cycodebase bindings"        ON)
 FetchContent_Declare(
   libigl
   GIT_REPOSITORY https://github.com/libigl/libigl.git
-  GIT_TAG 678e1fff76815e0c4c5d1f025ee2129181cc7d86
+  GIT_TAG f68f01c23ac82351e2543ce8c529b6d4c89fdf16
 )
 FetchContent_MakeAvailable(libigl)
 
@@ -182,6 +197,14 @@ endif()
 if(LIBIGL_RESTRICTED_TRIANGLE)
   pyigl_include("restricted" "triangle")
 endif()
-
+if(LIBIGL_SPECTRA)
+  pyigl_include("" "spectra")
+endif()
+if(LIBIGL_PREDICATES)
+  pyigl_include("" "predicates")
+endif()
+if(LIBIGL_CYCODEBASE)
+  pyigl_include("" "cycodebase")
+endif()
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libigl
-Version: 2.6.2.dev0
+Version: 2.6.3
 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)
@@ -48,7 +48,7 @@ libigl_version = importlib.metadata.version('libigl')
 The version of libigl is defined in the [pyproject.toml](./pyproject.toml) file.
 
 
-## Compiling and modifying the bindiings
+## Compiling and modifying the bindings
 
 According to the [scikit-build-core documentation](https://scikit-build-core.readthedocs.io/en/latest/configuration.html#editable-installs), the way to make an editable (incremental) build is to:
 
@@ -81,6 +81,20 @@ test in `tests/test_all.py` to ensure the binding can at least be called as
 expected.
 
 
+### Packaging a wheel from an existing build
+
+If you already have a compiled build directory, you can package it into a
+`.whl` without recompiling and install that wheel into other virtual
+environments on the same machine:
+
+```
+python -m pip wheel --no-build-isolation --no-deps -Cbuild-dir=build -w wheelhouse .
+pip install wheelhouse/libigl-*.whl
+```
+
+The `--no-deps` flag skips bundling numpy/scipy (the target environment must
+have them already). No compiler or CMake is required in the target environment.
+
 ## Testing cibuildwheel locally
 
 Install whichever version of Python from the [official website](https://www.python.org/downloads/) and then run:
@@ -101,7 +115,9 @@ A successful [.github/workflows/wheels.yml](.github/workflows/wheels.yml) run wi
 
 Then these can be uploaded to pypi using:
 
-    python -m twine upload --repository testpypi wheelhouse/*/*.whl wheelhouse/*/*.tar.gz
+    for f in wheelhouse/*/*.whl wheelhouse/*/*.tar.gz; do
+        python3 -m twine upload --repository pypi "$f" || echo "Skipping failed upload: $f"
+    done
 
 ## Acknowledgements
 

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

@@ -36,7 +36,7 @@ libigl_version = importlib.metadata.version('libigl')
 The version of libigl is defined in the [pyproject.toml](./pyproject.toml) file.
 
 
-## Compiling and modifying the bindiings
+## Compiling and modifying the bindings
 
 According to the [scikit-build-core documentation](https://scikit-build-core.readthedocs.io/en/latest/configuration.html#editable-installs), the way to make an editable (incremental) build is to:
 
@@ -69,6 +69,20 @@ test in `tests/test_all.py` to ensure the binding can at least be called as
 expected.
 
 
+### Packaging a wheel from an existing build
+
+If you already have a compiled build directory, you can package it into a
+`.whl` without recompiling and install that wheel into other virtual
+environments on the same machine:
+
+```
+python -m pip wheel --no-build-isolation --no-deps -Cbuild-dir=build -w wheelhouse .
+pip install wheelhouse/libigl-*.whl
+```
+
+The `--no-deps` flag skips bundling numpy/scipy (the target environment must
+have them already). No compiler or CMake is required in the target environment.
+
 ## Testing cibuildwheel locally
 
 Install whichever version of Python from the [official website](https://www.python.org/downloads/) and then run:
@@ -89,7 +103,9 @@ A successful [.github/workflows/wheels.yml](.github/workflows/wheels.yml) run wi
 
 Then these can be uploaded to pypi using:
 
-    python -m twine upload --repository testpypi wheelhouse/*/*.whl wheelhouse/*/*.tar.gz
+    for f in wheelhouse/*/*.whl wheelhouse/*/*.tar.gz; do
+        python3 -m twine upload --repository pypi "$f" || echo "Skipping failed upload: $f"
+    done
 
 ## Acknowledgements
 

{libigl-2.6.2.dev0 → libigl-2.6.3}/include/default_types.h

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

libigl-2.6.3/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/memory/MEMORY.md

@@ -0,0 +1,26 @@
+# libigl-python-bindings memory
+
+## Project
+Python bindings for libigl C++ geometry library using nanobind + scikit-build-core.
+C++ libigl source lives at `build/_deps/libigl-src/include/igl/` (fetched by CMake).
+
+## Binding Architecture
+- Each `src/<name>.cpp` → corresponds to `build/_deps/libigl-src/include/igl/<name>.h`
+- CMake globs all `.cpp` files, generates `BINDING_DECLARATIONS.in` / `BINDING_INVOCATIONS.in`, `module.cpp` includes them — adding a `.cpp` auto-registers it
+- Types centralized in `include/default_types.h`: `Numeric=double`, `Integer=int64_t`, `RowMajor`
+- Zero-copy input: `nb::DRef<const Eigen::MatrixXN>` (requires C-contiguous float64)
+- Multiple C++ output params → `std::make_tuple(...)` → Python tuple unpacking
+- Sparse output: `Eigen::SparseMatrixN` + `<nanobind/eigen/sparse.h>` → scipy CSR automatically
+
+## Submodules
+- `src/` → `igl` (core, MPL2)
+- `src/copyleft/` → `igl.copyleft` (GPL)
+- `src/copyleft/cgal/` → `igl.copyleft.cgal`
+- `src/embree/` → `igl.embree`
+- `src/triangle/` → `igl.triangle`
+
+## Key Gotchas
+- numpy `int32`/`float32` silently copies; always use `int64`/`float64` in tests
+- In-place mutation: use `Eigen::Ref<>` + `.noconvert()` on the arg
+- Class templates must be typedef'd to concrete type before `nb::class_<>`
+- Sparse inputs must be `scipy.sparse.csr_matrix`

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

@@ -1,9 +1,8 @@
 [build-system]
 requires = [
-    "cmake>=3.16",
     "nanobind >=1.3.2",
     "numpy>=2.0.0; python_version >= '3.9'",
-    "numpy; python_version < '3.9'",
+    "numpy<2.0.0; python_version < '3.9'",
     "packaging",
     "scikit-build-core >=0.10", 
     "scipy",
@@ -14,7 +13,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "libigl"
-version = "2.6.2.dev0"
+version = "2.6.3"
 description = "libigl: A simple C++ geometry processing library"
 readme = "README.md"
 requires-python = ">=3.8"

libigl-2.6.3/src/accumarray.cpp

@@ -0,0 +1,48 @@
+#include "default_types.h"
+#include <igl/accumarray.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto accumarray_V(
+    const nb::DRef<const Eigen::MatrixXI> &S,
+    const nb::DRef<const Eigen::MatrixXN> &V)
+  {
+    // Copy to compact column vectors so single-index (i) access works
+    const Eigen::VectorXI s = S.reshaped();
+    const Eigen::VectorXN v = V.reshaped();
+    Eigen::VectorXN A;
+    igl::accumarray(s, v, A);
+    return A;
+  }
+  auto accumarray_val(
+    const nb::DRef<const Eigen::MatrixXI> &S,
+    const Numeric val)
+  {
+    const Eigen::VectorXI s = S.reshaped();
+    Eigen::VectorXN A;
+    igl::accumarray(s, val, A);
+    return A;
+  }
+}
+
+void bind_accumarray(nb::module_ &m)
+{
+  m.def("accumarray", &pyigl::accumarray_V, "S"_a, "V"_a,
+    R"(Accumulate values V at subscripts S. Like MATLAB's accumarray.
+
+@param[in] S  #S list of subscripts (integer indices)
+@param[in] V  #S list of values
+@return A  max(S)+1 list of accumulated (summed) values)");
+
+  m.def("accumarray", &pyigl::accumarray_val, "S"_a, "val"_a,
+    R"(Accumulate a constant value at subscripts S. Like MATLAB's accumarray.
+
+@param[in] S  #S list of subscripts (integer indices)
+@param[in] val  scalar value to accumulate at each subscript
+@return A  max(S)+1 list of accumulated (summed) values)");
+}

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