Add ~55 new core bindings and tests

New bindings: accumarray, barycentric_interpolation, bezier, colormap,
combine, dijkstra/dijkstra_backtrack, directed_edge_parents, edge_topology,
edges_to_path, euler_characteristic, exterior_edges, extract_manifold_patches,
face_occurrences, fit_plane, flipped_triangles, flood_fill, hausdorff,
hsv_to_rgb/rgb_to_hsv, is_boundary_edge, is_delaunay, is_irregular_vertex,
iterative_closest_point, lbs_matrix, look_at, mvc, orient_outward,
orientable_patches, per_corner_normals, per_edge_normals,
per_vertex_attribute_smoothing, polar_dec, procrustes, pseudonormal_test,
random_dir/random_dir_stratified, ray_sphere_intersect, ray_triangle_intersect,
readCSV, readSTL, rgb_to_hsv, rigid_alignment, rotation_matrix_from_directions,
sample_edges, segment_segment_intersect, sharp_edges, signed_angle, snap_points,
solid_angle, super_fibonacci, tet_tet_adjacency, tri_tri_intersect,
turning_number, uniformly_sample_two_manifold, vector_area_matrix, voronoi_mass,
writeOFF, writeSTL.

Also fixes extract_manifold_patches to use std::make_tuple (was std::make_pair
with missing nanobind/stl/pair.h include). Adds 8 new test functions covering
all new bindings; total test count goes from 48 to 56.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: alecjacobson

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)");
+}

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)");
+}

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)");
+}

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])");
+}

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))");
+}

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)");
+}

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))");
+}

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))");
+}