libigl 2.6.3.dev2__tar.gz → 2.6.3.dev3__tar.gz

{libigl-2.6.3.dev2 → libigl-2.6.3.dev3}/.gitignore

@@ -18,7 +18,7 @@ __pycache__
 igl.egg-info
 libigl.egg-info
 *.code-workspace
-out.obj
+out.*
 test.off
 .vscode
 
@@ -41,3 +41,4 @@ junit
 dist/
 igl/*
 CLAUDE.md
+wheelhouse/

{libigl-2.6.3.dev2 → libigl-2.6.3.dev3}/CMakeLists.txt

@@ -42,6 +42,8 @@ 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)
 FetchContent_Declare(
   libigl
   GIT_REPOSITORY https://github.com/libigl/libigl.git
@@ -182,6 +184,12 @@ endif()
 if(LIBIGL_RESTRICTED_TRIANGLE)
   pyigl_include("restricted" "triangle")
 endif()
+if(LIBIGL_SPECTRA)
+  pyigl_include("" "spectra")
+endif()
+if(LIBIGL_PREDICATES)
+  pyigl_include("" "predicates")
+endif()
 
 
 

{libigl-2.6.3.dev2 → libigl-2.6.3.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libigl
-Version: 2.6.3.dev2
+Version: 2.6.3.dev3
 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:

{libigl-2.6.3.dev2 → libigl-2.6.3.dev3}/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:

{libigl-2.6.3.dev2 → libigl-2.6.3.dev3}/pyproject.toml

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

libigl-2.6.3.dev3/src/lexicographic_triangulation.cpp

@@ -0,0 +1,47 @@
+#include "default_types.h"
+#include <igl/lexicographic_triangulation.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto lexicographic_triangulation(
+    const Eigen::MatrixXN &P)
+  {
+    auto orient2D = [](const Numeric* pa, const Numeric* pb, const Numeric* pc) -> int
+    {
+      const Numeric cross =
+        (pb[0] - pa[0]) * (pc[1] - pa[1]) -
+        (pb[1] - pa[1]) * (pc[0] - pa[0]);
+      return (cross > 0) ? 1 : (cross < 0) ? -1 : 0;
+    };
+    Eigen::MatrixXi F;
+    try
+    {
+      igl::lexicographic_triangulation(P, orient2D, F);
+    }
+    catch(const char* e)
+    {
+      throw std::runtime_error(e);
+    }
+    return F;
+  }
+}
+
+void bind_lexicographic_triangulation(nb::module_ &m)
+{
+  m.def(
+    "lexicographic_triangulation",
+    &pyigl::lexicographic_triangulation,
+    "P"_a,
+R"(Compute a lexicographic triangulation of a 2D point set.
+
+Uses a floating-point cross-product orientation predicate; may be inaccurate
+for nearly-collinear inputs.
+
+@param[in] P  #P by 2 list of 2D vertex positions
+@param[out] F  #F by 3 list of face indices into P)");
+}

libigl-2.6.3.dev3/src/predicates/Orientation.cpp

@@ -0,0 +1,21 @@
+#include "default_types.h"
+#include <igl/predicates/Orientation.h>
+#include <nanobind/nanobind.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void bind_Orientation(nb::module_ &m)
+{
+  nb::enum_<igl::predicates::Orientation>(m, "Orientation")
+    .value("POSITIVE",    igl::predicates::Orientation::POSITIVE)
+    .value("INSIDE",      igl::predicates::Orientation::INSIDE)
+    .value("NEGATIVE",    igl::predicates::Orientation::NEGATIVE)
+    .value("OUTSIDE",     igl::predicates::Orientation::OUTSIDE)
+    .value("COLLINEAR",   igl::predicates::Orientation::COLLINEAR)
+    .value("COPLANAR",    igl::predicates::Orientation::COPLANAR)
+    .value("COCIRCULAR",  igl::predicates::Orientation::COCIRCULAR)
+    .value("COSPHERICAL", igl::predicates::Orientation::COSPHERICAL)
+    .value("DEGENERATE",  igl::predicates::Orientation::DEGENERATE)
+    .export_values();
+}

libigl-2.6.3.dev3/src/predicates/delaunay_triangulation.cpp

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

libigl-2.6.3.dev3/src/predicates/ear_clipping.cpp

@@ -0,0 +1,56 @@
+#include "default_types.h"
+#include <igl/predicates/ear_clipping.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  std::tuple<bool, Eigen::MatrixXi> ear_clipping(
+    const Eigen::MatrixXN &P)
+  {
+    Eigen::MatrixXi eF;
+    bool ok = igl::predicates::ear_clipping(P, eF);
+    return {ok, eF};
+  }
+
+  std::tuple<Eigen::MatrixXi, Eigen::MatrixXI> ear_clipping_with_reserved(
+    const Eigen::MatrixXN &P,
+    const Eigen::MatrixXI &RT)
+  {
+    Eigen::MatrixXi eF;
+    Eigen::VectorXi I;
+    Eigen::VectorXi RT_int = RT.cast<int>();
+    igl::predicates::ear_clipping(P, RT_int, eF, I);
+    Eigen::MatrixXI I_out = I.cast<Integer>();
+    return {eF, I_out};
+  }
+}
+
+void bind_ear_clipping(nb::module_ &m)
+{
+  m.def(
+    "ear_clipping",
+    &pyigl::ear_clipping,
+    "P"_a,
+R"(Ear-clipping triangulation of a 2D polygon.
+
+Reverses P if necessary so output orientation matches input.
+
+@param[in] P  #P by 2 list of 2D polygon vertices (CCW for proper mesh)
+@return (ok, eF) where ok is true if mesh is proper (input is a simple polygon)
+  and eF is #eF by 3 list of triangle indices into P.)");
+  m.def(
+    "ear_clipping",
+    &pyigl::ear_clipping_with_reserved,
+    "P"_a, "RT"_a,
+R"(Ear-clipping triangulation with reserved (non-clippable) vertices.
+
+@param[in] P   #P by 2 list of 2D polygon vertices
+@param[in] RT  #P list, vertices marked 1 are preserved (not clipped)
+@return (eF, I) where eF is the clipped ears (original indices into P) and
+  I maps indices of the remaining polygon to original P indices.)");
+}

libigl-2.6.3.dev3/src/predicates/find_intersections.cpp

@@ -0,0 +1,49 @@
+#include "default_types.h"
+#include <igl/predicates/find_intersections.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  std::tuple<bool, Eigen::MatrixXI, Eigen::MatrixXI> find_intersections(
+    const Eigen::MatrixXN &V1,
+    const Eigen::MatrixXI &F1,
+    const Eigen::MatrixXN &V2,
+    const Eigen::MatrixXI &F2,
+    const bool first_only)
+  {
+    Eigen::MatrixXi IF;
+    Eigen::Matrix<bool, Eigen::Dynamic, 1> CP_bool;
+    Eigen::MatrixXi F1_int = F1.cast<int>();
+    Eigen::MatrixXi F2_int = F2.cast<int>();
+    bool found = igl::predicates::find_intersections(
+      V1, F1_int, V2, F2_int, first_only, IF, CP_bool);
+    Eigen::MatrixXI IF_out = IF.cast<Integer>();
+    Eigen::MatrixXI CP_out = CP_bool.cast<Integer>();
+    return {found, IF_out, CP_out};
+  }
+}
+
+void bind_find_intersections(nb::module_ &m)
+{
+  m.def(
+    "find_intersections",
+    &pyigl::find_intersections,
+    "V1"_a, "F1"_a, "V2"_a, "F2"_a, "first_only"_a = false,
+R"(Find intersecting triangle pairs between two meshes.
+
+Uses AABB tree and exact predicates.
+
+@param[in] V1        #V1 by 3 vertex positions of first mesh
+@param[in] F1        #F1 by 3 triangle indices of first mesh
+@param[in] V2        #V2 by 3 vertex positions of second mesh
+@param[in] F2        #F2 by 3 triangle indices of second mesh
+@param[in] first_only  stop after finding the first intersection
+@return (found, IF, CP) where found is true if any intersections exist,
+  IF is #IF by 2 list of intersecting face index pairs (into F1, F2),
+  CP is #IF list of whether each intersection is coplanar.)");
+}

libigl-2.6.3.dev3/src/predicates/find_self_intersections.cpp

@@ -0,0 +1,43 @@
+#include "default_types.h"
+#include <igl/predicates/find_self_intersections.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  std::tuple<bool, Eigen::MatrixXI, Eigen::MatrixXI> find_self_intersections(
+    const Eigen::MatrixXN &V,
+    const Eigen::MatrixXI &F,
+    const bool first_only)
+  {
+    Eigen::MatrixXi IF;
+    Eigen::Matrix<bool, Eigen::Dynamic, 1> CP_bool;
+    Eigen::MatrixXi F_int = F.cast<int>();
+    bool found = igl::predicates::find_self_intersections(V, F_int, first_only, IF, CP_bool);
+    Eigen::MatrixXI IF_out = IF.cast<Integer>();
+    Eigen::MatrixXI CP_out = CP_bool.cast<Integer>();
+    return {found, IF_out, CP_out};
+  }
+}
+
+void bind_find_self_intersections(nb::module_ &m)
+{
+  m.def(
+    "find_self_intersections",
+    &pyigl::find_self_intersections,
+    "V"_a, "F"_a, "first_only"_a = false,
+R"(Find self-intersecting triangle pairs within a mesh.
+
+Uses AABB tree and exact predicates.
+
+@param[in] V         #V by 3 vertex positions
+@param[in] F         #F by 3 triangle indices
+@param[in] first_only  stop after finding the first intersection
+@return (found, IF, CP) where found is true if any self-intersections exist,
+  IF is #IF by 2 list of intersecting face index pairs,
+  CP is #IF list of whether each intersection is coplanar.)");
+}

libigl-2.6.3.dev3/src/predicates/incircle.cpp

@@ -0,0 +1,37 @@
+#include "default_types.h"
+#include <igl/predicates/incircle.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  igl::predicates::Orientation incircle(
+    const Eigen::Vector2d &pa,
+    const Eigen::Vector2d &pb,
+    const Eigen::Vector2d &pc,
+    const Eigen::Vector2d &pd)
+  {
+    return igl::predicates::incircle(pa, pb, pc, pd);
+  }
+}
+
+void bind_incircle(nb::module_ &m)
+{
+  m.def(
+    "incircle",
+    &pyigl::incircle,
+    "pa"_a, "pb"_a, "pc"_a, "pd"_a,
+R"(Decide whether a 2D point is inside/outside/on a circle.
+
+Uses exact arithmetic (Shewchuk predicates).
+
+@param[in] pa  2D point on circle
+@param[in] pb  2D point on circle
+@param[in] pc  2D point on circle
+@param[in] pd  2D query point
+@return INSIDE if pd is inside the circle defined by pa,pb,pc,
+  OUTSIDE if outside, COCIRCULAR if exactly on the circle.)");
+}

libigl-2.6.3.dev3/src/predicates/insphere.cpp

@@ -0,0 +1,39 @@
+#include "default_types.h"
+#include <igl/predicates/insphere.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  igl::predicates::Orientation insphere(
+    const Eigen::Vector3d &pa,
+    const Eigen::Vector3d &pb,
+    const Eigen::Vector3d &pc,
+    const Eigen::Vector3d &pd,
+    const Eigen::Vector3d &pe)
+  {
+    return igl::predicates::insphere(pa, pb, pc, pd, pe);
+  }
+}
+
+void bind_insphere(nb::module_ &m)
+{
+  m.def(
+    "insphere",
+    &pyigl::insphere,
+    "pa"_a, "pb"_a, "pc"_a, "pd"_a, "pe"_a,
+R"(Decide whether a 3D point is inside/outside/on a sphere.
+
+Uses exact arithmetic (Shewchuk predicates).
+
+@param[in] pa  3D point on sphere
+@param[in] pb  3D point on sphere
+@param[in] pc  3D point on sphere
+@param[in] pd  3D point on sphere
+@param[in] pe  3D query point
+@return INSIDE if pe is inside the sphere defined by pa,pb,pc,pd,
+  OUTSIDE if outside, COSPHERICAL if exactly on the sphere.)");
+}

libigl-2.6.3.dev3/src/predicates/lexicographic_triangulation.cpp

@@ -0,0 +1,30 @@
+#include "default_types.h"
+#include <igl/predicates/lexicographic_triangulation.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  Eigen::MatrixXi lexicographic_triangulation(
+    const Eigen::MatrixXN &V)
+  {
+    Eigen::MatrixXi F;
+    igl::predicates::lexicographic_triangulation(V, F);
+    return F;
+  }
+}
+
+void bind_lexicographic_triangulation(nb::module_ &m)
+{
+  m.def(
+    "lexicographic_triangulation",
+    &pyigl::lexicographic_triangulation,
+    "V"_a,
+R"(Compute a lexicographic triangulation of a 2D point set using exact predicates.
+
+@param[in] V  #V by 2 list of 2D vertex positions
+@return F  #F by 3 list of triangle indices into V.)");
+}

libigl-2.6.3.dev3/src/predicates/module.cpp

@@ -0,0 +1,9 @@
+#include <nanobind/nanobind.h>
+#include <igl/predicates/exactinit.h>
+namespace nb = nanobind;
+#include "predicates/BINDING_DECLARATIONS.in"
+NB_MODULE(pyigl_predicates, m) {
+  m.doc() = "libigl predicates module python bindings";
+  igl::predicates::exactinit();
+  #include "predicates/BINDING_INVOCATIONS.in"
+}

libigl-2.6.3.dev3/src/predicates/orient2d.cpp

@@ -0,0 +1,35 @@
+#include "default_types.h"
+#include <igl/predicates/orient2d.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  igl::predicates::Orientation orient2d(
+    const Eigen::Vector2d &pa,
+    const Eigen::Vector2d &pb,
+    const Eigen::Vector2d &pc)
+  {
+    return igl::predicates::orient2d(pa, pb, pc);
+  }
+}
+
+void bind_orient2d(nb::module_ &m)
+{
+  m.def(
+    "orient2d",
+    &pyigl::orient2d,
+    "pa"_a, "pb"_a, "pc"_a,
+R"(Compute the orientation of the triangle formed by pa, pb, pc.
+
+Uses exact arithmetic (Shewchuk predicates).
+
+@param[in] pa  2D point
+@param[in] pb  2D point
+@param[in] pc  2D point
+@return POSITIVE if pa,pb,pc are counterclockwise, NEGATIVE if clockwise,
+  COLLINEAR if collinear.)");
+}

libigl-2.6.3.dev3/src/predicates/orient3d.cpp

@@ -0,0 +1,59 @@
+#include "default_types.h"
+#include <igl/predicates/orient3d.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  igl::predicates::Orientation orient3d_scalar(
+    const Eigen::Vector3d &pa,
+    const Eigen::Vector3d &pb,
+    const Eigen::Vector3d &pc,
+    const Eigen::Vector3d &pd)
+  {
+    return igl::predicates::orient3d(pa, pb, pc, pd);
+  }
+
+  Eigen::VectorXi orient3d_vectorized(
+    const Eigen::MatrixXN &A,
+    const Eigen::MatrixXN &B,
+    const Eigen::MatrixXN &C,
+    const Eigen::MatrixXN &D)
+  {
+    Eigen::VectorXi R;
+    igl::predicates::orient3d(A, B, C, D, R);
+    return R;
+  }
+}
+
+void bind_orient3d(nb::module_ &m)
+{
+  m.def(
+    "orient3d",
+    &pyigl::orient3d_scalar,
+    "pa"_a, "pb"_a, "pc"_a, "pd"_a,
+R"(Compute the orientation of the tetrahedron formed by pa, pb, pc, pd.
+
+Uses exact arithmetic (Shewchuk predicates).
+
+@param[in] pa  3D point
+@param[in] pb  3D point
+@param[in] pc  3D point
+@param[in] pd  3D query point
+@return POSITIVE if pd is below the plane oriented by pa,pb,pc,
+  NEGATIVE if above, COPLANAR if on the plane.)");
+  m.def(
+    "orient3d",
+    &pyigl::orient3d_vectorized,
+    "A"_a, "B"_a, "C"_a, "D"_a,
+R"(Vectorized orient3d: compute orientation for each row-tuple (A[i], B[i], C[i], D[i]).
+
+@param[in] A  #P by 3 matrix of 3D points
+@param[in] B  #P by 3 matrix of 3D points
+@param[in] C  #P by 3 matrix of 3D points
+@param[in] D  #P by 3 matrix of 3D points
+@return #P vector of orientation values (+1, -1, or 0))");
+}

libigl-2.6.3.dev3/src/predicates/point_inside_convex_polygon.cpp

@@ -0,0 +1,30 @@
+#include "default_types.h"
+#include <igl/predicates/point_inside_convex_polygon.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  bool point_inside_convex_polygon(
+    const Eigen::MatrixX2d &P,
+    const Eigen::RowVector2d &q)
+  {
+    return igl::predicates::point_inside_convex_polygon(P, q);
+  }
+}
+
+void bind_point_inside_convex_polygon(nb::module_ &m)
+{
+  m.def(
+    "point_inside_convex_polygon",
+    &pyigl::point_inside_convex_polygon,
+    "P"_a, "q"_a,
+R"(Check whether a 2D point lies inside a 2D convex polygon.
+
+@param[in] P  #P by 2 list of polygon vertices (n >= 3)
+@param[in] q  2D query point
+@return true if q is inside P.)");
+}

libigl-2.6.3.dev3/src/predicates/polygons_to_triangles.cpp

@@ -0,0 +1,40 @@
+#include "default_types.h"
+#include <igl/predicates/polygons_to_triangles.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  std::tuple<Eigen::MatrixXi, Eigen::VectorXI> polygons_to_triangles(
+    const Eigen::MatrixXN &V,
+    const Eigen::VectorXI &I,
+    const Eigen::VectorXI &C)
+  {
+    Eigen::VectorXi I_int = I.cast<int>();
+    Eigen::VectorXi C_int = C.cast<int>();
+    Eigen::MatrixXi F;
+    Eigen::VectorXi J;
+    igl::predicates::polygons_to_triangles(V, I_int, C_int, F, J);
+    Eigen::VectorXI J_out = J.cast<Integer>();
+    return {F, J_out};
+  }
+}
+
+void bind_polygons_to_triangles(nb::module_ &m)
+{
+  m.def(
+    "polygons_to_triangles",
+    &pyigl::polygons_to_triangles,
+    "V"_a, "I"_a, "C"_a,
+R"(Triangulate each polygon of a polygon mesh with a fan.
+
+@param[in] V  #V by dim vertex positions (used for orientation in 3D)
+@param[in] I  #I list of polygon corner indices into rows of V
+@param[in] C  #polygons+1 cumulative polygon sizes (C[i+1]-C[i] = size of polygon i)
+@return (F, J) where F is #F by 3 list of triangle indices and J is #F list of
+  source polygon indices.)");
+}