libigl 2.6.3.dev1__tar.gz → 2.6.3.dev2__tar.gz

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

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

@@ -13,7 +13,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "libigl"
-version = "2.6.3.dev1"
+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/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)");
+}

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

@@ -0,0 +1,35 @@
+#include "default_types.h"
+#include <igl/copyleft/cgal/extract_cells.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_cells(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    // int32 required by libigl internals (static_assert checks index type)
+    Eigen::MatrixXi Fi = F.cast<int>();
+    Eigen::MatrixXi cells;
+    size_t n = igl::copyleft::cgal::extract_cells(V, Fi, cells);
+    return std::make_tuple((Integer)n, Eigen::MatrixXI(cells.cast<Integer>()));
+  }
+}
+
+void bind_extract_cells(nb::module_ &m)
+{
+  m.def("extract_cells", &pyigl::extract_cells, "V"_a, "F"_a,
+    R"(Extract connected 3D cells partitioned by a triangle mesh.
+
+@param[in] V  #V by 3 array of vertices
+@param[in] F  #F by 3 array of triangle indices
+@return tuple (num_cells, cells):
+  - num_cells  number of cells (cell 0 is the infinite outer cell)
+  - cells  #F by 2 array of cell indices; cells[i,0] is the cell on the
+    positive side of face i, cells[i,1] is on the negative side)");
+}

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

@@ -0,0 +1,42 @@
+#include "default_types.h"
+#include <igl/copyleft/cgal/outer_hull.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 outer_hull(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    // int32 required by libigl internals
+    Eigen::MatrixXi Fi = F.cast<int>();
+    Eigen::MatrixXN HV;
+    Eigen::MatrixXi HF;
+    Eigen::VectorXi J;
+    Eigen::Matrix<bool, Eigen::Dynamic, 1> flip;
+    igl::copyleft::cgal::outer_hull(V, Fi, HV, HF, J, flip);
+    return std::make_tuple(HV,
+      Eigen::MatrixXI(HF.cast<Integer>()),
+      Eigen::VectorXI(J.cast<Integer>()),
+      Eigen::VectorXB(flip));
+  }
+}
+
+void bind_outer_hull(nb::module_ &m)
+{
+  m.def("outer_hull", &pyigl::outer_hull, "V"_a, "F"_a,
+    R"(Compute the outer hull of a piecewise-constant winding number mesh.
+
+@param[in] V   #V by 3 list of vertex positions
+@param[in] F   #F by 3 list of triangle indices into V
+@return tuple (HV, HF, J, flip):
+  - HV    #HV by 3 output vertex positions
+  - HF    #HF by 3 output triangle indices into HV
+  - J     #HF list of indices into F (birth faces)
+  - flip  #HF list of bools, true if facet was flipped)");
+}

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

@@ -0,0 +1,36 @@
+#include "default_types.h"
+#include <igl/copyleft/cgal/peel_outer_hull_layers.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 peel_outer_hull_layers(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    // int32 required by libigl internals
+    Eigen::MatrixXi Fi = F.cast<int>();
+    Eigen::VectorXi I;
+    Eigen::Matrix<bool, Eigen::Dynamic, 1> flip;
+    int n = igl::copyleft::cgal::peel_outer_hull_layers(V, Fi, I, flip);
+    return std::make_tuple(Eigen::VectorXI(I.cast<Integer>()), Eigen::VectorXB(flip), n);
+  }
+}
+
+void bind_peel_outer_hull_layers(nb::module_ &m)
+{
+  m.def("peel_outer_hull_layers", &pyigl::peel_outer_hull_layers, "V"_a, "F"_a,
+    R"(Successively peel outer hull layers from a mesh, useful for boolean operations.
+
+@param[in] V  #V by 3 list of vertex positions
+@param[in] F  #F by 3 list of triangle indices into V
+@return tuple (I, flip, num_peels):
+  - I         #F list of which peel layer each facet belongs to
+  - flip      #F list of bools, true if facet orientation was flipped during peeling
+  - num_peels number of peel layers)");
+}

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

@@ -0,0 +1,34 @@
+#include "default_types.h"
+#include <igl/copyleft/cgal/peel_winding_number_layers.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 peel_winding_number_layers(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F)
+  {
+    // int32 required by libigl internals
+    Eigen::MatrixXi Fi = F.cast<int>();
+    Eigen::VectorXi W;
+    size_t n = igl::copyleft::cgal::peel_winding_number_layers(V, Fi, W);
+    return std::make_tuple(Eigen::VectorXI(W.cast<Integer>()), (Integer)n);
+  }
+}
+
+void bind_peel_winding_number_layers(nb::module_ &m)
+{
+  m.def("peel_winding_number_layers", &pyigl::peel_winding_number_layers, "V"_a, "F"_a,
+    R"(Peel winding number layers from a mesh.
+
+@param[in] V  #V by 3 list of vertex positions
+@param[in] F  #F by 3 list of triangle indices into V
+@return tuple (W, num_layers):
+  - W          #V list of integer winding numbers per vertex
+  - num_layers number of winding number layers)");
+}

libigl-2.6.3.dev2/src/copyleft/marching_cubes.cpp

@@ -0,0 +1,68 @@
+#include "default_types.h"
+#include <igl/copyleft/marching_cubes.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 marching_cubes(
+    const nb::DRef<const Eigen::VectorXN> &values,
+    const nb::DRef<const Eigen::MatrixXN> &points,
+    const Integer x_res,
+    const Integer y_res,
+    const Integer z_res,
+    const Numeric isovalue)
+  {
+    Eigen::MatrixXN vertices;
+    Eigen::MatrixXI faces;
+    igl::copyleft::marching_cubes(
+      values, points,
+      (unsigned)x_res, (unsigned)y_res, (unsigned)z_res,
+      isovalue, vertices, faces);
+    return std::make_tuple(vertices, faces);
+  }
+  auto marching_cubes_indexed(
+    const nb::DRef<const Eigen::VectorXN> &values,
+    const nb::DRef<const Eigen::MatrixXN> &points,
+    const nb::DRef<const Eigen::MatrixXI> &indices,
+    const Numeric isovalue)
+  {
+    Eigen::MatrixXN vertices;
+    Eigen::MatrixXI faces;
+    igl::copyleft::marching_cubes(values, points, indices, isovalue, vertices, faces);
+    return std::make_tuple(vertices, faces);
+  }
+}
+
+void bind_marching_cubes(nb::module_ &m)
+{
+  m.def("marching_cubes", &pyigl::marching_cubes,
+    "values"_a, "points"_a, "x_res"_a, "y_res"_a, "z_res"_a, "isovalue"_a = 0.0,
+    R"(Perform marching cubes to extract an isosurface from a scalar field on a regular grid.
+
+@param[in] values  #points vector of scalar values (<0 inside, >0 outside)
+@param[in] points  #points by 3 grid point positions (x-fastest order:
+    index = x + y*x_res + z*x_res*y_res)
+@param[in] x_res  grid resolution in x
+@param[in] y_res  grid resolution in y
+@param[in] z_res  grid resolution in z
+@param[in] isovalue  isovalue to reconstruct (default: 0.0)
+@return tuple (vertices, faces):
+  - vertices  #V by 3 mesh vertex positions
+  - faces  #F by 3 mesh triangle indices)");
+  m.def("marching_cubes", &pyigl::marching_cubes_indexed,
+    "values"_a, "points"_a, "indices"_a, "isovalue"_a = 0.0,
+    R"(Perform marching cubes on a sparse grid defined by explicit cube corner indices.
+
+@param[in] values  #points vector of scalar values
+@param[in] points  #points by 3 grid point positions
+@param[in] indices  #cubes by 8 array of corner indices into points/values
+@param[in] isovalue  isovalue to reconstruct (default: 0.0)
+@return tuple (vertices, faces):
+  - vertices  #V by 3 mesh vertex positions
+  - faces  #F by 3 mesh triangle indices)");
+}

libigl-2.6.3.dev2/src/copyleft/quadprog.cpp

@@ -0,0 +1,49 @@
+#include "default_types.h"
+#include <igl/copyleft/quadprog.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto quadprog(
+    const nb::DRef<const Eigen::MatrixXN> &G,
+    const nb::DRef<const Eigen::VectorXN> &g0,
+    const nb::DRef<const Eigen::MatrixXN> &CE,
+    const nb::DRef<const Eigen::VectorXN> &ce0,
+    const nb::DRef<const Eigen::MatrixXN> &CI,
+    const nb::DRef<const Eigen::VectorXN> &ci0)
+  {
+    // quadprog uses non-template MatrixXd (col-major); copy from row-major inputs
+    Eigen::MatrixXd G_d = G, CE_d = CE, CI_d = CI;
+    Eigen::VectorXd g0_d = g0, ce0_d = ce0, ci0_d = ci0;
+    Eigen::VectorXd x;
+    if(!igl::copyleft::quadprog(G_d, g0_d, CE_d, ce0_d, CI_d, ci0_d, x))
+      throw std::runtime_error("quadprog: solver failed");
+    return Eigen::VectorXN(x);
+  }
+}
+
+void bind_quadprog(nb::module_ &m)
+{
+  m.def("quadprog", &pyigl::quadprog,
+    "G"_a, "g0"_a,
+    "CE"_a = Eigen::MatrixXN(), "ce0"_a = Eigen::VectorXN(),
+    "CI"_a = Eigen::MatrixXN(), "ci0"_a = Eigen::VectorXN(),
+    R"(Solve a dense convex quadratic program.
+
+Minimizes:  0.5 x' G x + g0' x
+Subject to: CE' x + ce0  = 0
+            CI' x + ci0 >= 0
+
+@param[in] G    #x by #x positive semi-definite quadratic cost matrix
+@param[in] g0   #x linear cost vector
+@param[in] CE   #x by #ce equality constraint matrix (optional)
+@param[in] ce0  #ce equality constraint rhs (optional)
+@param[in] CI   #x by #ci inequality constraint matrix (optional)
+@param[in] ci0  #ci inequality constraint rhs (optional)
+@return x  #x solution vector
+@raises RuntimeError if the solver fails)");
+}

libigl-2.6.3.dev2/src/copyleft/tetgen/cdt.cpp

@@ -0,0 +1,57 @@
+#include "default_types.h"
+#include <igl/copyleft/tetgen/cdt.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto cdt(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const igl::copyleft::tetgen::CDTParam &param)
+  {
+    // int32 required by libigl tetgen internals
+    Eigen::MatrixXi Fi = F.cast<int>();
+    Eigen::MatrixXN TV;
+    Eigen::MatrixXi TT, TF;
+    // Note: libigl cdt() returns tetrahedralize()'s int (0=success) cast to
+    // bool, so false means success. Check output TT instead.
+    igl::copyleft::tetgen::cdt(V, Fi, param, TV, TT, TF);
+    if(TT.rows() == 0)
+      throw std::runtime_error("cdt: tetrahedralization failed");
+    return std::make_tuple(TV, Eigen::MatrixXI(TT.cast<Integer>()),
+      Eigen::MatrixXI(TF.cast<Integer>()));
+  }
+}
+
+void bind_cdt(nb::module_ &m)
+{
+  nb::class_<igl::copyleft::tetgen::CDTParam>(m, "CDTParam")
+    .def(nb::init<>())
+    .def_rw("use_bounding_box",    &igl::copyleft::tetgen::CDTParam::use_bounding_box)
+    .def_rw("bounding_box_scale",  &igl::copyleft::tetgen::CDTParam::bounding_box_scale)
+    .def_rw("flags",               &igl::copyleft::tetgen::CDTParam::flags);
+
+  m.def("cdt", &pyigl::cdt,
+    "V"_a, "F"_a, "param"_a = igl::copyleft::tetgen::CDTParam{},
+    R"(Create a constrained Delaunay tetrahedralization of the convex hull of a mesh.
+
+The input mesh must be non-self-intersecting.
+
+@param[in] V  #V by 3 list of input mesh vertices
+@param[in] F  #F by 3 list of input mesh facets
+@param[in] param  CDTParam struct with fields:
+    use_bounding_box    force meshing of the bounding box (default: false)
+    bounding_box_scale  scale factor for bounding box (default: 1.01)
+    flags               tetgen flags, do not include "c" (default: "Y")
+@return tuple (TV, TT, TF):
+  - TV  #TV by 3 output vertex positions (input vertices come first)
+  - TT  #TT by 4 tetrahedra indices into TV
+  - TF  #TF by 3 surface triangle indices (facets from F, possibly subdivided)
+@raises RuntimeError on failure)");
+}

libigl-2.6.3.dev2/src/copyleft/tetgen/mesh_with_skeleton.cpp

@@ -0,0 +1,61 @@
+#include "default_types.h"
+#include <igl/copyleft/tetgen/mesh_with_skeleton.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto mesh_with_skeleton(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    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 int samples_per_bone,
+    const std::string &tetgen_flags)
+  {
+    // Non-template API uses MatrixXd/MatrixXi (col-major, int32)
+    Eigen::MatrixXd Vd = V, Cd = C;
+    Eigen::MatrixXi Fd = F.cast<int>(), BEd = BE.cast<int>(), CEd = CE.cast<int>();
+    Eigen::VectorXi Pd = P.cast<int>();
+    Eigen::MatrixXd VV;
+    Eigen::MatrixXi TT, FF;
+    if(!igl::copyleft::tetgen::mesh_with_skeleton(Vd, Fd, Cd, Pd, BEd, CEd,
+        samples_per_bone, tetgen_flags, VV, TT, FF))
+      throw std::runtime_error("mesh_with_skeleton: tetrahedralization failed");
+    return std::make_tuple(Eigen::MatrixXN(VV), Eigen::MatrixXI(TT.cast<Integer>()),
+      Eigen::MatrixXI(FF.cast<Integer>()));
+  }
+}
+
+void bind_mesh_with_skeleton(nb::module_ &m)
+{
+  m.def("mesh_with_skeleton", &pyigl::mesh_with_skeleton,
+    "V"_a, "F"_a, "C"_a,
+    "P"_a = Eigen::VectorXI(),
+    "BE"_a = Eigen::MatrixXI(),
+    "CE"_a = Eigen::MatrixXI(),
+    "samples_per_bone"_a = 10,
+    "tetgen_flags"_a = "",
+    R"(Mesh the interior of a surface with a graded tetrahedral mesh conforming to a skeleton.
+
+@param[in] V  #V by 3 list of surface mesh vertex positions
+@param[in] F  #F by 3 list of triangle indices
+@param[in] C  #C by 3 list of skeleton joint positions
+@param[in] P  #P list of point handle indices into C (optional)
+@param[in] BE #BE by 2 list of bone edge indices into C (optional)
+@param[in] CE #CE by 2 list of cage edge indices into P (optional)
+@param[in] samples_per_bone  number of samples added per bone (default: 10)
+@param[in] tetgen_flags  tetgen option string (default: "" → "pq2Y")
+@return tuple (VV, TT, FF):
+  - VV  #VV by 3 tet-mesh vertex positions
+  - TT  #TT by 4 tetrahedra indices
+  - FF  #FF by 3 surface triangle indices
+@raises RuntimeError on failure)");
+}

libigl-2.6.3.dev2/src/embree/bone_visible.cpp

@@ -0,0 +1,40 @@
+#include "default_types.h"
+#include <igl/embree/bone_visible.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto bone_visible(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const nb::DRef<const Eigen::VectorXN> &s,
+    const nb::DRef<const Eigen::VectorXN> &d)
+  {
+    // int32 required; s/d must be column vectors (VectorXd), not row vectors
+    Eigen::MatrixXi Fi = F.cast<int>();
+    Eigen::Matrix<bool, Eigen::Dynamic, 1> flag;
+    // Pass s and d as VectorXN (column vectors) — DerivedSD must be col vector
+    igl::embree::bone_visible(V, Fi, s, d, flag);
+    return Eigen::VectorXB(flag);
+  }
+}
+
+void bind_bone_visible(nb::module_ &m)
+{
+  m.def("bone_visible", &pyigl::bone_visible,
+    "V"_a, "F"_a, "s"_a, "d"_a,
+    R"(Test which mesh vertices are visible to a bone segment.
+
+A vertex v is "visible" if the line segment from its projection onto the
+bone to v does not intersect the mesh (see Baran & Popovic 2007).
+
+@param[in] V  #V by 3 list of mesh vertex positions
+@param[in] F  #F by 3 list of triangle indices
+@param[in] s  3-vector: bone start position
+@param[in] d  3-vector: bone end position
+@return flag  #V bool vector, true if vertex is visible to the bone)");
+}

libigl-2.6.3.dev2/src/embree/line_mesh_intersection.cpp

@@ -0,0 +1,44 @@
+#include "default_types.h"
+#include <igl/embree/line_mesh_intersection.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto line_mesh_intersection(
+    const nb::DRef<const Eigen::MatrixXN> &V_source,
+    const nb::DRef<const Eigen::MatrixXN> &N_source,
+    const nb::DRef<const Eigen::MatrixXN> &V_target,
+    const nb::DRef<const Eigen::MatrixXI> &F_target)
+  {
+    // Explicit template instantiation: copies to col-major double/int
+    Eigen::MatrixXd vs = V_source, ns = N_source, vt = V_target;
+    Eigen::MatrixXi ft = F_target.cast<int>();
+    Eigen::MatrixXd result =
+      igl::embree::line_mesh_intersection<Eigen::MatrixXd, Eigen::MatrixXi>(
+        vs, ns, vt, ft);
+    return Eigen::MatrixXN(result);
+  }
+}
+
+void bind_line_mesh_intersection(nb::module_ &m)
+{
+  m.def("line_mesh_intersection", &pyigl::line_mesh_intersection,
+    "V_source"_a, "N_source"_a, "V_target"_a, "F_target"_a,
+    R"(Project a point cloud onto a target mesh by ray casting along normals.
+
+For each source point, a ray is cast along its normal (and the opposite
+direction). The nearest intersection with the target mesh is returned as
+barycentric coordinates.
+
+@param[in] V_source  #V by 3 source point positions
+@param[in] N_source  #V by 3 source point normals
+@param[in] V_target  #V2 by 3 target mesh vertex positions
+@param[in] F_target  #F2 by 3 target mesh triangle indices
+@return  #V by 3 matrix of barycentric hits: each row is (face_id, b1, b2)
+    where face_id is the index of the hit face and b1, b2 are barycentric
+    coordinates w.r.t. the first two edges)");
+}

libigl-2.6.3.dev2/src/triangle/cdt.cpp

@@ -0,0 +1,47 @@
+#include "default_types.h"
+#include <igl/triangle/cdt.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto cdt(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &E,
+    const std::string &flags)
+  {
+    // int32 required by libigl triangle internals
+    Eigen::MatrixXi Ei = E.cast<int>();
+    Eigen::MatrixXN WV;
+    Eigen::MatrixXi WF, WE;
+    Eigen::VectorXi J;
+    igl::triangle::cdt(V, Ei, flags, WV, WF, WE, J);
+    return std::make_tuple(WV, Eigen::MatrixXI(WF.cast<Integer>()),
+      Eigen::MatrixXI(WE.cast<Integer>()), Eigen::VectorXI(J.cast<Integer>()));
+  }
+}
+
+void bind_cdt(nb::module_ &m)
+{
+  m.def("cdt", &pyigl::cdt, "V"_a, "E"_a, "flags"_a = "-c",
+    R"(Constrained Delaunay triangulation of the convex hull of 2D points and segments.
+
+Preprocesses input to remove duplicates before calling triangle. Unlike
+triangulate(), this returns an adjusted edge list on the output.
+
+@param[in] V  #V by 2 list of 2D vertex positions
+@param[in] E  #E by 2 list of constraint edge indices into V
+@param[in] flags  triangle option string; should contain "-c" unless segments
+    already enclose all points (default: "-c")
+@return tuple (WV, WF, WE, J):
+  - WV  #WV by 2 background mesh vertex positions
+  - WF  #WF by 3 background mesh triangle indices into WV
+  - WE  #WE by 2 constraint edge indices into WV (may be smaller than E
+        if degenerate constraints were removed)
+  - J   #V list of indices into WF/WE for each original vertex in V)");
+}

libigl-2.6.3.dev2/src/triangle/refine.cpp

@@ -0,0 +1,39 @@
+#include "default_types.h"
+#include <igl/triangle/refine.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/eigen/dense.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+namespace pyigl
+{
+  auto refine(
+    const nb::DRef<const Eigen::MatrixXN> &V,
+    const nb::DRef<const Eigen::MatrixXI> &E,
+    const nb::DRef<const Eigen::MatrixXI> &F,
+    const std::string &flags)
+  {
+    Eigen::MatrixXN V2;
+    Eigen::MatrixXI F2;
+    igl::triangle::refine(V, E, F, flags, V2, F2);
+    return std::make_tuple(V2, F2);
+  }
+}
+
+void bind_refine(nb::module_ &m)
+{
+  m.def("refine", &pyigl::refine,
+    "V"_a, "E"_a, "F"_a, "flags"_a = "q",
+    R"(Refine an existing 2D triangulation.
+
+@param[in] V  #V by 2 list of 2D vertex positions
+@param[in] E  #E by 2 list of segment indices (constraint edges)
+@param[in] F  #F by 3 list of triangle indices
+@param[in] flags  triangle option string (default: "q" for quality refinement)
+@return tuple (V2, F2):
+  - V2  #V2 by 2 refined vertex positions
+  - F2  #F2 by 3 refined triangle indices)");
+}