math 0.0.0 → 0.1.0

package/dist/geometry/polygon2-triangulate.js

@@ -0,0 +1,222 @@
+import { signedArea } from '../shapes/polygon2.js';
+
+/*
+ * Polygon triangulation (ear clipping)
+ *
+ * Triangulates a simple (non-self-intersecting) polygon into a fan of
+ * triangles, emitting triangle indices into the input vertex array. No new
+ * vertices are introduced.
+ *
+ * based on the algorithm from Joseph O'Rourke's "Computational Geometry in C").
+ * Uses the standard high-bit ear-mark trick on the working index list to stay allocation-light.
+ */
+// The working index list packs an "is-ear" flag into the high bit of each entry;
+// the low bits hold the actual vertex index.
+const IDX_MASK = 0x0fffffff;
+const EAR_FLAG = 0x80000000;
+const nextIdx = (i, n) => (i + 1 < n ? i + 1 : 0);
+const prevIdx = (i, n) => (i - 1 >= 0 ? i - 1 : n - 1);
+/** Twice the signed area of triangle (a, b, c); positive when counter-clockwise. */
+function area2(ax, ay, bx, by, cx, cy) {
+    return (bx - ax) * (cy - ay) - (cx - ax) * (by - ay);
+}
+function collinear(ax, ay, bx, by, cx, cy) {
+    return area2(ax, ay, bx, by, cx, cy) === 0;
+}
+/** True if segments (a,b) and (c,d) properly cross (no collinear/endpoint contact). */
+function intersectProp(ax, ay, bx, by, cx, cy, dx, dy) {
+    if (collinear(ax, ay, bx, by, cx, cy) ||
+        collinear(ax, ay, bx, by, dx, dy) ||
+        collinear(cx, cy, dx, dy, ax, ay) ||
+        collinear(cx, cy, dx, dy, bx, by)) {
+        return false;
+    }
+    const l1 = area2(ax, ay, bx, by, cx, cy) < 0;
+    const l2 = area2(ax, ay, bx, by, dx, dy) < 0;
+    const l3 = area2(cx, cy, dx, dy, ax, ay) < 0;
+    const l4 = area2(cx, cy, dx, dy, bx, by) < 0;
+    return l1 !== l2 && l3 !== l4;
+}
+/** True if point c lies on the closed segment (a,b), assuming the three are collinear. */
+function between(ax, ay, bx, by, cx, cy) {
+    if (!collinear(ax, ay, bx, by, cx, cy))
+        return false;
+    if (ax !== bx)
+        return (ax <= cx && cx <= bx) || (ax >= cx && cx >= bx);
+    return (ay <= cy && cy <= by) || (ay >= cy && cy >= by);
+}
+/** True if segments (a,b) and (c,d) intersect, including collinear/endpoint contact. */
+function intersectSeg(ax, ay, bx, by, cx, cy, dx, dy) {
+    if (intersectProp(ax, ay, bx, by, cx, cy, dx, dy))
+        return true;
+    return (between(ax, ay, bx, by, cx, cy) ||
+        between(ax, ay, bx, by, dx, dy) ||
+        between(cx, cy, dx, dy, ax, ay) ||
+        between(cx, cy, dx, dy, bx, by));
+}
+/** X of the original vertex referenced by working slot `s`. */
+const vX = (vertices, indices, s) => vertices[(indices[s] & IDX_MASK) * 2];
+/** Y of the original vertex referenced by working slot `s`. */
+const vY = (vertices, indices, s) => vertices[(indices[s] & IDX_MASK) * 2 + 1];
+/**
+ * True if the segment between working slots `i` and `j` does not intersect any
+ * polygon edge. `loose` uses proper-intersection only (tolerating collinear
+ * contact), used as a fallback when no strict ear can be found.
+ */
+function diagonalie(i, j, n, vertices, indices, loose) {
+    const d0x = vX(vertices, indices, i);
+    const d0y = vY(vertices, indices, i);
+    const d1x = vX(vertices, indices, j);
+    const d1y = vY(vertices, indices, j);
+    for (let k = 0; k < n; k++) {
+        const k1 = nextIdx(k, n);
+        if (k === i || k1 === i || k === j || k1 === j)
+            continue;
+        const e0x = vX(vertices, indices, k);
+        const e0y = vY(vertices, indices, k);
+        const e1x = vX(vertices, indices, k1);
+        const e1y = vY(vertices, indices, k1);
+        // Ignore edges that share an endpoint with the diagonal.
+        if ((d0x === e0x && d0y === e0y) ||
+            (d1x === e0x && d1y === e0y) ||
+            (d0x === e1x && d0y === e1y) ||
+            (d1x === e1x && d1y === e1y)) {
+            continue;
+        }
+        const hit = loose
+            ? intersectProp(d0x, d0y, d1x, d1y, e0x, e0y, e1x, e1y)
+            : intersectSeg(d0x, d0y, d1x, d1y, e0x, e0y, e1x, e1y);
+        if (hit)
+            return false;
+    }
+    return true;
+}
+/** True if the diagonal from slot `i` to slot `j` stays inside the cone at vertex `i`. */
+function inCone(i, j, n, vertices, indices, loose) {
+    const ax = vX(vertices, indices, i);
+    const ay = vY(vertices, indices, i);
+    const bx = vX(vertices, indices, j);
+    const by = vY(vertices, indices, j);
+    const ni = nextIdx(i, n);
+    const pi = prevIdx(i, n);
+    const nx = vX(vertices, indices, ni);
+    const ny = vY(vertices, indices, ni);
+    const px = vX(vertices, indices, pi);
+    const py = vY(vertices, indices, pi);
+    // Convex cone vertex: prev is left-on of (cone -> next).
+    if (area2(px, py, ax, ay, nx, ny) <= 0) {
+        const c1 = area2(ax, ay, bx, by, px, py); // (cone, test, prev)
+        const c2 = area2(bx, by, ax, ay, nx, ny); // (test, cone, next)
+        return loose ? c1 <= 0 && c2 <= 0 : c1 < 0 && c2 < 0;
+    }
+    // Reflex cone vertex.
+    return !(area2(ax, ay, bx, by, nx, ny) <= 0 && area2(bx, by, ax, ay, px, py) <= 0);
+}
+function diagonal(i, j, n, vertices, indices, loose) {
+    return inCone(i, j, n, vertices, indices, loose) && diagonalie(i, j, n, vertices, indices, loose);
+}
+/**
+ * Triangulates a simple polygon by ear clipping, writing triangle indices into
+ * `out` as `[i0, i1, i2, i3, i4, i5, ...]`, where each index refers to a vertex
+ * of the input polygon. Either winding is accepted (normalised internally).
+ *
+ * `out` must have room for at least `3 * (n - 2)` indices. A complete
+ * triangulation returns exactly `n - 2` triangles; a smaller count indicates
+ * the polygon could not be fully triangulated (e.g. degenerate input).
+ *
+ * @param out output array of triangle indices
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns the number of triangles written
+ */
+function triangulatePolygon2(out, vertices, n) {
+    if (n < 3)
+        return 0;
+    // Order the working list so the resolved polygon winds clockwise, which is
+    // what this ear-clipping formulation expects. The stored values are original
+    // vertex indices, so emitted triangles refer back to the caller's vertices
+    // regardless of input winding.
+    const ccw = signedArea(vertices, n) >= 0;
+    const indices = new Array(n);
+    for (let i = 0; i < n; i++)
+        indices[i] = ccw ? n - 1 - i : i;
+    let ntris = 0;
+    let dst = 0;
+    // Mark removable ears.
+    for (let i = 0; i < n; i++) {
+        const i1 = nextIdx(i, n);
+        if (diagonal(i, nextIdx(i1, n), n, vertices, indices, false))
+            indices[i1] |= EAR_FLAG;
+    }
+    let nv = n;
+    while (nv > 3) {
+        let minLen = -1;
+        let mini = -1;
+        // Clip the shortest available ear for well-shaped triangles.
+        for (let i = 0; i < nv; i++) {
+            const i1 = nextIdx(i, nv);
+            if (indices[i1] & EAR_FLAG) {
+                const p0 = indices[i] & IDX_MASK;
+                const p2 = indices[nextIdx(i1, nv)] & IDX_MASK;
+                const dx = vertices[p2 * 2] - vertices[p0 * 2];
+                const dy = vertices[p2 * 2 + 1] - vertices[p0 * 2 + 1];
+                const len = dx * dx + dy * dy;
+                if (minLen < 0 || len < minLen) {
+                    minLen = len;
+                    mini = i;
+                }
+            }
+        }
+        if (mini === -1) {
+            // No strict ear: retry with the loose diagonal test.
+            for (let i = 0; i < nv; i++) {
+                const i1 = nextIdx(i, nv);
+                const i2 = nextIdx(i1, nv);
+                if (diagonal(i, i2, nv, vertices, indices, true)) {
+                    const p0 = indices[i] & IDX_MASK;
+                    const p2 = indices[nextIdx(i2, nv)] & IDX_MASK;
+                    const dx = vertices[p2 * 2] - vertices[p0 * 2];
+                    const dy = vertices[p2 * 2 + 1] - vertices[p0 * 2 + 1];
+                    const len = dx * dx + dy * dy;
+                    if (minLen < 0 || len < minLen) {
+                        minLen = len;
+                        mini = i;
+                    }
+                }
+            }
+            if (mini === -1)
+                return ntris; // give up on degenerate input
+        }
+        const i = mini;
+        let i1 = nextIdx(i, nv);
+        const i2 = nextIdx(i1, nv);
+        out[dst++] = indices[i] & IDX_MASK;
+        out[dst++] = indices[i1] & IDX_MASK;
+        out[dst++] = indices[i2] & IDX_MASK;
+        ntris++;
+        // Remove the clipped vertex (slot i1) and re-evaluate its neighbours.
+        nv--;
+        for (let k = i1; k < nv; k++)
+            indices[k] = indices[k + 1];
+        if (i1 >= nv)
+            i1 = 0;
+        const iPrev = prevIdx(i1, nv);
+        if (diagonal(prevIdx(iPrev, nv), i1, nv, vertices, indices, false))
+            indices[iPrev] |= EAR_FLAG;
+        else
+            indices[iPrev] &= IDX_MASK;
+        if (diagonal(iPrev, nextIdx(i1, nv), nv, vertices, indices, false))
+            indices[i1] |= EAR_FLAG;
+        else
+            indices[i1] &= IDX_MASK;
+    }
+    // The final remaining triangle.
+    out[dst++] = indices[0] & IDX_MASK;
+    out[dst++] = indices[1] & IDX_MASK;
+    out[dst++] = indices[2] & IDX_MASK;
+    ntris++;
+    return ntris;
+}
+
+export { triangulatePolygon2 };
+//# sourceMappingURL=polygon2-triangulate.js.map

package/dist/geometry/polygon2-triangulate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon2-triangulate.js","sources":["../../src/geometry/polygon2-triangulate.ts"],"sourcesContent":["import { signedArea } from '../shapes/polygon2';\n\n/*\n * Polygon triangulation (ear clipping)\n *\n * Triangulates a simple (non-self-intersecting) polygon into a fan of\n * triangles, emitting triangle indices into the input vertex array. No new\n * vertices are introduced.\n *\n * based on the algorithm from Joseph O'Rourke's \"Computational Geometry in C\").\n * Uses the standard high-bit ear-mark trick on the working index list to stay allocation-light.\n */\n\n// The working index list packs an \"is-ear\" flag into the high bit of each entry;\n// the low bits hold the actual vertex index.\nconst IDX_MASK = 0x0fffffff;\nconst EAR_FLAG = 0x80000000;\n\nconst nextIdx = (i: number, n: number): number => (i + 1 < n ? i + 1 : 0);\nconst prevIdx = (i: number, n: number): number => (i - 1 >= 0 ? i - 1 : n - 1);\n\n/** Twice the signed area of triangle (a, b, c); positive when counter-clockwise. */\nfunction area2(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): number {\n    return (bx - ax) * (cy - ay) - (cx - ax) * (by - ay);\n}\n\nfunction collinear(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): boolean {\n    return area2(ax, ay, bx, by, cx, cy) === 0;\n}\n\n/** True if segments (a,b) and (c,d) properly cross (no collinear/endpoint contact). */\nfunction intersectProp(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, dx: number, dy: number): boolean {\n    if (\n        collinear(ax, ay, bx, by, cx, cy) ||\n        collinear(ax, ay, bx, by, dx, dy) ||\n        collinear(cx, cy, dx, dy, ax, ay) ||\n        collinear(cx, cy, dx, dy, bx, by)\n    ) {\n        return false;\n    }\n    const l1 = area2(ax, ay, bx, by, cx, cy) < 0;\n    const l2 = area2(ax, ay, bx, by, dx, dy) < 0;\n    const l3 = area2(cx, cy, dx, dy, ax, ay) < 0;\n    const l4 = area2(cx, cy, dx, dy, bx, by) < 0;\n    return l1 !== l2 && l3 !== l4;\n}\n\n/** True if point c lies on the closed segment (a,b), assuming the three are collinear. */\nfunction between(ax: number, ay: number, bx: number, by: number, cx: number, cy: number): boolean {\n    if (!collinear(ax, ay, bx, by, cx, cy)) return false;\n    if (ax !== bx) return (ax <= cx && cx <= bx) || (ax >= cx && cx >= bx);\n    return (ay <= cy && cy <= by) || (ay >= cy && cy >= by);\n}\n\n/** True if segments (a,b) and (c,d) intersect, including collinear/endpoint contact. */\nfunction intersectSeg(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, dx: number, dy: number): boolean {\n    if (intersectProp(ax, ay, bx, by, cx, cy, dx, dy)) return true;\n    return (\n        between(ax, ay, bx, by, cx, cy) ||\n        between(ax, ay, bx, by, dx, dy) ||\n        between(cx, cy, dx, dy, ax, ay) ||\n        between(cx, cy, dx, dy, bx, by)\n    );\n}\n\n/** X of the original vertex referenced by working slot `s`. */\nconst vX = (vertices: number[], indices: number[], s: number): number => vertices[(indices[s] & IDX_MASK) * 2];\n/** Y of the original vertex referenced by working slot `s`. */\nconst vY = (vertices: number[], indices: number[], s: number): number => vertices[(indices[s] & IDX_MASK) * 2 + 1];\n\n/**\n * True if the segment between working slots `i` and `j` does not intersect any\n * polygon edge. `loose` uses proper-intersection only (tolerating collinear\n * contact), used as a fallback when no strict ear can be found.\n */\nfunction diagonalie(i: number, j: number, n: number, vertices: number[], indices: number[], loose: boolean): boolean {\n    const d0x = vX(vertices, indices, i);\n    const d0y = vY(vertices, indices, i);\n    const d1x = vX(vertices, indices, j);\n    const d1y = vY(vertices, indices, j);\n\n    for (let k = 0; k < n; k++) {\n        const k1 = nextIdx(k, n);\n        if (k === i || k1 === i || k === j || k1 === j) continue;\n\n        const e0x = vX(vertices, indices, k);\n        const e0y = vY(vertices, indices, k);\n        const e1x = vX(vertices, indices, k1);\n        const e1y = vY(vertices, indices, k1);\n\n        // Ignore edges that share an endpoint with the diagonal.\n        if (\n            (d0x === e0x && d0y === e0y) ||\n            (d1x === e0x && d1y === e0y) ||\n            (d0x === e1x && d0y === e1y) ||\n            (d1x === e1x && d1y === e1y)\n        ) {\n            continue;\n        }\n\n        const hit = loose\n            ? intersectProp(d0x, d0y, d1x, d1y, e0x, e0y, e1x, e1y)\n            : intersectSeg(d0x, d0y, d1x, d1y, e0x, e0y, e1x, e1y);\n        if (hit) return false;\n    }\n    return true;\n}\n\n/** True if the diagonal from slot `i` to slot `j` stays inside the cone at vertex `i`. */\nfunction inCone(i: number, j: number, n: number, vertices: number[], indices: number[], loose: boolean): boolean {\n    const ax = vX(vertices, indices, i);\n    const ay = vY(vertices, indices, i);\n    const bx = vX(vertices, indices, j);\n    const by = vY(vertices, indices, j);\n\n    const ni = nextIdx(i, n);\n    const pi = prevIdx(i, n);\n    const nx = vX(vertices, indices, ni);\n    const ny = vY(vertices, indices, ni);\n    const px = vX(vertices, indices, pi);\n    const py = vY(vertices, indices, pi);\n\n    // Convex cone vertex: prev is left-on of (cone -> next).\n    if (area2(px, py, ax, ay, nx, ny) <= 0) {\n        const c1 = area2(ax, ay, bx, by, px, py); // (cone, test, prev)\n        const c2 = area2(bx, by, ax, ay, nx, ny); // (test, cone, next)\n        return loose ? c1 <= 0 && c2 <= 0 : c1 < 0 && c2 < 0;\n    }\n    // Reflex cone vertex.\n    return !(area2(ax, ay, bx, by, nx, ny) <= 0 && area2(bx, by, ax, ay, px, py) <= 0);\n}\n\nfunction diagonal(i: number, j: number, n: number, vertices: number[], indices: number[], loose: boolean): boolean {\n    return inCone(i, j, n, vertices, indices, loose) && diagonalie(i, j, n, vertices, indices, loose);\n}\n\n/**\n * Triangulates a simple polygon by ear clipping, writing triangle indices into\n * `out` as `[i0, i1, i2, i3, i4, i5, ...]`, where each index refers to a vertex\n * of the input polygon. Either winding is accepted (normalised internally).\n *\n * `out` must have room for at least `3 * (n - 2)` indices. A complete\n * triangulation returns exactly `n - 2` triangles; a smaller count indicates\n * the polygon could not be fully triangulated (e.g. degenerate input).\n *\n * @param out output array of triangle indices\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns the number of triangles written\n */\nexport function triangulatePolygon2(out: number[], vertices: number[], n: number): number {\n    if (n < 3) return 0;\n\n    // Order the working list so the resolved polygon winds clockwise, which is\n    // what this ear-clipping formulation expects. The stored values are original\n    // vertex indices, so emitted triangles refer back to the caller's vertices\n    // regardless of input winding.\n    const ccw = signedArea(vertices, n) >= 0;\n    const indices = new Array<number>(n);\n    for (let i = 0; i < n; i++) indices[i] = ccw ? n - 1 - i : i;\n\n    let ntris = 0;\n    let dst = 0;\n\n    // Mark removable ears.\n    for (let i = 0; i < n; i++) {\n        const i1 = nextIdx(i, n);\n        if (diagonal(i, nextIdx(i1, n), n, vertices, indices, false)) indices[i1] |= EAR_FLAG;\n    }\n\n    let nv = n;\n    while (nv > 3) {\n        let minLen = -1;\n        let mini = -1;\n\n        // Clip the shortest available ear for well-shaped triangles.\n        for (let i = 0; i < nv; i++) {\n            const i1 = nextIdx(i, nv);\n            if (indices[i1] & EAR_FLAG) {\n                const p0 = indices[i] & IDX_MASK;\n                const p2 = indices[nextIdx(i1, nv)] & IDX_MASK;\n                const dx = vertices[p2 * 2] - vertices[p0 * 2];\n                const dy = vertices[p2 * 2 + 1] - vertices[p0 * 2 + 1];\n                const len = dx * dx + dy * dy;\n                if (minLen < 0 || len < minLen) {\n                    minLen = len;\n                    mini = i;\n                }\n            }\n        }\n\n        if (mini === -1) {\n            // No strict ear: retry with the loose diagonal test.\n            for (let i = 0; i < nv; i++) {\n                const i1 = nextIdx(i, nv);\n                const i2 = nextIdx(i1, nv);\n                if (diagonal(i, i2, nv, vertices, indices, true)) {\n                    const p0 = indices[i] & IDX_MASK;\n                    const p2 = indices[nextIdx(i2, nv)] & IDX_MASK;\n                    const dx = vertices[p2 * 2] - vertices[p0 * 2];\n                    const dy = vertices[p2 * 2 + 1] - vertices[p0 * 2 + 1];\n                    const len = dx * dx + dy * dy;\n                    if (minLen < 0 || len < minLen) {\n                        minLen = len;\n                        mini = i;\n                    }\n                }\n            }\n            if (mini === -1) return ntris; // give up on degenerate input\n        }\n\n        const i = mini;\n        let i1 = nextIdx(i, nv);\n        const i2 = nextIdx(i1, nv);\n\n        out[dst++] = indices[i] & IDX_MASK;\n        out[dst++] = indices[i1] & IDX_MASK;\n        out[dst++] = indices[i2] & IDX_MASK;\n        ntris++;\n\n        // Remove the clipped vertex (slot i1) and re-evaluate its neighbours.\n        nv--;\n        for (let k = i1; k < nv; k++) indices[k] = indices[k + 1];\n        if (i1 >= nv) i1 = 0;\n        const iPrev = prevIdx(i1, nv);\n\n        if (diagonal(prevIdx(iPrev, nv), i1, nv, vertices, indices, false)) indices[iPrev] |= EAR_FLAG;\n        else indices[iPrev] &= IDX_MASK;\n\n        if (diagonal(iPrev, nextIdx(i1, nv), nv, vertices, indices, false)) indices[i1] |= EAR_FLAG;\n        else indices[i1] &= IDX_MASK;\n    }\n\n    // The final remaining triangle.\n    out[dst++] = indices[0] & IDX_MASK;\n    out[dst++] = indices[1] & IDX_MASK;\n    out[dst++] = indices[2] & IDX_MASK;\n    ntris++;\n\n    return ntris;\n}\n"],"names":[],"mappings":"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"}

package/dist/geometry/quickhull2.js

@@ -0,0 +1,123 @@
+const EPSILON = 1e-10;
+/**
+ * Computes the convex hull of a set of 2D points using the QuickHull algorithm.
+ * The hull is returned as an array of indices in counter-clockwise order.
+ *
+ * Implementation of pseudocode from: https://en.wikipedia.org/wiki/Quickhull
+ *
+ * @param points flat array of 2D points: [x0, y0, x1, y1, ...]
+ * @returns indices of hull vertices in ccw order
+ */
+function quickhull2(points) {
+    const n = Math.floor(points.length / 2);
+    if (n < 3)
+        return Array.from({ length: n }, (_, i) => i);
+    // find left and right most points
+    let leftIdx = 0;
+    let rightIdx = 0;
+    let minX = points[0];
+    let maxX = points[0];
+    for (let i = 1; i < n; i++) {
+        const x = points[i * 2];
+        if (x < minX) {
+            minX = x;
+            leftIdx = i;
+        }
+        if (x > maxX) {
+            maxX = x;
+            rightIdx = i;
+        }
+    }
+    if (Math.abs(maxX - minX) < EPSILON)
+        return [leftIdx];
+    // convex Hull starts with A and B
+    const hull = [];
+    // partition points into S1 and S2
+    // S1 = points on the right side of oriented line from A to B
+    // S2 = points on the right side of oriented line from B to A
+    const s1 = [];
+    const s2 = [];
+    for (let i = 0; i < n; i++) {
+        if (i === leftIdx || i === rightIdx)
+            continue;
+        const side = crossProduct(points, leftIdx, rightIdx, i);
+        // positive = left side of A→B = right side of B→A
+        // negative = right side of A→B = left side of B→A
+        if (side > EPSILON) {
+            s2.push(i); // left of A→B is right of B→A
+        }
+        else if (side < -EPSILON) {
+            s1.push(i); // right of A→B
+        }
+    }
+    // build hull: start with leftmost, process upper hull, add rightmost, process lower hull
+    hull.push(leftIdx);
+    findHull(points, s1, leftIdx, rightIdx, hull);
+    hull.push(rightIdx);
+    findHull(points, s2, rightIdx, leftIdx, hull);
+    return hull;
+}
+/**
+ * Finds points on convex hull from set Sk that are on the right side of oriented line from P to Q.
+ * Points are inserted into hull array at the end (before the final endpoint).
+ */
+function findHull(points, sk, p, q, hull) {
+    if (sk.length === 0)
+        return;
+    // find farthest point C from segment PQ
+    let maxIdx = -1;
+    let maxDist = -1;
+    for (const idx of sk) {
+        const dist = Math.abs(crossProduct(points, p, q, idx));
+        if (dist > maxDist) {
+            maxDist = dist;
+            maxIdx = idx;
+        }
+    }
+    if (maxIdx === -1)
+        return;
+    // partition remaining points into S1 and S2
+    // S1 = points on right side of oriented line from P to C
+    // S2 = points on right side of oriented line from C to Q
+    // S0 = points inside triangle PCQ (discarded)
+    const s1 = [];
+    const s2 = [];
+    for (const idx of sk) {
+        if (idx === maxIdx)
+            continue;
+        const sidePC = crossProduct(points, p, maxIdx, idx);
+        const sideCQ = crossProduct(points, maxIdx, q, idx);
+        // point is on right of P→C if cross product is negative
+        if (sidePC < -EPSILON) {
+            s1.push(idx);
+        }
+        // point is on right of C→Q if cross product is negative
+        else if (sideCQ < -EPSILON) {
+            s2.push(idx);
+        }
+        // else: point is inside triangle PCQ, discard it
+    }
+    // recursively process the two subsets
+    findHull(points, s1, p, maxIdx, hull);
+    hull.push(maxIdx); // Add point C to hull between P and Q
+    findHull(points, s2, maxIdx, q, hull);
+}
+/**
+ * Cross product to determine orientation.
+ * Returns (p2 - p1) × (p3 - p1)
+ * > 0: p3 is on the left of line p1→p2 (counter-clockwise)
+ * < 0: p3 is on the right of line p1→p2 (clockwise)
+ * = 0: collinear
+ */
+function crossProduct(points, p1, p2, p3) {
+    const x1 = points[p1 * 2];
+    const y1 = points[p1 * 2 + 1];
+    const x2 = points[p2 * 2];
+    const y2 = points[p2 * 2 + 1];
+    const x3 = points[p3 * 2];
+    const y3 = points[p3 * 2 + 1];
+    return (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1);
+}
+
+export { quickhull2 };
+//# sourceMappingURL=quickhull2.js.map

package/dist/geometry/quickhull2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quickhull2.js","sources":["../../src/geometry/quickhull2.ts"],"sourcesContent":["const EPSILON = 1e-10;\n\n/**\n * Computes the convex hull of a set of 2D points using the QuickHull algorithm.\n * The hull is returned as an array of indices in counter-clockwise order.\n *\n * Implementation of pseudocode from: https://en.wikipedia.org/wiki/Quickhull\n *\n * @param points flat array of 2D points: [x0, y0, x1, y1, ...]\n * @returns indices of hull vertices in ccw order\n */\nexport function quickhull2(points: number[]): number[] {\n    const n = Math.floor(points.length / 2);\n    if (n < 3) return Array.from({ length: n }, (_, i) => i);\n\n    // find left and right most points\n    let leftIdx = 0;\n    let rightIdx = 0;\n    let minX = points[0];\n    let maxX = points[0];\n\n    for (let i = 1; i < n; i++) {\n        const x = points[i * 2];\n        if (x < minX) {\n            minX = x;\n            leftIdx = i;\n        }\n        if (x > maxX) {\n            maxX = x;\n            rightIdx = i;\n        }\n    }\n\n    if (Math.abs(maxX - minX) < EPSILON) return [leftIdx];\n\n    // convex Hull starts with A and B\n    const hull: number[] = [];\n\n    // partition points into S1 and S2\n    // S1 = points on the right side of oriented line from A to B\n    // S2 = points on the right side of oriented line from B to A\n    const s1: number[] = [];\n    const s2: number[] = [];\n\n    for (let i = 0; i < n; i++) {\n        if (i === leftIdx || i === rightIdx) continue;\n\n        const side = crossProduct(points, leftIdx, rightIdx, i);\n\n        // positive = left side of A→B = right side of B→A\n        // negative = right side of A→B = left side of B→A\n        if (side > EPSILON) {\n            s2.push(i); // left of A→B is right of B→A\n        } else if (side < -EPSILON) {\n            s1.push(i); // right of A→B\n        }\n    }\n\n    // build hull: start with leftmost, process upper hull, add rightmost, process lower hull\n    hull.push(leftIdx);\n    findHull(points, s1, leftIdx, rightIdx, hull);\n    hull.push(rightIdx);\n    findHull(points, s2, rightIdx, leftIdx, hull);\n\n    return hull;\n}\n\n/**\n * Finds points on convex hull from set Sk that are on the right side of oriented line from P to Q.\n * Points are inserted into hull array at the end (before the final endpoint).\n */\nfunction findHull(points: number[], sk: number[], p: number, q: number, hull: number[]): void {\n    if (sk.length === 0) return;\n\n    // find farthest point C from segment PQ\n    let maxIdx = -1;\n    let maxDist = -1;\n\n    for (const idx of sk) {\n        const dist = Math.abs(crossProduct(points, p, q, idx));\n        if (dist > maxDist) {\n            maxDist = dist;\n            maxIdx = idx;\n        }\n    }\n\n    if (maxIdx === -1) return;\n\n    // partition remaining points into S1 and S2\n    // S1 = points on right side of oriented line from P to C\n    // S2 = points on right side of oriented line from C to Q\n    // S0 = points inside triangle PCQ (discarded)\n    const s1: number[] = [];\n    const s2: number[] = [];\n\n    for (const idx of sk) {\n        if (idx === maxIdx) continue;\n\n        const sidePC = crossProduct(points, p, maxIdx, idx);\n        const sideCQ = crossProduct(points, maxIdx, q, idx);\n\n        // point is on right of P→C if cross product is negative\n        if (sidePC < -EPSILON) {\n            s1.push(idx);\n        }\n        // point is on right of C→Q if cross product is negative\n        else if (sideCQ < -EPSILON) {\n            s2.push(idx);\n        }\n        // else: point is inside triangle PCQ, discard it\n    }\n\n    // recursively process the two subsets\n    findHull(points, s1, p, maxIdx, hull);\n    hull.push(maxIdx); // Add point C to hull between P and Q\n    findHull(points, s2, maxIdx, q, hull);\n}\n\n/**\n * Cross product to determine orientation.\n * Returns (p2 - p1) × (p3 - p1)\n * > 0: p3 is on the left of line p1→p2 (counter-clockwise)\n * < 0: p3 is on the right of line p1→p2 (clockwise)\n * = 0: collinear\n */\nfunction crossProduct(points: number[], p1: number, p2: number, p3: number): number {\n    const x1 = points[p1 * 2];\n    const y1 = points[p1 * 2 + 1];\n    const x2 = points[p2 * 2];\n    const y2 = points[p2 * 2 + 1];\n    const x3 = points[p3 * 2];\n    const y3 = points[p3 * 2 + 1];\n\n    return (x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1);\n}\n"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG,KAAK;AAErB;;;;;;;;AAQG;AACG,SAAU,UAAU,CAAC,MAAgB,EAAA;AACvC,IAAA,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;IACvC,IAAI,CAAC,GAAG,CAAC;AAAE,QAAA,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;;IAGxD,IAAI,OAAO,GAAG,CAAC;IACf,IAAI,QAAQ,GAAG,CAAC;AAChB,IAAA,IAAI,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC;AACpB,IAAA,IAAI,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC;AAEpB,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;QACxB,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC;AACvB,QAAA,IAAI,CAAC,GAAG,IAAI,EAAE;YACV,IAAI,GAAG,CAAC;YACR,OAAO,GAAG,CAAC;QACf;AACA,QAAA,IAAI,CAAC,GAAG,IAAI,EAAE;YACV,IAAI,GAAG,CAAC;YACR,QAAQ,GAAG,CAAC;QAChB;IACJ;IAEA,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,OAAO;QAAE,OAAO,CAAC,OAAO,CAAC;;IAGrD,MAAM,IAAI,GAAa,EAAE;;;;IAKzB,MAAM,EAAE,GAAa,EAAE;IACvB,MAAM,EAAE,GAAa,EAAE;AAEvB,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;AACxB,QAAA,IAAI,CAAC,KAAK,OAAO,IAAI,CAAC,KAAK,QAAQ;YAAE;AAErC,QAAA,MAAM,IAAI,GAAG,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;;;AAIvD,QAAA,IAAI,IAAI,GAAG,OAAO,EAAE;AAChB,YAAA,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf;AAAO,aAAA,IAAI,IAAI,GAAG,CAAC,OAAO,EAAE;AACxB,YAAA,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACf;IACJ;;AAGA,IAAA,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC;AAC7C,IAAA,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,IAAI,CAAC;AAE7C,IAAA,OAAO,IAAI;AACf;AAEA;;;AAGG;AACH,SAAS,QAAQ,CAAC,MAAgB,EAAE,EAAY,EAAE,CAAS,EAAE,CAAS,EAAE,IAAc,EAAA;AAClF,IAAA,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC;QAAE;;AAGrB,IAAA,IAAI,MAAM,GAAG,EAAE;AACf,IAAA,IAAI,OAAO,GAAG,EAAE;AAEhB,IAAA,KAAK,MAAM,GAAG,IAAI,EAAE,EAAE;AAClB,QAAA,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;AACtD,QAAA,IAAI,IAAI,GAAG,OAAO,EAAE;YAChB,OAAO,GAAG,IAAI;YACd,MAAM,GAAG,GAAG;QAChB;IACJ;IAEA,IAAI,MAAM,KAAK,EAAE;QAAE;;;;;IAMnB,MAAM,EAAE,GAAa,EAAE;IACvB,MAAM,EAAE,GAAa,EAAE;AAEvB,IAAA,KAAK,MAAM,GAAG,IAAI,EAAE,EAAE;QAClB,IAAI,GAAG,KAAK,MAAM;YAAE;AAEpB,QAAA,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC;AACnD,QAAA,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,CAAC;;AAGnD,QAAA,IAAI,MAAM,GAAG,CAAC,OAAO,EAAE;AACnB,YAAA,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;QAChB;;AAEK,aAAA,IAAI,MAAM,GAAG,CAAC,OAAO,EAAE;AACxB,YAAA,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC;QAChB;;IAEJ;;IAGA,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC;AACrC,IAAA,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAClB,QAAQ,CAAC,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,CAAC;AACzC;AAEA;;;;;;AAMG;AACH,SAAS,YAAY,CAAC,MAAgB,EAAE,EAAU,EAAE,EAAU,EAAE,EAAU,EAAA;IACtE,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC;IACzB,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC;IACzB,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC;IACzB,MAAM,EAAE,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;IAE7B,OAAO,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;AACxD;;;;"}