libigl 2.5.4.dev0__cp313-abi3-win_amd64.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,154 @@
+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 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 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
+    """
+
+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,16 @@
+from typing import Annotated
+
+from numpy.typing import ArrayLike
+
+
+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
+    """

igl/copyleft/tetgen/__init__.py

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

igl/copyleft/tetgen/pyigl_copyleft_tetgen.pyi

@@ -0,0 +1,29 @@
+from typing import Annotated
+
+from numpy.typing import ArrayLike
+
+
+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/embree/__init__.py

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

igl/embree/pyigl_embree.pyi

@@ -0,0 +1,82 @@
+from typing import Annotated, overload
+
+from numpy.typing import ArrayLike
+
+
+class EmbreeIntersector:
+    def __init__(self) -> None: ...
+
+    def init(self, V: Annotated[ArrayLike, dict(dtype='float32', shape=(None, 3), order='F')], F: Annotated[ArrayLike, dict(dtype='int32', shape=(None, 3), order='F')], isStatic: bool = False) -> None: ...
+
+    def intersectRay_first(self, origin: Annotated[ArrayLike, dict(dtype='float32', shape=(3), order='C')], direction: Annotated[ArrayLike, dict(dtype='float32', shape=(3), order='C')], tnear: float = 0, tfar: float = float('inf')) -> tuple[int, float, float, float]: ...
+
+    def intersectRay(self, origin: Annotated[ArrayLike, dict(dtype='float32', shape=(3), order='C')], direction: Annotated[ArrayLike, dict(dtype='float32', shape=(3), order='C')], tnear: float = 0, tfar: float = float('inf')) -> tuple[list[tuple[int, float, float, float]], int]: ...
+
+@overload
+def ambient_occlusion(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, None), writable=False)], N: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], num_samples: int) -> Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')]:
+    """
+    Compute ambient occlusion per given point
+
+    @param[in] V  #V by 3 list of mesh vertex positiosn
+    @param[in] F  #F by 3 list of mesh triangle indices into rows of V
+    @param[in] P  #P by 3 list of origin points
+    @param[in] N  #P by 3 list of origin normals
+    @param[out] S  #P list of ambient occlusion values between 1 (fully occluded) and
+         0 (not occluded)
+    """
+
+@overload
+def ambient_occlusion(ei: EmbreeIntersector, P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], N: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], num_samples: int) -> Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')]:
+    """
+    Compute ambient occlusion per given point
+
+    @param[in] ei  EmbreeIntersector containing (V,F)
+    @param[in] P  #P by 3 list of origin points
+    @param[in] N  #P by 3 list of origin normals
+    @param[out] S  #P list of ambient occlusion values between 1 (fully occluded) and
+         0 (not occluded)
+    """
+
+def reorient_facets_raycast(V: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], F: Annotated[ArrayLike, dict(dtype='int64', shape=(None, None), writable=False)], rays_total: int = -1, rays_minimum: int = 10, facet_wise: bool = False, use_parity: bool = False, is_verbose: bool = False) -> tuple[Annotated[ArrayLike, dict(dtype='bool', shape=(None), order='C')], Annotated[ArrayLike, dict(dtype='int64', shape=(None), order='C')]]:
+    """
+    Orient each component (identified by C) of a mesh (V,F) using ambient
+    occlusion such that the front side is less occluded than back side, as
+    described in "A Simple Method for Correcting Facet Orientations in
+    Polygon Meshes Based on Ray Casting" [Takayama et al. 2014].
+
+    @param[in] V  #V by 3 list of vertex positions
+    @param[in] F  #F by 3 list of triangle indices
+    @param[in] rays_total  Total number of rays that will be shot
+    @param[in] rays_minimum  Minimum number of rays that each patch should receive
+    @param[in] facet_wise  Decision made for each face independently, no use of patches
+        (i.e., each face is treated as a patch)
+    @param[in] use_parity  Use parity mode
+    @param[in] is_verbose  Verbose output to cout
+    @param[out] I  #F list of whether face has been flipped
+    @param[out] C  #F list of patch ID (output of bfs_orient > manifold patches)
+    """
+
+@overload
+def shape_diameter_function(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, None), writable=False)], N: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], num_samples: int) -> Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')]:
+    """
+    Compute shape diameter function per given point
+
+    @param[in] V  #V by 3 list of mesh vertex positiosn
+    @param[in] F  #F by 3 list of mesh triangle indices into rows of V
+    @param[in] P  #P by 3 list of origin points
+    @param[in] N  #P by 3 list of origin normals
+    @param[out] S  #P list of ambient occlusion values between 1 (fully occluded) and
+         0 (not occluded)
+    """
+
+@overload
+def shape_diameter_function(ei: EmbreeIntersector, P: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], N: Annotated[ArrayLike, dict(dtype='float64', shape=(None, None), writable=False)], num_samples: int) -> Annotated[ArrayLike, dict(dtype='float64', shape=(None), order='C')]:
+    """
+    Compute shape diameter function per given point
+
+    @param[in] ei  EmbreeIntersector containing (V,F)
+    @param[in] P  #P by 3 list of origin points
+    @param[in] N  #P by 3 list of origin normals
+    @param[out] S  #P list of ambient occlusion values between 1 (fully occluded) and
+         0 (not occluded)
+    """