libigl 2.6.3.dev4__tar.gz → 2.6.3.dev5__tar.gz

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

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

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

@@ -0,0 +1,180 @@
+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
+          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.3.dev4 → libigl-2.6.3.dev5}/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 0cbcaf886314ff331402c38fbb04cc4de8d7c033
 )
 FetchContent_MakeAvailable(libigl)
 
@@ -208,4 +208,3 @@ if(LIBIGL_CYCODEBASE)
 endif()
 
 
-

{libigl-2.6.3.dev4 → libigl-2.6.3.dev5}/PKG-INFO

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

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

libigl-2.6.3.dev5/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.3.dev5}/pyproject.toml

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

libigl-2.6.3.dev5/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.3.dev5/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.3.dev5/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.3.dev5}/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.3.dev5/src/cycodebase/point_cubic_squared_distance.cpp

@@ -0,0 +1,67 @@
+#include "default_types.h"
+#include <igl/cycodebase/point_cubic_squared_distance.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+#include <tuple>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto point_cubic_squared_distance(
+    const nb::DRef<const Eigen::MatrixXN> &Q,
+    const nb::DRef<const Eigen::MatrixXN> &C)
+  {
+    Eigen::VectorXN sqrD, S;
+    Eigen::MatrixXN K;
+    igl::cycodebase::point_cubic_squared_distance(Q, C, sqrD, S, K);
+    return std::make_tuple(sqrD, S, K);
+  }
+
+  // Precomputed overload: reuse the monomial bases (D, B) from
+  // igl.cubic_monomial_bases so repeated queries don't recompute them.
+  auto point_cubic_squared_distance_bases(
+    const nb::DRef<const Eigen::MatrixXN> &Q,
+    const nb::DRef<const Eigen::MatrixXN> &C,
+    const nb::DRef<const Eigen::MatrixXN> &D,
+    const nb::DRef<const Eigen::VectorXN> &B)
+  {
+    Eigen::VectorXN sqrD, S;
+    Eigen::MatrixXN K;
+    igl::cycodebase::point_cubic_squared_distance(Q, C, D, B, sqrD, S, K);
+    return std::make_tuple(sqrD, S, K);
+  }
+}
+
+void bind_point_cubic_squared_distance(nb::module_ &m)
+{
+  m.def("point_cubic_squared_distance", &pyigl::point_cubic_squared_distance,
+    "Q"_a, "C"_a,
+    R"(Squared distance from each query point to a cubic Bézier curve.
+
+@param[in] Q  #Q by dim matrix of query points
+@param[in] C  4 by dim matrix of control points for the cubic Bézier curve
+@return Tuple (sqrD, S, K) where
+  sqrD  #Q vector of smallest squared distances
+  S     #Q vector of parameters of the closest points on the curve
+  K     #Q by dim matrix of closest points on the curve)");
+
+  m.def("point_cubic_squared_distance", &pyigl::point_cubic_squared_distance_bases,
+    "Q"_a, "C"_a, "D"_a, "B"_a,
+    R"(Squared distance to a cubic Bézier curve, reusing precomputed monomial bases.
+
+Compute the bases once with igl.cubic_monomial_bases(C) -> (M, D, B) and pass
+(D, B) here so repeated queries against the same curve skip recomputing them.
+The result matches the two-argument overload.
+
+@param[in] Q  #Q by dim matrix of query points
+@param[in] C  4 by dim matrix of control points for the cubic Bézier curve
+@param[in] D  3 by dim matrix of monomial coefficients for dC/dt (from cubic_monomial_bases)
+@param[in] B  6-vector of inner products of the monomial bases (from cubic_monomial_bases)
+@return Tuple (sqrD, S, K) where
+  sqrD  #Q vector of smallest squared distances
+  S     #Q vector of parameters of the closest points on the curve
+  K     #Q by dim matrix of closest points on the curve)");
+}

libigl-2.6.3.dev5/src/cycodebase/point_spline_squared_distance.cpp

@@ -0,0 +1,78 @@
+#include "default_types.h"
+#include <igl/cycodebase/point_spline_squared_distance.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+#include <tuple>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto point_spline_squared_distance(
+    const nb::DRef<const Eigen::MatrixXN> &Q,
+    const nb::DRef<const Eigen::MatrixXN> &P,
+    const nb::DRef<const Eigen::MatrixXI> &C)
+  {
+    Eigen::VectorXN sqrD, S;
+    Eigen::VectorXI I;
+    Eigen::MatrixXN K;
+    igl::cycodebase::point_spline_squared_distance(Q, P, C, sqrD, I, S, K);
+    return std::make_tuple(sqrD, I, S, K);
+  }
+
+  // Accelerated overload: reuse a prebuilt Eytzinger AABB (B1, B2, leaf) from
+  // igl.cycodebase.spline_eytzinger_aabb so repeated queries don't rebuild it.
+  auto point_spline_squared_distance_aabb(
+    const nb::DRef<const Eigen::MatrixXN> &Q,
+    const nb::DRef<const Eigen::MatrixXN> &P,
+    const nb::DRef<const Eigen::MatrixXI> &C,
+    const nb::DRef<const Eigen::MatrixXN> &B1,
+    const nb::DRef<const Eigen::MatrixXN> &B2,
+    const nb::DRef<const Eigen::VectorXI> &leaf)
+  {
+    Eigen::VectorXN sqrD, S;
+    Eigen::VectorXI I;
+    Eigen::MatrixXN K;
+    igl::cycodebase::point_spline_squared_distance(
+      Q, P, C, B1, B2, leaf, sqrD, I, S, K);
+    return std::make_tuple(sqrD, I, S, K);
+  }
+}
+
+void bind_point_spline_squared_distance(nb::module_ &m)
+{
+  m.def("point_spline_squared_distance", &pyigl::point_spline_squared_distance,
+    "Q"_a, "P"_a, "C"_a,
+    R"(Squared distance from each query point to a spline of cubic Bézier curves.
+
+@param[in] Q  #Q by dim matrix of query points
+@param[in] P  #P by dim matrix of spline control points
+@param[in] C  #C by 4 matrix of indices into P defining the cubic Bézier curves
+@return Tuple (sqrD, I, S, K) where
+  sqrD  #Q vector of smallest squared distances
+  I     #Q vector of indices of the closest cubic (row of C)
+  S     #Q vector of parameters of the closest points on that cubic
+  K     #Q by dim matrix of closest points on the spline)");
+
+  m.def("point_spline_squared_distance", &pyigl::point_spline_squared_distance_aabb,
+    "Q"_a, "P"_a, "C"_a, "B1"_a, "B2"_a, "leaf"_a,
+    R"(Squared distance to a spline, reusing a prebuilt Eytzinger AABB.
+
+Build the AABB once with igl.cycodebase.spline_eytzinger_aabb(P, C) and pass its
+(B1, B2, leaf) here so repeated queries against the same spline skip rebuilding
+the acceleration structure. The result matches the unaccelerated overload.
+
+@param[in] Q     #Q by dim matrix of query points
+@param[in] P     #P by dim matrix of spline control points
+@param[in] C     #C by 4 matrix of indices into P defining the cubic Bézier curves
+@param[in] B1    #B by dim matrix of AABB min box corners (from spline_eytzinger_aabb)
+@param[in] B2    #B by dim matrix of AABB max box corners (from spline_eytzinger_aabb)
+@param[in] leaf  #B vector of AABB leaf node indices/flags (from spline_eytzinger_aabb)
+@return Tuple (sqrD, I, S, K) where
+  sqrD  #Q vector of smallest squared distances
+  I     #Q vector of indices of the closest cubic (row of C)
+  S     #Q vector of parameters of the closest points on that cubic
+  K     #Q by dim matrix of closest points on the spline)");
+}