libigl 2.5.4.dev0__tar.gz → 2.6.1__tar.gz

{libigl-2.5.4.dev0 → libigl-2.6.1}/.github/workflows/pip.yml

@@ -2,10 +2,10 @@ name: Pip
 
 on:
   workflow_dispatch:
-  #pull_request:
-  #push:
-  #  branches:
-  #    - master
+  pull_request:
+  push:
+    branches:
+      - master
 
 jobs:
   build:
@@ -14,7 +14,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        platform: [windows-latest, macos-latest, ubuntu-latest]
+        platform: [windows-latest, macos-latest, ubuntu-latest, ubuntu-24.04-arm]
         python-version: ["3.10"]
 
     steps:

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

@@ -0,0 +1,91 @@
+name: Wheels
+
+on:
+  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-14, macos-13, 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-14   # Exclude macOS 14 (Sonoma)
+            arch: x86_64   # Exclude x86_64 explicitly
+          - os: macos-14 # Exclude cp38
+            pybuilds: cp38
+          - os: macos-13  # Exclude macOS 13 (Ventura) - arm64
+            arch: arm64   # Exclude arm64 on macOS 13
+          - os: macos-13
+            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==2.23.0
+      - run: python -m cibuildwheel --output-dir wheelhouse
+        env:
+          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
+
+  release_artifacts:
+    if: github.event_name == 'push' && contains(github.ref, 'refs/tags/')
+    needs: build_wheels
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: ./artifacts
+          merge-multiple: true
+      - run: ls -R ./artifacts
+      - uses: ncipollo/release-action@v1
+        with:
+          allowUpdates: true
+          artifacts: "./artifacts/**/*"
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: pypa/gh-action-pypi-publish@v1.12.4
+        with:
+          packages-dir: ./artifacts

{libigl-2.5.4.dev0 → libigl-2.6.1}/CMakeLists.txt

@@ -14,13 +14,9 @@ set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15")
 # <20 for embree
 set(CMAKE_CXX_STANDARD 17)
 
-if (CMAKE_VERSION VERSION_LESS 3.18)
-  set(DEV_MODULE Development)
-else()
-  set(DEV_MODULE Development.Module)
-endif()
-
-find_package(Python 3.8 COMPONENTS Interpreter ${DEV_MODULE} REQUIRED)
+find_package(Python 3.8
+  REQUIRED COMPONENTS Interpreter Development.Module
+  OPTIONAL_COMPONENTS Development.SABIModule)
 
 if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
@@ -36,7 +32,7 @@ include(FetchContent)
 FetchContent_Declare(
   nanobind
   GIT_REPOSITORY https://github.com/wjakob/nanobind.git
-  GIT_TAG        v2.2.0
+  GIT_TAG        v2.7.0
 )
 FetchContent_MakeAvailable(nanobind)
 
@@ -49,7 +45,7 @@ option(LIBIGL_RESTRICTED_TRIANGLE  "Build target igl_restricted::triangle" ON)
 FetchContent_Declare(
   libigl
   GIT_REPOSITORY https://github.com/libigl/libigl.git
-  GIT_TAG a221faf1e4bd571529ca2101c08bc2458579b1da
+  GIT_TAG v2.6.0
 )
 FetchContent_MakeAvailable(libigl)
 
@@ -125,7 +121,10 @@ function(pyigl_include prefix name)
     file(WRITE "${generated_dir}/BINDING_INVOCATIONS.in" "${BINDING_INVOCATIONS}")
 
     set(target_name "pyigl${prefix_lc}_${name}")
-    nanobind_add_module(${target_name} ${sources})
+    nanobind_add_module(
+      ${target_name} 
+      STABLE_ABI
+      ${sources})
 
     # important for scikit-build
     install(TARGETS ${target_name} LIBRARY DESTINATION  "igl/${subpath}")

libigl-2.6.1/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.1
+Name: libigl
+Version: 2.6.1
+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)
+Project-URL: Homepage, https://github.com/libigl/libigl-python-bindings
+Requires-Python: >=3.8
+Requires-Dist: numpy
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+# libigl Python Bindings
+[![PyPI version](https://badge.fury.io/py/libigl.svg)](https://pypi.org/project/libigl/)
+[![buildwheels](https://github.com/libigl/libigl-python-bindings/actions/workflows/wheels.yml/badge.svg)](https://github.com/libigl/libigl-python-bindings/actions/workflows/wheels.yml?query=branch%3Amain)
+
+This repository contains the source code for the python bindings for the C++
+[libigl](https://github.com/libigl/libigl) library written using
+[nanobind](https://nanobind.readthedocs.io/en/latest/). Functions allow NumPy
+arrays as input and output for dense matrices and vectors and SciPy sparse
+matrices for sparse matrices. 
+
+## Installation
+
+```
+python -m pip install libigl
+```
+
+## Documentation
+
+| :warning: WARNING           |
+|:----------------------------|
+| The [python-binding documentation](https://libigl.github.io/libigl-python-bindings/) is perennially out of date and will likely be removed/changed. |
+
+* A tutorial on how to use the bindings can be found [here](https://libigl.github.io/libigl-python-bindings/tutorials/)
+* A function reference can be found [here](https://libigl.github.io/libigl-python-bindings/igl_docs/)
+
+## Getting the current version of libigl within python code
+
+Since version 2.5.4.dev0, the `igl.__version__` attribute has been removed. To
+get the version of the libigl package you're using within your python code, you
+can use the following code:
+
+```
+import importlib.metadata
+libigl_version = importlib.metadata.version('libigl')
+```
+
+The version of libigl is defined in the [pyproject.toml](./pyproject.toml) file.
+
+
+## Compiling and modifying the bindiings
+
+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:
+
+ 1. Preinstall the dependencies (at the top of pyproject.toml 
+ 2. Then use this very long command:
+
+```
+CMAKE_BUILD_PARALLEL_LEVEL=10  python -m pip install --no-build-isolation --config-settings=editable.rebuild=true -Cbuild-dir=build -ve.
+```
+
+The `CMAKE_BUILD_PARALLEL_LEVEL=10` will invoke with 10 parallel build threads.
+
+### Adding a missing binding
+
+Bindings are fairly mechanical to write. For example, suppose we didn't have a
+binding for the c++ function `igl::moments`. The first step would be to look at
+the corresponding `.h` header file in the C++ libigl library:
+[moments.h](https://github.com/libigl/libigl/blob/main/include/igl/moments.h).
+
+Then we would create the [src/moments.cpp](src/moments.cpp) file in this project
+which uses `Eigen::MatrixXN` for numeric types and `Eigen::MatrixXI` for integer
+types. Typically this requires a simple wrapper around the function matching
+its signature to these types and some boilerplate `void bind_moments(...` code which adds the function to the python module.
+
+Simply adding this `.cpp` file will be enough to add the bindings on the next
+build.
+
+If submitting a pull request with a new binding, please also add an execution
+test in `tests/test_all.py` to ensure the binding can at least be called as
+expected.
+
+
+## Testing cibuildwheel locally
+
+Install whichever version of Python from the [official website](https://www.python.org/downloads/) and then run:
+
+    
+    /Library/Frameworks/Python.framework/Versions/3.11/bin/python3.11 -m venv venv-official-3.11
+    source venv-official-3.11/bin/activate
+    python -m pip install cibuildwheel
+    CIBW_BUILD="cp311-*" python -m cibuildwheel --output-dir wheelhouse --platform macos
+
+## Downloading all the artifacts
+
+A successful [.github/workflows/wheels.yml](.github/workflows/wheels.yml) run will a lot of `.whl` files. To download these all at once, you can use the following command:
+
+    mkdir wheelhouse
+    cd wheelhouse
+    gh run download [runid]
+
+Then these can be uploaded to pypi using:
+
+    python -m twine upload --repository testpypi wheelhouse/*/*.whl wheelhouse/*/*.tar.gz
+
+## Acknowledgements
+
+The original python bindings were generated and maintained by
+[@teseoch](https://github.com/teseoch),
+[@KarlLeell](https://github.com/KarlLeell),
+[@fwilliams](https://github.com/fwilliams),
+[@skoch9](https://github.com/skoch9), and
+[@danielepanozzo](https://github.com/danielepanozzo)
+
+The modern python bindings (since 2.5.4.dev0) can largely be blamed on
+[@alecjacobson](https://github.com/alecjacobson).

libigl-2.6.1/README.md

@@ -0,0 +1,105 @@
+# libigl Python Bindings
+[![PyPI version](https://badge.fury.io/py/libigl.svg)](https://pypi.org/project/libigl/)
+[![buildwheels](https://github.com/libigl/libigl-python-bindings/actions/workflows/wheels.yml/badge.svg)](https://github.com/libigl/libigl-python-bindings/actions/workflows/wheels.yml?query=branch%3Amain)
+
+This repository contains the source code for the python bindings for the C++
+[libigl](https://github.com/libigl/libigl) library written using
+[nanobind](https://nanobind.readthedocs.io/en/latest/). Functions allow NumPy
+arrays as input and output for dense matrices and vectors and SciPy sparse
+matrices for sparse matrices. 
+
+## Installation
+
+```
+python -m pip install libigl
+```
+
+## Documentation
+
+| :warning: WARNING           |
+|:----------------------------|
+| The [python-binding documentation](https://libigl.github.io/libigl-python-bindings/) is perennially out of date and will likely be removed/changed. |
+
+* A tutorial on how to use the bindings can be found [here](https://libigl.github.io/libigl-python-bindings/tutorials/)
+* A function reference can be found [here](https://libigl.github.io/libigl-python-bindings/igl_docs/)
+
+## Getting the current version of libigl within python code
+
+Since version 2.5.4.dev0, the `igl.__version__` attribute has been removed. To
+get the version of the libigl package you're using within your python code, you
+can use the following code:
+
+```
+import importlib.metadata
+libigl_version = importlib.metadata.version('libigl')
+```
+
+The version of libigl is defined in the [pyproject.toml](./pyproject.toml) file.
+
+
+## Compiling and modifying the bindiings
+
+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:
+
+ 1. Preinstall the dependencies (at the top of pyproject.toml 
+ 2. Then use this very long command:
+
+```
+CMAKE_BUILD_PARALLEL_LEVEL=10  python -m pip install --no-build-isolation --config-settings=editable.rebuild=true -Cbuild-dir=build -ve.
+```
+
+The `CMAKE_BUILD_PARALLEL_LEVEL=10` will invoke with 10 parallel build threads.
+
+### Adding a missing binding
+
+Bindings are fairly mechanical to write. For example, suppose we didn't have a
+binding for the c++ function `igl::moments`. The first step would be to look at
+the corresponding `.h` header file in the C++ libigl library:
+[moments.h](https://github.com/libigl/libigl/blob/main/include/igl/moments.h).
+
+Then we would create the [src/moments.cpp](src/moments.cpp) file in this project
+which uses `Eigen::MatrixXN` for numeric types and `Eigen::MatrixXI` for integer
+types. Typically this requires a simple wrapper around the function matching
+its signature to these types and some boilerplate `void bind_moments(...` code which adds the function to the python module.
+
+Simply adding this `.cpp` file will be enough to add the bindings on the next
+build.
+
+If submitting a pull request with a new binding, please also add an execution
+test in `tests/test_all.py` to ensure the binding can at least be called as
+expected.
+
+
+## Testing cibuildwheel locally
+
+Install whichever version of Python from the [official website](https://www.python.org/downloads/) and then run:
+
+    
+    /Library/Frameworks/Python.framework/Versions/3.11/bin/python3.11 -m venv venv-official-3.11
+    source venv-official-3.11/bin/activate
+    python -m pip install cibuildwheel
+    CIBW_BUILD="cp311-*" python -m cibuildwheel --output-dir wheelhouse --platform macos
+
+## Downloading all the artifacts
+
+A successful [.github/workflows/wheels.yml](.github/workflows/wheels.yml) run will a lot of `.whl` files. To download these all at once, you can use the following command:
+
+    mkdir wheelhouse
+    cd wheelhouse
+    gh run download [runid]
+
+Then these can be uploaded to pypi using:
+
+    python -m twine upload --repository testpypi wheelhouse/*/*.whl wheelhouse/*/*.tar.gz
+
+## Acknowledgements
+
+The original python bindings were generated and maintained by
+[@teseoch](https://github.com/teseoch),
+[@KarlLeell](https://github.com/KarlLeell),
+[@fwilliams](https://github.com/fwilliams),
+[@skoch9](https://github.com/skoch9), and
+[@danielepanozzo](https://github.com/danielepanozzo)
+
+The modern python bindings (since 2.5.4.dev0) can largely be blamed on
+[@alecjacobson](https://github.com/alecjacobson).

{libigl-2.5.4.dev0 → libigl-2.6.1}/cmake/Warnings.cmake

@@ -1,5 +1,5 @@
 ################################################################################
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.5)
 ################################################################################
 # See comments and discussions here:
 # http://stackoverflow.com/questions/5088460/flags-to-enable-thorough-and-verbose-g-warnings

{libigl-2.5.4.dev0 → libigl-2.6.1}/priority.txt

@@ -7,13 +7,11 @@ euler_characteristic.cpp
 grad_intrinsic.cpp
 hessian.cpp
 hessian_energy.cpp
-internal_angles.cpp
 is_delaunay.cpp
 is_intrinsic_delaunay.cpp
 is_irregular_vertex.cpp
 iterative_closest_point.cpp
 lbs_matrix.cpp
-map_vertices_to_circle.cpp
 marching_tets.cpp
 mvc.cpp
 offset_surface.cpp
@@ -35,7 +33,6 @@ sparse_voxel_grid.cpp
 tet_tet_adjacency.cpp
 
 active_set.cpp
-all_pairs_distances.cpp
 ambient_occlusion.cpp
 arap_linear_block.cpp
 arap_rhs.cpp

{libigl-2.5.4.dev0 → libigl-2.6.1}/pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "libigl"
-version = "2.5.4dev"
+version = "2.6.1"
 description = "libigl: A simple C++ geometry processing library"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -42,10 +42,12 @@ build-dir = "build/{wheel_tag}"
 # Build stable ABI wheels for CPython 3.12+
 wheel.py-api = "cp312"
 
+
 [tool.scikit-build.cmake]
 build-type = "Release"
 
 [tool.cibuildwheel]
+archs = "auto64"
 # Necessary to see build output from the actual compilation
 build-verbosity = 1
 
@@ -53,6 +55,10 @@ build-verbosity = 1
 test-command = "pytest {project}/tests"
 test-requires = "pytest"
 
+# linux images
+manylinux-x86_64-image = "quay.io/pypa/manylinux_2_28_x86_64"
+manylinux-aarch64-image = "quay.io/pypa/manylinux_2_28_aarch64"
+
 # Don't test Python 3.8 wheels on macOS/arm64
 test-skip="cp38-macosx_*:arm64"
 

libigl-2.6.1/src/all_pairs_distances.cpp

@@ -0,0 +1,37 @@
+#include "default_types.h"
+#include <igl/all_pairs_distances.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+namespace pyigl
+{
+  auto all_pairs_distances(
+      const Eigen::MatrixXd &V,
+      const Eigen::MatrixXd &U,
+      const bool squared)
+  {
+    Eigen::MatrixXd D;
+    igl::all_pairs_distances(V, U, squared, D);
+    return D;
+  }
+}
+
+void bind_all_pairs_distances(nb::module_ &m)
+{
+  m.def("all_pairs_distances", &pyigl::all_pairs_distances,
+        "V"_a,
+        "U"_a,
+        "squared"_a,
+        R"(Compute distances between each point i in V and point j in U
+    D = all_pairs_distances(V,U)
+@tparam matrix class like MatrixXd
+@param[in] V  #V by dim list of points
+@param[in] U  #U by dim list of points
+@param[in] squared  whether to return squared distances
+@param[out] D  #V by #U matrix of distances, where D(i,j) gives the distance or
+    squareed distance between V(i,:) and U(j,:)
+)");
+}

{libigl-2.5.4.dev0 → libigl-2.6.1}/src/copyleft/cgal/remesh_self_intersections.cpp

@@ -61,7 +61,9 @@ void bind_remesh_self_intersections(nb::module_ &m)
       - VV: remeshed vertex positions
       - FF: remeshed face indices
       - IF: intersecting face pairs
-      - J: birth triangle indices)");
-
+      - J: birth triangle indices
+      - IM if stitch_all = true   #VV list from 0 to #VV-1
+           elseif stitch_all = false  #VV list of indices into VV of unique vertices.
+      )");
 }
 

libigl-2.6.1/src/internal_angles.cpp

@@ -0,0 +1,31 @@
+#include "default_types.h"
+#include <igl/internal_angles.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+namespace pyigl
+{
+  auto internal_angles(
+      const nb::DRef<const Eigen::MatrixXN> &V,
+      const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::MatrixXN K;
+    igl::internal_angles(V, F, K);
+    return K;
+  }
+}
+
+void bind_internal_angles(nb::module_ &m)
+{
+  m.def("internal_angles", &pyigl::internal_angles,
+        "V"_a,
+        "F"_a,
+        R"(Compute internal angles for all tets of a given tet mesh (V,T).
+@param[in] V  #V by dim eigen Matrix of mesh vertex nD positions
+@param[in] F  #F by poly-size eigen Matrix of face (triangle) indices
+@param[out] K  #F by poly-size eigen Matrix of internal angles
+    for triangles, columns correspond to edges [1,2],[2,0],[0,1])");
+}

libigl-2.6.1/src/is_vertex_manifold.cpp

@@ -0,0 +1,38 @@
+#include "default_types.h"
+#include <igl/is_vertex_manifold.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  // Wrapper for is_vertex_manifold with overload handling
+  auto is_vertex_manifold(
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::Matrix<bool, Eigen::Dynamic, 1> B;
+    igl::is_vertex_manifold(F, B);
+    return B;
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_is_vertex_manifold(nb::module_ &m)
+{
+  m.def(
+    "is_vertex_manifold",
+    &pyigl::is_vertex_manifold,
+    "F"_a,
+R"(Check if a mesh is vertex-manifold.
+
+This only checks whether the faces incident on each vertex form exactly one
+connected component. Vertices incident on non-manifold edges are not consider
+non-manifold by this function (see is_edge_manifold). Unreferenced verties are
+considered non-manifold (zero components).
+
+@param[in] F  #F by 3 list of triangle indices
+@return B  #V list indicate whether each vertex is locally manifold (the mesh is vertex manifold if all(B) == True)");
+}

libigl-2.6.1/src/map_vertices_to_circle.cpp

@@ -0,0 +1,33 @@
+#include "default_types.h"
+#include <igl/map_vertices_to_circle.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/vector.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+namespace pyigl
+{
+  auto map_vertices_to_circle(
+      const Eigen::MatrixXd &V,
+      const Eigen::VectorXi &bnd)
+  {
+    Eigen::MatrixXd UV;
+    igl::map_vertices_to_circle(V, bnd, UV);
+    return UV;
+  }
+}
+
+void bind_map_vertices_to_circle(nb::module_ &m)
+{
+  m.def("map_vertices_to_circle", &pyigl::map_vertices_to_circle,
+        "V"_a,
+        "bnd"_a,
+        R"(Map the vertices whose indices are in a given boundary loop (bnd) on the
+unit circle with spacing proportional to the original boundary edge
+lengths.
+@param[in] V  #V by dim list of mesh vertex positions
+@param[in] b  #W list of vertex ids
+@param[out] UV   #W by 2 list of 2D position on the unit circle for the vertices in b)");
+}

libigl-2.6.1/src/sparse_map_noop.cpp

@@ -0,0 +1,27 @@
+#include "default_types.h"
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/sparse.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto sparse_map_noop( const Eigen::Map<const Eigen::SparseMatrix<Integer>> &A)
+  {
+    return A;
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_sparse_map_noop(nb::module_ &m)
+{
+  m.def(
+    "sparse_map_noop",
+    &pyigl::sparse_map_noop,
+    "A"_a,
+R"("Returns input A)");
+}
+

libigl-2.6.1/src/sparse_map_shape.cpp

@@ -0,0 +1,29 @@
+#include "default_types.h"
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/sparse.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto sparse_map_shape( const Eigen::Map<const Eigen::SparseMatrix<Integer>> &A)
+  {
+    Eigen::Matrix<Integer,2,1> dims(A.rows(), A.cols());
+    return dims;
+  }
+}
+
+// Bind the wrapper to the Python module
+void bind_sparse_map_shape(nb::module_ &m)
+{
+  m.def(
+    "sparse_map_shape",
+    &pyigl::sparse_map_shape,
+    "A"_a,
+R"("Returns shape of A as 2-vector)");
+}
+
+