libigl 2.6.2__tar.gz → 2.6.3.dev1__tar.gz

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

@@ -51,7 +51,7 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
-      - run: pip install cibuildwheel==2.23.0
+      - run: pip install cibuildwheel==3.1.4
       - name: Build wheels
         run: python -m cibuildwheel --output-dir wheelhouse
         env:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libigl
-Version: 2.6.2
+Version: 2.6.3.dev1
 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.dev1/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 → libigl-2.6.3.dev1}/pyproject.toml

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

libigl-2.6.3.dev1/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.dev1/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.dev1/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.dev1/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.dev1/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.dev1/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.dev1/src/dijkstra.cpp

@@ -0,0 +1,84 @@
+#include "default_types.h"
+#include <igl/dijkstra.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/tuple.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/set.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  // Dijkstra with uniform edge weights (Euclidean distance via vertex positions)
+  auto dijkstra(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const std::vector<std::vector<Integer>> &VV,
+    const Integer source,
+    const std::set<Integer> &targets)
+  {
+    Eigen::VectorXN min_distance;
+    Eigen::VectorXI previous;
+    igl::dijkstra(V, VV, source, targets, min_distance, previous);
+    return std::make_tuple(min_distance, previous);
+  }
+  // Dijkstra with custom vertex weights
+  auto dijkstra_weighted(
+    const Integer source,
+    const std::set<Integer> &targets,
+    const std::vector<std::vector<Integer>> &VV,
+    const std::vector<double> &weights)
+  {
+    Eigen::VectorXN min_distance;
+    Eigen::VectorXI previous;
+    igl::dijkstra(source, targets, VV, weights, min_distance, previous);
+    return std::make_tuple(min_distance, previous);
+  }
+  // Backtrack path from vertex to source
+  auto dijkstra_backtrack(
+    const Integer vertex,
+    const nb::DRef<const Eigen::MatrixXI> &previous)
+  {
+    // previous[i] single-index access requires IsVectorAtCompileTime — copy to VectorXI
+    const Eigen::VectorXI prev = previous.reshaped();
+    std::vector<Integer> path;
+    igl::dijkstra(vertex, prev, path);
+    Eigen::VectorXI result(path.size());
+    for (size_t i = 0; i < path.size(); ++i) result(i) = path[i];
+    return result;
+  }
+}
+
+void bind_dijkstra(nb::module_ &m)
+{
+  m.def("dijkstra", &pyigl::dijkstra,
+    "V"_a, "VV"_a, "source"_a, "targets"_a,
+    R"(Dijkstra shortest paths using Euclidean edge weights.
+
+@param[in] V  #V by 3 list of vertex positions
+@param[in] VV  #V list of adjacency lists (e.g. from adjacency_list)
+@param[in] source  source vertex index
+@param[in] targets  set of target vertex indices (stop early if reached)
+@return min_distance  #V list of minimum distances from source
+@return previous  #V list of previous vertex indices for path reconstruction)");
+
+  m.def("dijkstra", &pyigl::dijkstra_weighted,
+    "source"_a, "targets"_a, "VV"_a, "weights"_a,
+    R"(Dijkstra shortest paths with custom vertex weights.
+
+@param[in] source  source vertex index
+@param[in] targets  set of target vertex indices
+@param[in] VV  #V list of adjacency lists
+@param[in] weights  #V list of vertex weights
+@return min_distance  #V list of minimum distances from source
+@return previous  #V list of previous vertex indices)");
+
+  m.def("dijkstra_backtrack", &pyigl::dijkstra_backtrack,
+    "vertex"_a, "previous"_a,
+    R"(Backtrack path from a vertex to the source using Dijkstra's previous array.
+
+@param[in] vertex  destination vertex
+@param[in] previous  #V list of previous vertex indices (from dijkstra)
+@return path  list of vertex indices from vertex to source)");
+}

libigl-2.6.3.dev1/src/directed_edge_parents.cpp

@@ -0,0 +1,26 @@
+#include "default_types.h"
+#include <igl/directed_edge_parents.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto directed_edge_parents(const nb::DRef<const Eigen::MatrixXI> &E)
+  {
+    Eigen::VectorXI P;
+    igl::directed_edge_parents(E, P);
+    return P;
+  }
+}
+
+void bind_directed_edge_parents(nb::module_ &m)
+{
+  m.def("directed_edge_parents", &pyigl::directed_edge_parents, "E"_a,
+    R"(Recover parent edges in a tree given directed edges.
+
+@param[in] E  #E by 2 list of directed edges
+@return P  #E list of parent indices into E (-1 means root))");
+}

libigl-2.6.3.dev1/src/edge_topology.cpp

@@ -0,0 +1,32 @@
+#include "default_types.h"
+#include <igl/edge_topology.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 edge_topology(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::MatrixXI EV, FE, EF;
+    igl::edge_topology(V, F, EV, FE, EF);
+    return std::make_tuple(EV, FE, EF);
+  }
+}
+
+void bind_edge_topology(nb::module_ &m)
+{
+  m.def("edge_topology", &pyigl::edge_topology, "V"_a, "F"_a,
+    R"(Initialize edges and their topological relations for an edge-manifold mesh.
+
+@param[in] V  #V by dim list of vertex positions (unused, kept for API compatibility)
+@param[in] F  #F by 3 list of triangle indices
+@return EV  #E by 2 list of edge vertex indices
+@return FE  #F by 3 list of face-edge relations (FE(f,c) is an edge incident on corner c of face f)
+@return EF  #E by 2 list of edge-face relations (EF(e,:) are the two adjacent faces))");
+}

libigl-2.6.3.dev1/src/edges_to_path.cpp

@@ -0,0 +1,36 @@
+#include "default_types.h"
+#include <igl/edges_to_path.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 edges_to_path(const nb::DRef<const Eigen::MatrixXI> &E)
+  {
+    // igl::edges_to_path internally uses Eigen::Map<DerivedE>(vE.data(), ...) where
+    // vE is Eigen::VectorXi (int32). Must use Eigen::MatrixXi (int32, ColMajor).
+    Eigen::MatrixXi e = E.cast<int>();
+    Eigen::VectorXi I, J, K;
+    igl::edges_to_path(e, I, J, K);
+    // Cast int32 outputs back to int64 (Integer)
+    return std::make_tuple(
+      Eigen::VectorXI(I.cast<Integer>()),
+      Eigen::VectorXI(J.cast<Integer>()),
+      Eigen::VectorXI(K.cast<Integer>()));
+  }
+}
+
+void bind_edges_to_path(nb::module_ &m)
+{
+  m.def("edges_to_path", &pyigl::edges_to_path, "E"_a,
+    R"(Given undirected edges forming a single chain/loop, find the path visiting all nodes.
+
+@param[in] E  #E by 2 list of undirected edges
+@return I  #E+1 list of node indices tracing the chain (if loop: I[0]==I[-1])
+@return J  #E list of indices into E tracing I
+@return K  #E list of column indices in E (0 or 1) indicating edge direction)");
+}

libigl-2.6.3.dev1/src/euler_characteristic.cpp

@@ -0,0 +1,20 @@
+#include "default_types.h"
+#include <igl/euler_characteristic.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+void bind_euler_characteristic(nb::module_ &m)
+{
+  m.def("euler_characteristic",
+    [](const nb::DRef<const Eigen::MatrixXI> &F) -> int {
+      return igl::euler_characteristic(F);
+    },
+    "F"_a,
+    R"(Compute the Euler characteristic of a mesh: χ = |V| - |E| + |F|
+
+@param[in] F  #F by dim list of mesh faces
+@return Euler characteristic (e.g. 2 for a closed genus-0 surface))");
+}

libigl-2.6.3.dev1/src/exterior_edges.cpp

@@ -0,0 +1,26 @@
+#include "default_types.h"
+#include <igl/exterior_edges.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto exterior_edges(const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::MatrixXI E;
+    igl::exterior_edges(F, E);
+    return E;
+  }
+}
+
+void bind_exterior_edges(nb::module_ &m)
+{
+  m.def("exterior_edges", &pyigl::exterior_edges, "F"_a,
+    R"(Determine boundary edges (edges with odd number of occurrences).
+
+@param[in] F  #F by simplex_size list of faces
+@return E  #E by simplex_size-1 list of exterior edges)");
+}

libigl-2.6.3.dev1/src/extract_manifold_patches.cpp

@@ -0,0 +1,30 @@
+#include "default_types.h"
+#include <igl/extract_manifold_patches.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 extract_manifold_patches(const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::VectorXI P;
+    int n = igl::extract_manifold_patches(F, P);
+    return std::make_tuple(n, Eigen::VectorXI(P));
+  }
+}
+
+void bind_extract_manifold_patches(nb::module_ &m)
+{
+  m.def("extract_manifold_patches", &pyigl::extract_manifold_patches, "F"_a,
+    R"(Extract maximal manifold patches from a triangle mesh.
+
+A patch is a maximal subset of faces connected via manifold edges.
+
+@param[in] F  #F by 3 list of triangle indices
+@return n  number of manifold patches
+@return P  #F list of patch indices for each face)");
+}

libigl-2.6.3.dev1/src/face_occurrences.cpp

@@ -0,0 +1,26 @@
+#include "default_types.h"
+#include <igl/face_occurrences.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto face_occurrences(const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::VectorXI C;
+    igl::face_occurrences(F, C);
+    return C;
+  }
+}
+
+void bind_face_occurrences(nb::module_ &m)
+{
+  m.def("face_occurrences", &pyigl::face_occurrences, "F"_a,
+    R"(Count the occurrences of each face (row) in a list of face indices.
+
+@param[in] F  #F by simplex_size list of faces
+@return C  #F list of occurrence counts)");
+}

libigl-2.6.3.dev1/src/fit_plane.cpp

@@ -0,0 +1,30 @@
+#include "default_types.h"
+#include <igl/fit_plane.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 fit_plane(const nb::DRef<const Eigen::MatrixXN> &V)
+  {
+    Eigen::RowVector3d N, C;
+    igl::fit_plane(V, N, C);
+    return std::make_tuple(
+      Eigen::VectorXN(N.transpose()),
+      Eigen::VectorXN(C.transpose()));
+  }
+}
+
+void bind_fit_plane(nb::module_ &m)
+{
+  m.def("fit_plane", &pyigl::fit_plane, "V"_a,
+    R"(Fit a plane to a point cloud.
+
+@param[in] V  #V by 3 matrix of 3D point cloud positions
+@return N  3-vector normal of the fitted plane
+@return C  3-vector of a point that lies on the fitted plane)");
+}

libigl-2.6.3.dev1/src/flipped_triangles.cpp

@@ -0,0 +1,29 @@
+#include "default_types.h"
+#include <igl/flipped_triangles.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto flipped_triangles(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    Eigen::VectorXI X;
+    igl::flipped_triangles(V, F, X);
+    return X;
+  }
+}
+
+void bind_flipped_triangles(nb::module_ &m)
+{
+  m.def("flipped_triangles", &pyigl::flipped_triangles, "V"_a, "F"_a,
+    R"(Find indices of flipped triangles in a 2D UV mapping.
+
+@param[in] V  #V by 2 list of UV vertex positions
+@param[in] F  #F by 3 list of triangle indices
+@return X  list of indices into F of flipped triangles)");
+}