libigl 2.6.4.dev0__cp312-abi3-win_arm64.whl

igl/__init__.py

@@ -0,0 +1 @@
+from .pyigl_core import *

igl/copyleft/__init__.py

@@ -0,0 +1 @@
+from .pyigl_copyleft_core import *

igl/copyleft/cgal/__init__.py

@@ -0,0 +1 @@
+from .pyigl_copyleft_cgal import *

igl/copyleft/cgal/pyigl_copyleft_cgal.pyi

@@ -0,0 +1,231 @@
+from typing import Annotated, overload
+
+from numpy.typing import ArrayLike
+
+
+def convex_hull(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)]) -> Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')]:
+    """
+    Compute the convex hull of a set of points, returning only the triangular faces of the hull.
+
+        @param[in] V  #V by 3 matrix of input points
+        @return F: #F by 3 matrix of triangle indices into V
+    """
+
+def coplanar(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)]) -> bool:
+    """
+    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
+    """
+
+def delaunay_triangulation(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)]) -> Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')]:
+    """
+    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
+    """
+
+def extract_cells(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)]) -> tuple[int, Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')]]:
+    """
+    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
+    """
+
+def fast_winding_number(P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], N: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], Q: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], expansion_order: int = 2, beta: float = 2.0) -> Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')]:
+    """
+    Evaluate the fast winding number for point data with adjustable accuracy.
+
+        @param[in] P  #P by 3 list of point locations
+        @param[in] N  #P by 3 list of point normals
+        @param[in] Q  #Q by 3 list of query points for the winding number
+        @param[in] expansion_order  Order of the Taylor expansion (0, 1, or 2)
+        @param[in] beta  Barnes-Hut style accuracy parameter (recommended: 2)
+        @return Vector of winding number values for each query point
+    """
+
+def intersect_other(VA: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], FA: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], VB: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], FB: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], detect_only: bool = False, first_only: bool = False, stitch_all: bool = False, slow_and_more_precise_rounding: bool = False, cutoff: int = 1000) -> tuple[Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Detect intersecting faces between two triangle meshes, providing detailed output.
+
+        @param[in] VA  #V by 3 list of vertices for first mesh
+        @param[in] FA  #F by 3 list of faces for first mesh
+        @param[in] VB  #V by 3 list of vertices for second mesh
+        @param[in] FB  #F by 3 list of faces for second mesh
+        @param[in] detect_only  only detect intersections, do not resolve
+        @param[in] first_only  only return first intersection
+        @param[in] stitch_all  stitch all intersections
+        @param[in] slow_and_more_precise_rounding  use slow and more precise rounding
+        @param[in] cutoff  maximum number of intersections to resolve
+        @return Tuple containing:
+          - success: bool indicating if the operation succeeded
+          - IF: # intersecting face pairs
+          - VVAB: list of intersection vertex positions
+          - FFAB: list of triangle indices into VVAB
+          - JAB: list of indices into [FA;FB] denoting the birth triangle
+          - IMAB: indices stitching duplicates from intersections
+    """
+
+@overload
+def intersect_with_half_space(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], p: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)], n: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Intersect a PWN mesh with a half-space using a point and normal.
+
+        @param[in] V  #V by 3 list of mesh vertex positions
+        @param[in] F  #F by 3 list of triangle indices
+        @param[in] p  3D point on plane
+        @param[in] n  3D normal vector
+        @return Tuple containing:
+          - success: bool, true if successful
+          - VC: vertices of resulting mesh
+          - FC: face indices of resulting mesh
+          - J: birth facet indices
+    """
+
+@overload
+def intersect_with_half_space(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], equ: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Intersect a PWN mesh with a half-space using the plane equation.
+
+        @param[in] V  #V by 3 list of mesh vertex positions
+        @param[in] F  #F by 3 list of triangle indices
+        @param[in] equ  Plane equation coefficients (a, b, c, d)
+        @return Tuple containing:
+          - success: bool, true if successful
+          - VC: vertices of resulting mesh
+          - FC: face indices of resulting mesh
+          - J: birth facet indices
+    """
+
+def mesh_boolean(VA: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], FA: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], VB: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)] = ..., FB: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)] = ..., type_str: str) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Compute the boolean operation (union, intersection, difference, etc.) between two meshes.
+
+    @param[in] VA #VA by dim matrix of mesh A vertices
+    @param[in] FA #FA by simplex_size matrix of mesh A faces
+    @param[in] VB #VB by dim matrix of mesh B vertices
+    @param[in] FB #FB by simplex_size matrix of mesh B faces
+    @param[in] type_str Type of boolean operation: "union", "intersection", "difference", etc.
+    @param[out] VC #VC by dim matrix of result vertices
+    @param[out] FC #FC by simplex_size matrix of result faces
+    @param[out] J #FC list of indices indicating which input face contributed to each result face
+    @return Tuple containing:
+      - VC: Result vertices
+      - FC: Result faces
+      - J: Face origin indices
+    """
+
+def oriented_bounding_box(P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)]) -> Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')]:
+    """
+    Given a set of points compute the rotation transformation of them such
+    that their axis-aligned bounding box is as small as possible.
+
+    igl::oriented_bounding_box is often faster and better
+
+      @param[in] P  #P by 3 list of point locations
+      @param[out] R  rotation matrix
+    """
+
+def outer_hull(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='bool', shape=(None), order='C')]]:
+    """
+    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
+    """
+
+def peel_outer_hull_layers(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='bool', shape=(None), order='C')], int]:
+    """
+    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
+    """
+
+def peel_winding_number_layers(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], int]:
+    """
+    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
+    """
+
+def point_areas(P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], I: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], N: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')]]:
+    r"""
+    Given a 3D set of points P, each with a list of k-nearest-neighbours,
+    estimate the geodesic voronoi area associated with each point.
+
+    The k nearest neighbours may be known from running igl::knn_octree on
+    the output data from igl::octree. We reccomend using a k value
+    between 15 and 20 inclusive for accurate area estimation.
+
+    N is used filter the neighbours, to ensure area estimation only occurs
+    using neighbors that are on the same side of the surface (ie for thin
+    sheets), as well as to solve the orientation ambiguity of the tangent
+    plane normal.
+
+    \note This function *should* be implemented by pre-filtering I, rather
+    than filtering in this function using N. In this case, the function
+    would only take P and I as input.
+
+    @param[in] P  #P by 3 list of point locations
+    @param[in] I  #P by k list of k-nearest-neighbor indices into P
+    @param[in] N  #P by 3 list of point normals
+    @param[out] A  #P list of estimated areas
+    @param[out] T  #P by 3 list of tangent plane normals for each point
+
+    \see igl::knn
+    """
+
+def remesh_self_intersections(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], detect_only: bool = False, first_only: bool = False, stitch_all: bool = False, slow_and_more_precise_rounding: bool = False, cutoff: int = 1000) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Resolve self-intersections in a mesh, without returning unique vertex indices (IM).
+
+        @param[in] V  #V by 3 list of vertex positions
+        @param[in] F  #F by 3 list of face indices
+        @param[in] detect_only  only detect intersections, do not resolve
+        @param[in] first_only  only return first intersection
+        @param[in] stitch_all  stitch all intersections
+        @param[in] slow_and_more_precise_rounding  use slow and more precise rounding
+        @param[in] cutoff  maximum number of intersections to resolve
+        @return Tuple containing:
+          - VV: remeshed vertex positions
+          - FF: remeshed face indices
+          - IF: intersecting face pairs
+          - J: birth triangle indices
+          - IM if stitch_all = true   #VV list from 0 to #VV-1
+               elseif stitch_all = false  #VV list of indices into VV of unique vertices.
+    """
+
+def trim_with_solid(VA: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], FA: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], VB: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], FB: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='bool', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Trim a mesh with another solid mesh, determining which faces lie inside or outside.
+
+        @param[in] VA Vertex positions of mesh A
+        @param[in] FA Triangle indices of mesh A
+        @param[in] VB Vertex positions of mesh B (solid)
+        @param[in] FB Triangle indices of mesh B
+        @param[out] V Output vertex positions
+        @param[out] F Output triangle indices
+        @param[out] D Boolean vector indicating if each face is inside B
+        @param[out] J Indices into FA showing parent triangle
+    """

igl/copyleft/pyigl_copyleft_core.pyi

@@ -0,0 +1,65 @@
+from typing import Annotated, overload
+
+from numpy.typing import ArrayLike
+
+
+@overload
+def marching_cubes(values: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)], points: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], x_res: int, y_res: int, z_res: int, isovalue: float = 0.0) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')]]:
+    """
+    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
+    """
+
+@overload
+def marching_cubes(values: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)], points: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], indices: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], isovalue: float = 0.0) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')]]:
+    """
+    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
+    """
+
+def progressive_hulls(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='F')], F: Annotated[ArrayLike, dict(dtype='int32', shape=(None, None), order='F')], max_m: int = 0) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='F')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='F')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Performs progressive hull simplification on a mesh, collapsing edges until a target number of faces is reached.
+
+        @param[in] V  #V by dim list of vertex positions
+        @param[in] F  #F by 3 list of face indices into V
+        @param[in] max_m Target number of output faces
+        @param[out] U Output vertex positions
+        @param[out] G Output face indices into U
+        @param[out] J Indices into F indicating the birth face for each face in G
+    """
+
+def quadprog(G: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], g0: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)], CE: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)] = ..., ce0: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)] = ..., CI: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)] = ..., ci0: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)] = ...) -> Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')]:
+    """
+    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
+    """

igl/copyleft/tetgen/__init__.py

@@ -0,0 +1 @@
+from .pyigl_copyleft_tetgen import *

igl/copyleft/tetgen/pyigl_copyleft_tetgen.pyi

@@ -0,0 +1,88 @@
+from typing import Annotated
+
+from numpy.typing import ArrayLike
+
+
+class CDTParam:
+    def __init__(self) -> None: ...
+
+    @property
+    def use_bounding_box(self) -> bool: ...
+
+    @use_bounding_box.setter
+    def use_bounding_box(self, arg: bool, /) -> None: ...
+
+    @property
+    def bounding_box_scale(self) -> float: ...
+
+    @bounding_box_scale.setter
+    def bounding_box_scale(self, arg: float, /) -> None: ...
+
+    @property
+    def flags(self) -> str: ...
+
+    @flags.setter
+    def flags(self, arg: str, /) -> None: ...
+
+def cdt(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], param: CDTParam = ...) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')]]:
+    """
+    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
+    """
+
+def mesh_with_skeleton(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], C: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], P: Annotated[ArrayLike, dict(dtype='int64', shape=(None), writable=False)] = ..., BE: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)] = ..., CE: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)] = ..., samples_per_bone: int = 10, tetgen_flags: str = '') -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')]]:
+    """
+    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
+    """
+
+def tetrahedralize(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)] = ..., H: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)] = ..., VM: Annotated[ArrayLike, dict(dtype='int64', shape=(None), writable=False)] = ..., FM: Annotated[ArrayLike, dict(dtype='int64', shape=(None), writable=False)] = ..., R: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)] = ..., flags: str = '') -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), order='C')], int]:
+    """
+    Mesh the interior of a surface mesh (V,F) using tetgen
+
+    @param[in] V  #V by 3 vertex position list
+    @param[in] F  #F list of polygon face indices into V (0-indexed)
+    @param[in] H  #H by 3 list of seed points inside holes
+    @param[in] VM  #VM list of vertex markers
+    @param[in] FM  #FM list of face markers
+    @param[in] R  #R by 5 list of region attributes            
+    @param[in] flags string of tetgen options (See tetgen documentation) e.g.
+        "pq1.414a0.01" tries to mesh the interior of a given surface with
+          quality and area constraints
+        "" will mesh the convex hull constrained to pass through V (ignores F)
+    @param[out] TV  #TV by 3 vertex position list
+    @param[out] TT  #TT by 4 list of tet face indices
+    @param[out] TF  #TF by 3 list of triangle face indices ('f', else
+      `boundary_facets` is called on TT)
+    @param[out] TR  #TT list of region ID for each tetrahedron      
+    @param[out] TN  #TT by 4 list of indices neighbors for each tetrahedron ('n')
+    @param[out] PT  #TV list of incident tetrahedron for a vertex ('m')
+    @param[out] FT  #TF by 2 list of tetrahedrons sharing a triface ('nn')
+    @param[out] num_regions Number of regions in output mesh
+    """

igl/cycodebase/__init__.py

@@ -0,0 +1 @@
+from .pyigl_cycodebase import *

igl/cycodebase/pyigl_cycodebase.pyi

@@ -0,0 +1,122 @@
+from typing import Annotated, overload
+
+from numpy.typing import ArrayLike
+
+
+@overload
+def box_cubic(C: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')]]:
+    """
+    Compute the min/max box corners tightly containing a cubic Bézier curve.
+
+    @param[in] C  4 by dim matrix of control points defining the cubic Bézier curve
+    @return Tuple (B1, B2) where
+      B1  1 by dim min corner of the bounding box
+      B2  1 by dim max corner of the bounding box
+    """
+
+@overload
+def box_cubic(P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], C: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')]]:
+    """
+    Compute bounding boxes for a collection of indexed cubic Bézier curves.
+
+    @param[in] P  #P by dim matrix of control point locations
+    @param[in] C  #C by 4 matrix of indices into P defining the cubics
+    @return Tuple (B1, B2) where
+      B1  #C by dim matrix of min corners of the bounding boxes
+      B2  #C by dim matrix of max corners of the bounding boxes
+    """
+
+@overload
+def point_cubic_squared_distance(Q: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], C: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')]]:
+    """
+    Squared distance from each query point to a cubic Bézier curve.
+
+    @param[in] Q  #Q by dim matrix of query points
+    @param[in] C  4 by dim matrix of control points for the cubic Bézier curve
+    @return Tuple (sqrD, S, K) where
+      sqrD  #Q vector of smallest squared distances
+      S     #Q vector of parameters of the closest points on the curve
+      K     #Q by dim matrix of closest points on the curve
+    """
+
+@overload
+def point_cubic_squared_distance(Q: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], C: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], D: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], B: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')]]:
+    """
+    Squared distance to a cubic Bézier curve, reusing precomputed monomial bases.
+
+    Compute the bases once with igl.cubic_monomial_bases(C) -> (M, D, B) and pass
+    (D, B) here so repeated queries against the same curve skip recomputing them.
+    The result matches the two-argument overload.
+
+    @param[in] Q  #Q by dim matrix of query points
+    @param[in] C  4 by dim matrix of control points for the cubic Bézier curve
+    @param[in] D  3 by dim matrix of monomial coefficients for dC/dt (from cubic_monomial_bases)
+    @param[in] B  6-vector of inner products of the monomial bases (from cubic_monomial_bases)
+    @return Tuple (sqrD, S, K) where
+      sqrD  #Q vector of smallest squared distances
+      S     #Q vector of parameters of the closest points on the curve
+      K     #Q by dim matrix of closest points on the curve
+    """
+
+@overload
+def point_spline_squared_distance(Q: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], C: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')]]:
+    """
+    Squared distance from each query point to a spline of cubic Bézier curves.
+
+    @param[in] Q  #Q by dim matrix of query points
+    @param[in] P  #P by dim matrix of spline control points
+    @param[in] C  #C by 4 matrix of indices into P defining the cubic Bézier curves
+    @return Tuple (sqrD, I, S, K) where
+      sqrD  #Q vector of smallest squared distances
+      I     #Q vector of indices of the closest cubic (row of C)
+      S     #Q vector of parameters of the closest points on that cubic
+      K     #Q by dim matrix of closest points on the spline
+    """
+
+@overload
+def point_spline_squared_distance(Q: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], C: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], B1: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], B2: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], leaf: Annotated[ArrayLike, dict(dtype='int64', shape=(None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')]]:
+    """
+    Squared distance to a spline, reusing a prebuilt Eytzinger AABB.
+
+    Build the AABB once with igl.cycodebase.spline_eytzinger_aabb(P, C) and pass its
+    (B1, B2, leaf) here so repeated queries against the same spline skip rebuilding
+    the acceleration structure. The result matches the unaccelerated overload.
+
+    @param[in] Q     #Q by dim matrix of query points
+    @param[in] P     #P by dim matrix of spline control points
+    @param[in] C     #C by 4 matrix of indices into P defining the cubic Bézier curves
+    @param[in] B1    #B by dim matrix of AABB min box corners (from spline_eytzinger_aabb)
+    @param[in] B2    #B by dim matrix of AABB max box corners (from spline_eytzinger_aabb)
+    @param[in] leaf  #B vector of AABB leaf node indices/flags (from spline_eytzinger_aabb)
+    @return Tuple (sqrD, I, S, K) where
+      sqrD  #Q vector of smallest squared distances
+      I     #Q vector of indices of the closest cubic (row of C)
+      S     #Q vector of parameters of the closest points on that cubic
+      K     #Q by dim matrix of closest points on the spline
+    """
+
+def roots(coef: Annotated[ArrayLike, dict(dtype='float64', shape=(None), writable=False)], xmin: float, xmax: float) -> tuple[int, Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')]]:
+    """
+    Find the real roots of a polynomial within an interval [xmin, xmax].
+
+    @param[in] coef  #coef list of monomial coefficients (low to high order); the
+      polynomial degree is len(coef)-1
+    @param[in] xmin  lower bound of the search interval
+    @param[in] xmax  upper bound of the search interval
+    @return Tuple (n, R) where
+      n  number of roots found in [xmin, xmax]
+      R  degree-length vector whose first n entries are the roots (ascending); the
+         remaining entries are NaN
+    """
+
+def spline_eytzinger_aabb(P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], C: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)]) -> tuple[Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Compute an Eytzinger-layout AABB tree for a spline of cubic Bézier curves.
+
+    @param[in] P  #P by dim matrix of spline control points
+    @param[in] C  #C by 4 matrix of indices into P defining the cubic Bézier curves
+    @return Tuple (B1, B2, leaf) where
+      B1    #B by dim matrix of AABB min box corners
+      B2    #B by dim matrix of AABB max box corners
+      leaf  #B vector of AABB leaf node indices/flags
+    """

igl/predicates/__init__.py

@@ -0,0 +1 @@
+from .pyigl_predicates import *