libigl 2.6.2.dev0__tar.gz → 2.6.3.dev2__tar.gz

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

@@ -1,6 +1,7 @@
 name: Wheels
 
 on:
+  workflow_dispatch:
   push:
     branches:
       - main
@@ -27,19 +28,19 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-24.04, ubuntu-24.04-arm, macos-14, macos-13, windows-latest]  # Use specific versions for clarity
+        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-14   # Exclude macOS 14 (Sonoma)
+          - os: macos-latest
             arch: x86_64   # Exclude x86_64 explicitly
-          - os: macos-14 # Exclude cp38
+          - os: macos-latest # Exclude cp38
             pybuilds: cp38
-          - os: macos-13  # Exclude macOS 13 (Ventura) - arm64
+          - os: macos-15-intel
             arch: arm64   # Exclude arm64 on macOS 13
-          - os: macos-13
+          - os: macos-15-intel
             pybuilds: cp38
 
     name: >
@@ -50,9 +51,14 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
-      - run: pip install cibuildwheel==2.23.0
-      - run: python -m cibuildwheel --output-dir wheelhouse
+      - 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"
@@ -86,6 +92,6 @@ jobs:
           allowUpdates: true
           artifacts: "./artifacts/**/*"
           token: ${{ secrets.GITHUB_TOKEN }}
-      - uses: pypa/gh-action-pypi-publish@v1.12.4
+      - uses: pypa/gh-action-pypi-publish@v1.13.0
         with:
           packages-dir: ./artifacts

{libigl-2.6.2.dev0 → libigl-2.6.3.dev2}/.gitignore

@@ -40,3 +40,4 @@ junit
 *~
 dist/
 igl/*
+CLAUDE.md

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libigl
-Version: 2.6.2.dev0
+Version: 2.6.3.dev2
 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)
@@ -101,7 +101,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.dev2}/README.md

@@ -89,7 +89,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.3.dev2/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.dev2}/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.dev2"
 description = "libigl: A simple C++ geometry processing library"
 readme = "README.md"
 requires-python = ">=3.8"

libigl-2.6.3.dev2/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.dev2/src/barycentric_interpolation.cpp

@@ -0,0 +1,36 @@
+#include "default_types.h"
+#include <igl/barycentric_interpolation.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto barycentric_interpolation(
+    const nb::DRef<const Eigen::MatrixXN> &D,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const nb::DRef<const Eigen::MatrixXN> &B,
+    const nb::DRef<const Eigen::MatrixXI> &I)
+  {
+    // I is indexed as a vector internally
+    const Eigen::VectorXI idx = I.reshaped();
+    Eigen::MatrixXN X;
+    igl::barycentric_interpolation(D, F, B, idx, X);
+    return X;
+  }
+}
+
+void bind_barycentric_interpolation(nb::module_ &m)
+{
+  m.def("barycentric_interpolation", &pyigl::barycentric_interpolation,
+    "D"_a, "F"_a, "B"_a, "I"_a,
+    R"(Interpolate per-vertex data on a triangle mesh using barycentric coordinates.
+
+@param[in] D  #V by dim list of per-vertex data
+@param[in] F  #F by 3 list of triangle indices
+@param[in] B  #X by 3 list of barycentric coordinates
+@param[in] I  #X list of triangle indices into F
+@return X  #X by dim list of interpolated data)");
+}

libigl-2.6.3.dev2/src/bezier.cpp

@@ -0,0 +1,48 @@
+#include "default_types.h"
+#include <igl/bezier.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  // Single parameter t
+  auto bezier_t(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const Numeric t)
+  {
+    Eigen::MatrixXN P;
+    igl::bezier(V, t, P);
+    return P;
+  }
+  // Array of parameters T
+  auto bezier_T(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXN> &T)
+  {
+    // Copy T to compact vector for single-index access
+    const Eigen::VectorXN t = T.reshaped();
+    Eigen::MatrixXN P;
+    igl::bezier(V, t, P);
+    return P;
+  }
+}
+
+void bind_bezier(nb::module_ &m)
+{
+  m.def("bezier", &pyigl::bezier_t, "V"_a, "t"_a,
+    R"(Evaluate a polynomial Bezier curve at a single parameter value.
+
+@param[in] V  #V by dim list of Bezier control points
+@param[in] t  evaluation parameter in [0,1]
+@return P  1 by dim output point)");
+
+  m.def("bezier", &pyigl::bezier_T, "V"_a, "T"_a,
+    R"(Evaluate a polynomial Bezier curve at many parameter values.
+
+@param[in] V  #V by dim list of Bezier control points
+@param[in] T  #T list of evaluation parameters in [0,1]
+@return P  #T by dim output points)");
+}

libigl-2.6.3.dev2/src/bounding_box_diagonal.cpp

@@ -0,0 +1,25 @@
+#include "default_types.h"
+#include <igl/bounding_box_diagonal.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl {
+    auto bounding_box_diagonal(
+	const nb::DRef<const Eigen::MatrixXd>& V
+    ) {
+	return igl::bounding_box_diagonal(V);
+    }
+}
+
+void bind_bounding_box_diagonal(nb::module_ &m) {
+    m.def("bounding_box_diagonal", &pyigl::bounding_box_diagonal,
+	  "V"_a,
+	  R"(Compute the length of the diagonal of a given meshes axis-aligned bounding
+
+	  @param[in] V  #V by 3 list of vertex/point positions
+	  @return length of bounding box diagonal)"
+    );
+}

libigl-2.6.3.dev2/src/centroid.cpp

@@ -0,0 +1,40 @@
+#include "default_types.h"
+#include <igl/centroid.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto centroid(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::VectorXN c;
+    Numeric vol;
+    igl::centroid(V,F,c,vol);
+    return std::make_tuple(c,vol);
+  }
+}
+
+void bind_centroid(nb::module_ &m)
+{
+  m.def(
+    "centroid",
+    &pyigl::centroid,
+    "V"_a,
+    "F"_a,
+R"(Computes the centroid and enclosed volume of a closed mesh using a surface
+integral.
+
+@param[in] V  #V by dim list of rest domain positions
+@param[in] F  #F by 3 list of triangle indices into V
+@return c    dim vector of centroid coordinates
+@return vol  total volume of solid
+
+\see moments
+)");
+}

libigl-2.6.3.dev2/src/colormap.cpp

@@ -0,0 +1,62 @@
+#include "default_types.h"
+#include <igl/colormap.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  // Map scalar array to RGB colors using a colormap
+  auto colormap(
+    const igl::ColorMapType cm,
+    const nb::DRef<const Eigen::VectorXN> &Z,
+    const bool normalize)
+  {
+    Eigen::MatrixXN C;
+    igl::colormap(cm, Z, normalize, C);
+    return C;
+  }
+  // Map scalar to single RGB triple
+  auto colormap_scalar(
+    const igl::ColorMapType cm,
+    const Numeric f)
+  {
+    Numeric r, g, b;
+    igl::colormap(cm, f, r, g, b);
+    Eigen::Vector3d rgb;
+    rgb << r, g, b;
+    return rgb;
+  }
+}
+
+void bind_colormap(nb::module_ &m)
+{
+  nb::enum_<igl::ColorMapType>(m, "ColorMapType")
+    .value("INFERNO",  igl::COLOR_MAP_TYPE_INFERNO)
+    .value("JET",      igl::COLOR_MAP_TYPE_JET)
+    .value("MAGMA",    igl::COLOR_MAP_TYPE_MAGMA)
+    .value("PARULA",   igl::COLOR_MAP_TYPE_PARULA)
+    .value("PLASMA",   igl::COLOR_MAP_TYPE_PLASMA)
+    .value("VIRIDIS",  igl::COLOR_MAP_TYPE_VIRIDIS)
+    .value("TURBO",    igl::COLOR_MAP_TYPE_TURBO)
+    .export_values();
+
+  m.def("colormap", &pyigl::colormap,
+    "cm"_a, "Z"_a, "normalize"_a = true,
+    R"(Map scalar values to RGB colors using a colormap.
+
+@param[in] cm  colormap type (igl.ColorMapType.VIRIDIS, .JET, etc.)
+@param[in] Z   #Z list of scalar values
+@param[in] normalize  if true, normalize Z to [0,1] range before mapping
+@return C  #Z by 3 list of RGB colors in [0,1])");
+
+  m.def("colormap", &pyigl::colormap_scalar,
+    "cm"_a, "f"_a,
+    R"(Map a single scalar in [0,1] to an RGB color.
+
+@param[in] cm  colormap type
+@param[in] f   scalar in [0,1]
+@return 3-vector of RGB values in [0,1])");
+}

libigl-2.6.3.dev2/src/comb_cross_field.cpp

@@ -0,0 +1,39 @@
+#include "default_types.h"
+#include <igl/comb_cross_field.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;
+
+void bind_comb_cross_field(nb::module_ &m)
+{
+    m.def("comb_cross_field",
+        [](
+            const Eigen::MatrixXN& V,
+            const Eigen::MatrixXI& F,
+            const Eigen::MatrixXN& PD1,
+            const Eigen::MatrixXN& PD2
+        ) {
+            Eigen::MatrixXN PD1_out, PD2_out;
+            igl::comb_cross_field(V, F, PD1, PD2, PD1_out, PD2_out);
+            return std::make_tuple(PD1_out, PD2_out);
+        },
+        "V"_a,
+        "F"_a,
+        "PD1"_a,
+        "PD2"_a,
+        R"(Computes principal matchings of the vectors of a cross field across face edges,
+           and generates a combed cross field defined on the mesh faces
+     
+          @param[in]  V          #V by 3 eigen Matrix of mesh vertex 3D positions
+          @param[in]  F          #F by 4 eigen Matrix of face (quad) indices
+          @param[in]  PD1in      #F by 3 eigen Matrix of the first per face cross field vector
+          @param[in]  PD2in      #F by 3 eigen Matrix of the second per face cross field vector
+          @param[out] PD1out      #F by 3 eigen Matrix of the first combed cross field vector
+          @param[out] PD2out      #F by 3 eigen Matrix of the second combed cross field vector
+        )"
+    );
+}

libigl-2.6.3.dev2/src/comb_frame_field.cpp

@@ -0,0 +1,47 @@
+#include "default_types.h"
+#include <igl/comb_frame_field.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;
+
+void bind_comb_frame_field(nb::module_ &m)
+{
+    m.def("comb_frame_field",
+        [](
+            const Eigen::MatrixXN& V,
+            const Eigen::MatrixXI& F,
+            const Eigen::MatrixXN& PD1,
+            const Eigen::MatrixXN& PD2,
+            const Eigen::MatrixXN& BIS1_combed,
+            const Eigen::MatrixXN& BIS2_combed
+        ) {
+            Eigen::MatrixXN PD1_combed, PD2_combed;
+            igl::comb_frame_field(V, F, PD1, PD2, BIS1_combed, BIS2_combed, PD1_combed, PD2_combed);
+            return std::make_tuple(PD1_combed, PD2_combed);
+        },
+        "V"_a,
+        "F"_a,
+        "PD1"_a,
+        "PD2"_a,
+        "BIS1_combed"_a,
+        "BIS2_combed"_a,
+        R"(Computes principal matchings of the vectors of a frame field across face edges,
+           and generates a combed frame field defined on the mesh faces. This makes use of a
+           combed cross field generated by combing the field created by the bisectors of the
+           frame field.
+         
+           @param[in] V            #V by 3 eigen Matrix of mesh vertex 3D positions
+           @param[in] F            #F by 4 eigen Matrix of face (quad) indices
+           @param[in] PD1          #F by 3 eigen Matrix of the first per face cross field vector
+           @param[in] PD2          #F by 3 eigen Matrix of the second per face cross field vector
+           @param[in] BIS1_combed  #F by 3 eigen Matrix of the first combed bisector field vector
+           @param[in] BIS2_combed  #F by 3 eigen Matrix of the second combed bisector field vector
+           @param[out] PD1_combed  #F by 3 eigen Matrix of the first combed cross field vector
+           @param[out] PD2_combed  #F by 3 eigen Matrix of the second combed cross field vector
+        )"
+    );
+}

libigl-2.6.3.dev2/src/combine.cpp

@@ -0,0 +1,33 @@
+#include "default_types.h"
+#include <igl/combine.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/vector.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto combine(
+    const std::vector<Eigen::MatrixXN> &VV,
+    const std::vector<Eigen::MatrixXI> &FF)
+  {
+    Eigen::MatrixXN V;
+    Eigen::MatrixXI F;
+    igl::combine(VV, FF, V, F);
+    return std::make_tuple(V, F);
+  }
+}
+
+void bind_combine(nb::module_ &m)
+{
+  m.def("combine", &pyigl::combine, "VV"_a, "FF"_a,
+    R"(Concatenate multiple meshes into a single mesh.
+
+@param[in] VV  list of vertex position matrices, each #Vi by dim
+@param[in] FF  list of face index matrices, each #Fi by simplex_size
+@return V  concatenated vertex positions
+@return F  concatenated face indices (reindexed into V))");
+}

libigl-2.6.3.dev2/src/compute_frame_field_bisectors.cpp

@@ -0,0 +1,71 @@
+#include "default_types.h"
+#include <igl/compute_frame_field_bisectors.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;
+
+void bind_compute_frame_field_bisectors(nb::module_ &m)
+{
+    m.def("compute_frame_field_bisectors",
+        [](
+        const Eigen::MatrixXN& V,
+        const Eigen::MatrixXI& F,
+        const Eigen::MatrixXN& B1,
+        const Eigen::MatrixXN& B2,
+        const Eigen::MatrixXN& PD1,
+        const Eigen::MatrixXN& PD2
+        ) {
+            Eigen::MatrixXN BIS1, BIS2;
+            igl::compute_frame_field_bisectors(V, F, B1, B2, PD1, PD2, BIS1, BIS2);
+            return std::make_tuple(BIS1, BIS2);
+        },
+        "V"_a,
+        "F"_a,
+        "B1"_a,
+        "B2"_a,
+        "PD1"_a,
+        "PD2"_a,
+        R"(Compute bisectors of a frame field defined on mesh faces.
+
+          @param[in] V     #V by 3 eigen Matrix of mesh vertex 3D positions
+          @param[in] F     #F by 3 eigen Matrix of face (triangle) indices
+          @param[in] B1    #F by 3 eigen Matrix of face (triangle) base vector 1
+          @param[in] B2    #F by 3 eigen Matrix of face (triangle) base vector 2
+          @param[in] PD1   #F by 3 eigen Matrix of the first per face frame field vector
+          @param[in] PD2   #F by 3 eigen Matrix of the second per face frame field vector
+          @param[out] BIS1  #F by 3 eigen Matrix of the first per face frame field bisector
+          @param[out] BIS2  #F by 3 eigen Matrix of the second per face frame field bisector
+        )"
+    );
+
+    // Overload
+    m.def("compute_frame_field_bisectors",
+        [](
+        const Eigen::MatrixXN& V,
+        const Eigen::MatrixXI& F,
+        const Eigen::MatrixXN& PD1,
+        const Eigen::MatrixXN& PD2
+        ) {
+            Eigen::MatrixXN BIS1, BIS2;
+            igl::compute_frame_field_bisectors(V, F, PD1, PD2, BIS1, BIS2);
+            return std::make_tuple(BIS1, BIS2);
+        },
+        "V"_a,
+        "F"_a,
+        "PD1"_a,
+        "PD2"_a,
+        R"(Compute bisectors of a frame field defined on mesh faces.
+
+          @param[in] V     #V by 3 eigen Matrix of mesh vertex 3D positions
+          @param[in] F     #F by 3 eigen Matrix of face (triangle) indices
+          @param[in] PD1   #F by 3 eigen Matrix of the first per face frame field vector
+          @param[in] PD2   #F by 3 eigen Matrix of the second per face frame field vector
+          @param[out] BIS1  #F by 3 eigen Matrix of the first per face frame field bisector
+          @param[out] BIS2  #F by 3 eigen Matrix of the second per face frame field bisector
+        )"
+    );
+}

libigl-2.6.3.dev2/src/copyleft/cgal/coplanar.cpp

@@ -0,0 +1,24 @@
+#include "default_types.h"
+#include <igl/copyleft/cgal/coplanar.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  bool coplanar(const nb::DRef<const Eigen::MatrixXN> &V)
+  {
+    return igl::copyleft::cgal::coplanar(V);
+  }
+}
+
+void bind_coplanar(nb::module_ &m)
+{
+  m.def("coplanar", &pyigl::coplanar, "V"_a,
+    R"(Test whether all points lie on the same plane.
+
+@param[in] V  #V by 3 list of 3D vertex positions
+@return true if all points are coplanar)");
+}

libigl-2.6.3.dev2/src/copyleft/cgal/delaunay_triangulation.cpp

@@ -0,0 +1,26 @@
+#include "default_types.h"
+#include <igl/copyleft/cgal/delaunay_triangulation.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto delaunay_triangulation(const nb::DRef<const Eigen::MatrixXN> &V)
+  {
+    Eigen::MatrixXi F;  // int32 required by libigl internals
+    igl::copyleft::cgal::delaunay_triangulation(V, F);
+    return Eigen::MatrixXI(F.cast<Integer>());
+  }
+}
+
+void bind_delaunay_triangulation(nb::module_ &m)
+{
+  m.def("delaunay_triangulation", &pyigl::delaunay_triangulation, "V"_a,
+    R"(Compute the Delaunay triangulation of a 2D point set using CGAL.
+
+@param[in] V  #V by 2 list of 2D vertex positions
+@return F  #F by 3 triangle indices into V)");
+}