pattapatta 0.2.0

package/dist/meshing/index.d.ts

@@ -0,0 +1,125 @@
+import { V as Vec2 } from '../vec2-CWyXN1Wj.js';
+import { S as Segment } from '../segment-BKuIFMKD.js';
+import { P as Path } from '../path-0RjhYjJs.js';
+import { G as Group } from '../group-BNjVVYSQ.js';
+
+/** Edges shared by at least two faces (excludes perimeter and hole boundaries). */
+declare function extractInnerEdges(faces: Path[]): Segment[];
+/** Vertices not on the mesh perimeter. */
+declare function extractInnerVertices(faces: Path[]): Vec2[];
+/** First face that contains `point`, or null. */
+declare function findContainingFace(faces: Path[], point: Vec2): Path | null;
+/** Split every face edge longer than `maxLen` by inserting subdivision points. */
+declare function splitEdges(faces: Path[], maxLen: number): Group;
+/** Urquhart faces: remove longest edge of each triangle, then polygonize. */
+declare function urquhartFaces(input: Vec2[] | Path[], preservePerimeter?: boolean): Group;
+/** Gabriel graph faces from a point set or triangulation. */
+declare function gabrielFaces(input: Vec2[] | Path[], preservePerimeter?: boolean): Group;
+/** Relative-neighborhood graph faces. */
+declare function relativeNeighborFaces(input: Vec2[] | Path[], preservePerimeter?: boolean): Group;
+/**
+ * Greedy sparse spanner faces. Higher `k` allows longer detours, so more edges
+ * are collapsed → larger faces.
+ */
+declare function spannerFaces(input: Vec2[] | Path[], k?: number, preservePerimeter?: boolean): Group;
+/**
+ * Dual faces of a triangulation: closed polygons connecting centroids of
+ * triangles around each interior primal vertex.
+ */
+declare function dualFaces(faces: Path[]): Group;
+/**
+ * Centroid quadrangulation: one quad per triangulation edge using the
+ * centroids of the one or two incident triangles.
+ */
+declare function centroidQuadrangulation(input: Vec2[] | Path[], preservePerimeter?: boolean): Group;
+/**
+ * Split (Catmull–Clark) quadrangulation: 3 quads per triangle via edge
+ * midpoints and the face centroid.
+ */
+declare function splitQuadrangulation(input: Vec2[] | Path[]): Group;
+/**
+ * Edge-collapse quadrangulation: greedy pairing of adjacent triangles into quads
+ * (edge-coloring style collapse of shared edges).
+ */
+declare function edgeCollapseQuadrangulation(input: Vec2[] | Path[], preservePerimeter?: boolean): Group;
+/**
+ * Matching quadrangulation: quality-weighted greedy matching of triangles
+ * (Blossom-Quad first step; leftover triangles retained).
+ */
+declare function matchingQuadrangulation(input: Vec2[] | Path[]): Group;
+/**
+ * Spiral quadrangulation from a point set (characteristic spiral pattern).
+ */
+declare function spiralQuadrangulation(points: Vec2[]): Group;
+/** Weighted Laplacian mesh smoothing. */
+declare function smoothMesh(faces: Path[], iterationsOrCutoff: number, preservePerimeter?: boolean): Group;
+/**
+ * Catmull–Clark-style subdivision: split each edge at `edgeSplitRatio` and
+ * connect to the face centroid (N subfaces per N-gon).
+ */
+declare function subdivideMesh(faces: Path[], edgeSplitRatio?: number): Group;
+/**
+ * Simplify face boundaries while preserving mesh topology (shared edges
+ * simplified once, then faces rebuilt).
+ */
+declare function simplifyMesh(faces: Path[], tolerance: number, preservePerimeter?: boolean): Group;
+/** Randomly dissolve adjacent faces that share a class id. */
+declare function stochasticMerge(faces: Path[], nClasses: number, seed?: number): Group;
+/**
+ * Merge faces below `minArea` into adjacent neighbors, or merge until at most
+ * `remainingFaces` remain when options use `{ remainingFaces }`.
+ */
+declare function areaMerge(faces: Path[], minAreaOrOptions: number | {
+    minArea?: number;
+    remainingFaces?: number;
+}): Group;
+/**
+ * Locate near-miss gaps between faces that should form a valid mesh
+ * (boundary segments without a matching twin within a tiny tolerance).
+ */
+declare function findBreaks(faces: Path[]): Group;
+/**
+ * Clean inter-face gaps/overlaps/slivers toward a valid coverage by snapping
+ * vertices within `maxGapWidth` and dissolving overlaps.
+ */
+declare function fixBreaks(faces: Path[], maxGapWidth: number): Group;
+/**
+ * Endpoint-only snap within `tolerance`, then optionally polygonize linework
+ * into faces.
+ */
+declare function fixBrokenFaces(coverage: Path[], tolerance: number, polygonise?: boolean): Group;
+/** Disconnected face islands sorted by face count descending. */
+declare function findIslands(faces: Path[]): Group[];
+/** Sort faces by centroid angle around their collective centroid. */
+declare function radialSortFaces(faces: Path[]): Path[];
+/** Sort faces by centroid x then y. */
+declare function centroidSortFaces(faces: Path[]): Path[];
+declare const meshing: {
+    extractInnerEdges: typeof extractInnerEdges;
+    extractInnerVertices: typeof extractInnerVertices;
+    findContainingFace: typeof findContainingFace;
+    splitEdges: typeof splitEdges;
+    urquhartFaces: typeof urquhartFaces;
+    gabrielFaces: typeof gabrielFaces;
+    relativeNeighborFaces: typeof relativeNeighborFaces;
+    spannerFaces: typeof spannerFaces;
+    dualFaces: typeof dualFaces;
+    centroidQuadrangulation: typeof centroidQuadrangulation;
+    edgeCollapseQuadrangulation: typeof edgeCollapseQuadrangulation;
+    splitQuadrangulation: typeof splitQuadrangulation;
+    spiralQuadrangulation: typeof spiralQuadrangulation;
+    matchingQuadrangulation: typeof matchingQuadrangulation;
+    smoothMesh: typeof smoothMesh;
+    subdivideMesh: typeof subdivideMesh;
+    simplifyMesh: typeof simplifyMesh;
+    stochasticMerge: typeof stochasticMerge;
+    areaMerge: typeof areaMerge;
+    radialSortFaces: typeof radialSortFaces;
+    centroidSortFaces: typeof centroidSortFaces;
+    findBreaks: typeof findBreaks;
+    fixBreaks: typeof fixBreaks;
+    fixBrokenFaces: typeof fixBrokenFaces;
+    findIslands: typeof findIslands;
+};
+
+export { areaMerge, centroidQuadrangulation, centroidSortFaces, dualFaces, edgeCollapseQuadrangulation, extractInnerEdges, extractInnerVertices, findBreaks, findContainingFace, findIslands, fixBreaks, fixBrokenFaces, gabrielFaces, matchingQuadrangulation, meshing, radialSortFaces, relativeNeighborFaces, simplifyMesh, smoothMesh, spannerFaces, spiralQuadrangulation, splitEdges, splitQuadrangulation, stochasticMerge, subdivideMesh, urquhartFaces };