@woosh/meep-engine 2.42.7 → 2.43.0

package/core/geom/2d/convex-hull/orientation3_array.js

@@ -0,0 +1,22 @@
+import { orientation3 } from "./orientation3.js";
+
+/**
+ *
+ * @param {number[]} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @returns {number}
+ */
+export function orientation3_array(points, a, b, c) {
+    const ax = points[a * 2];
+    const ay = points[a * 2 + 1];
+
+    const bx = points[b * 2];
+    const by = points[b * 2 + 1];
+
+    const cx = points[c * 2];
+    const cy = points[c * 2 + 1];
+
+    return orientation3(ax, ay, bx, by, cx, cy);
+}

package/core/geom/2d/convex-hull/orientation3_v2.js

@@ -0,0 +1,12 @@
+import { orientation3 } from "./orientation3.js";
+
+/**
+ *
+ * @param {number[]} a
+ * @param {number[]} b
+ * @param {number[]} c
+ * @returns {number}
+ */
+export function orientation3_v2(a, b, c) {
+    return orientation3(a[0], a[1], b[0], b[1], c[0], c[1]);
+}

package/core/geom/2d/intersect_ray_2d.js

@@ -0,0 +1,56 @@
+import { fabsf } from "../../math/fabsf.js";
+
+/**
+ *
+ * @param {number} ux
+ * @param {number} uy
+ * @param {number} vx
+ * @param {number} vy
+ * @returns {number}
+ */
+function perp(ux, uy, vx, vy) {
+    return (ux * vy - uy * vx);
+}
+
+/**
+ * NOTE: that direction must not be normalized for correct results and instead derived from line length
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number} origin_a_x
+ * @param {number} origin_a_y
+ * @param {number} direction_a_x
+ * @param {number} direction_a_y
+ * @param {number} origin_b_x
+ * @param {number} origin_b_y
+ * @param {number} direction_b_x
+ * @param {number} direction_b_y
+ * @returns {boolean} false if lines are coplanar or intersect on the wrong side
+ */
+export function intersect_ray_2d(
+    out, out_offset,
+    origin_a_x, origin_a_y, direction_a_x, direction_a_y,
+    origin_b_x, origin_b_y, direction_b_x, direction_b_y
+) {
+    const d = perp(direction_a_x, direction_a_y, direction_b_x, direction_b_y);
+    if (fabsf(d) < 0.000000000001) // Parallel lines
+        return false;
+
+    const t = perp(direction_b_x, direction_b_y, origin_a_x - origin_b_x, origin_a_y - origin_b_y) / d;
+
+    if (t < 0.5) // Intersects on the wrong side
+        return false;
+
+    const point_x = origin_a_x + t * direction_a_x;
+    const point_y = origin_a_y + t * direction_a_y;
+
+
+    // if (Number.isNaN(point_x)) {
+    //     debugger;
+    // }
+
+
+    out[out_offset] = point_x;
+    out[out_offset + 1] = point_y;
+
+    return true;
+}

package/core/geom/2d/quad-tree/QuadTreeNode.js

@@ -2,7 +2,6 @@ import { assert } from "../../../assert.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
 import AABB2 from "../../AABB2.js";
-import { aabb2_sqrDistanceToPoint } from "../AABB2Math.js";
 import { QuadTreeDatum } from "./QuadTreeDatum.js";
 
 
@@ -486,25 +485,6 @@ export class QuadTreeNode extends AABB2 {
         }
     }
 
-    /**
-     *
-     * @param {QuadTreeDatum<D>[]} result
-     * @param {number} x
-     * @param {number} y
-     * @param {number} radius
-     * @returns {number} number of intersecting objects added to the result
-     */
-    requestDatumIntersectionsCircle(result, x, y, radius) {
-        //TODO optimize closures out to avoid GC
-        let count = 0;
-
-        this.traverseCircleIntersections(x, y, radius, datum => {
-            return result[count++] = datum;
-        });
-
-        return count;
-    }
-
     /**
      *
      * @param {QuadTreeDatum<D>[]} result
@@ -595,65 +575,4 @@ export class QuadTreeNode extends AABB2 {
         }
     }
 
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} radius
-     * @param {function(QuadTreeDatum)} visitor
-     * @param {*} [thisArg]
-     */
-    traverseCircleIntersections(x, y, radius, visitor, thisArg) {
-        assert.isNumber(x, 'x');
-        assert.isNumber(y, 'y');
-        assert.isNumber(radius, 'radius');
-
-        const radius2 = radius * radius;
-
-        const data = this.data;
-        const dataCount = data.length;
-
-        for (let i = 0; i < dataCount; i++) {
-            const datum = data[i];
-
-            const d2 = aabb2_sqrDistanceToPoint(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
-
-            if (d2 < radius2) {
-                const continueTraversal = visitor.call(thisArg, datum);
-
-                if (continueTraversal === false) {
-                    return;
-                }
-            }
-        }
-
-        if (this.isSplit()) {
-
-            const x0 = this.x0;
-            const x1 = this.x1;
-
-            const y0 = this.y0;
-            const y1 = this.y1;
-
-            const hx = (x0 + x1) / 2;
-            const hy = (y0 + y1) / 2;
-
-            if (aabb2_sqrDistanceToPoint(x0, y0, hx, hy, x, y) < radius2) {
-                this.topLeft.traverseCircleIntersections(x, y, radius, visitor, thisArg);
-            }
-
-            if (aabb2_sqrDistanceToPoint(x0, hy, hx, y1, x, y) < radius2) {
-                this.bottomLeft.traverseCircleIntersections(x, y, radius, visitor, thisArg);
-            }
-
-            if (aabb2_sqrDistanceToPoint(hx, y0, x1, hy, x, y) < radius2) {
-                this.topRight.traverseCircleIntersections(x, y, radius, visitor, thisArg);
-            }
-
-            if (aabb2_sqrDistanceToPoint(hx, hy, x1, y1, x, y) < radius2) {
-                this.bottomRight.traverseCircleIntersections(x, y, radius, visitor, thisArg);
-            }
-
-        }
-    }
 }

package/core/geom/2d/quad-tree/qt_match_data_by_circle.js

@@ -0,0 +1,70 @@
+import { aabb2_sqrDistanceToPoint } from "../AABB2Math.js";
+
+/**
+ *
+ * @type {QuadTreeNode[]}
+ */
+const node_stack = [];
+
+/**
+ * @template T
+ * @param {QuadTreeDatum<T>[]} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @param {function(data:T):boolean} [predicate]
+ * @param {*} [predicateContext]
+ * @returns {number}
+ */
+export function qt_match_data_by_circle(
+    result, result_offset,
+    tree,
+    x, y, radius,
+    predicate, predicateContext
+) {
+    let result_cursor = result_offset;
+
+    let stack_pointer = 0;
+
+    const r2 = radius * radius;
+
+    node_stack[stack_pointer] = tree;
+    stack_pointer++;
+
+    while (stack_pointer > 0) {
+
+        --stack_pointer;
+        const node = node_stack[stack_pointer];
+
+        const d2 = aabb2_sqrDistanceToPoint(node.x0, node.y0, node.x1, node.y1, x, y);
+
+        if (d2 > r2) {
+            // not a match
+            continue;
+        }
+
+        const data = node.data;
+        const data_count = data.length;
+
+        for (let i = 0; i < data_count; i++) {
+            const datum = data[i];
+
+            const d2_to_datum = aabb2_sqrDistanceToPoint(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
+
+            if (d2_to_datum <= r2 && predicate.call(predicateContext, datum.data)) {
+                result[result_cursor++] = datum;
+            }
+        }
+
+        if (node.isSplit()) {
+            node_stack[stack_pointer++] = node.topLeft;
+            node_stack[stack_pointer++] = node.bottomLeft;
+            node_stack[stack_pointer++] = node.topRight;
+            node_stack[stack_pointer++] = node.bottomRight;
+        }
+    }
+
+    return result_cursor - result_offset;
+}

package/core/geom/3d/matrix/m4_multiply_alphatensor.js

@@ -0,0 +1,131 @@
+/**
+ * Performs 4x4 matrix multiplication using algorithm discovered by AlphaTensor
+ * @see AlphaTensor2022 by Fawzi etAl
+ * @param {number[]} out
+ * @param {number[]} a
+ * @param {number[]} b
+ */
+export function m4_multiply_alphatensor(out, a, b) {
+    // read out matricies
+    const a11 = a[0];
+    const a12 = a[1];
+    const a13 = a[2];
+    const a14 = a[3];
+    const a21 = a[4];
+    const a22 = a[5];
+    const a23 = a[6];
+    const a24 = a[7];
+    const a31 = a[8];
+    const a32 = a[9];
+    const a33 = a[10];
+    const a34 = a[11];
+    const a41 = a[12];
+    const a42 = a[13];
+    const a43 = a[14];
+    const a44 = a[15];
+
+    const b11 = b[0];
+    const b12 = b[1];
+    const b13 = b[2];
+    const b14 = b[3];
+    const b21 = b[4];
+    const b22 = b[5];
+    const b23 = b[6];
+    const b24 = b[7];
+    const b31 = b[8];
+    const b32 = b[9];
+    const b33 = b[10];
+    const b34 = b[11];
+    const b41 = b[12];
+    const b42 = b[13];
+    const b43 = b[14];
+    const b44 = b[15];
+
+    // apply multiplication algorithm
+    const h1 = (a11 + a31) * (b11 + b31)
+    const h2 = (a11 - a13 + a31) * (b11 - b13 + b31)
+    const h3 = -a13 * (b11 - b13 + b31 - b33)
+    const h4 = -a33 * -b33
+    const h5 = -a31 * -b13
+    const h6 = (a11 - a13 + a31 - a33) * -b31
+    const h7 = (-a21 + a22 - a23 - a24) * (-b21 + b22 - b23 - b24)
+    const h8 = (-a21 + a22 - a23 - a24 - a41 + a42) * (-b21 + b22 - b23 - b24 - b41 + b42)
+    const h9 = (a11 - a13) * (b11 - b13)
+    const h10 = (-a21 + a22 - a41 + a42) * (-b21 + b22 - b41 + b42)
+    const h11 = (a41 - a42) * (-b23 - b24)
+    const h12 = (-a21 + a22 - a23 - a24 - a41 + a42 - a43 - a44) * (b41 - b42)
+    const h13 = (-a23 - a24) * (-b21 + b22 - b23 - b24 - b41 + b42 - b43 - b44)
+    const h14 = (a11 - a12 + a21 - a22) * (-b12 - b14)
+    const h15 = (-a12 - a14) * -b21
+    const h16 = (a12 + a14 - a21 + a22 + a23 + a24) * (b12 + b14 - b21 + b22 + b23 + b24)
+    const h17 = (a12 + a14 - a21 + a22 + a23 + a24 + a32 + a41 - a42) * (b12 + b14 - b21 + b22 + b23 + b24 + b32 + b41 - b42)
+    const h18 = (a12 - a21 + a22 + a32 + a41 - a42) * (b12 - b21 + b22 + b32 + b41 - b42)
+    const h19 = (a14 + a23 + a24) * (b12 + b14 - b21 + b22 + b23 + b24 + b32 + b34 + b41 - b42 - b43 - b44)
+    const h20 = (a12 + a14 - a21 + a22 + a23 + a24 + a32 + a34 + a41 - a42 - a43 - a44) * (b32 + b41 - b42)
+    const h21 = (a32 + a41 - a42) * (b14 + b23 + b24)
+    const h22 = (a12 + a14 + a22 + a24) * (b12 + b14 + b22 + b24)
+    const h23 = (a12 + a14 + a22 + a24 + a32 - a42) * (b12 + b14 + b22 + b24 + b32 - b42)
+    const h24 = (a14 + a24) * (b12 + b14 + b22 + b24 + b32 + b34 - b42 - b44)
+    const h25 = (a12 + a14 + a22 + a24 + a32 + a34 - a42 - a44) * (b32 - b42)
+    const h26 = (a32 - a42) * (b14 + b24)
+    const h27 = (a34 - a44) * (b34 - b44)
+    const h28 = (a34 - a43 - a44) * (b34 - b43 - b44)
+    const h29 = (a14 + a34) * -b43
+    const h30 = (a13 + a14 + a23 + a24 + a33 + a34 - a43 - a44) * (b14 + b34)
+    const h31 = (a11 - a12 - a13 - a14 + a21 - a22 - a23 - a24 + a31 - a32 - a33 - a34 - a41 + a42 + a43 + a44) * b14
+    const h32 = -a43 * (b13 + b14 + b23 + b24 + b33 + b34 - b43 - b44)
+    const h33 = a14 * (-b21 + b41)
+    const h34 = (a14 - a32) * (-b21 + b41 - b43)
+    const h35 = (a13 + a14 + a23 + a24 - a31 + a32 + a33 + a34 + a41 - a42 - a43 - a44) * (b14 - b32)
+    const h36 = (-a31 + a32 + a33 + a34 + a41 - a42 - a43 - a44) * b32
+    const h37 = (-a12 - a32) * -b23
+    const h38 = (a32 + a34) * (b41 - b43)
+    const h39 = (-a13 - a14 - a23 - a24) * (b32 + b34)
+    const h40 = a32 * (-b21 + b23 + b41 - b43)
+    const h41 = -a21 * (b11 - b12 + b21 - b22)
+    const h42 = (-a21 + a41) * (b11 - b12 - b13 - b14 + b21 - b22 - b23 - b24 + b31 - b32 - b33 - b34 - b41 + b42 + b43 + b44)
+    const h43 = (-a21 + a41 - a43) * (b13 + b14 + b23 + b24 - b31 + b32 + b33 + b34 + b41 - b42 - b43 - b44)
+    const h44 = (a12 + a22 + a32 - a42) * (b12 + b22 + b32 - b42)
+    const h45 = (-a21 + a23 + a41 - a43) * (-b31 + b32 + b33 + b34 + b41 - b42 - b43 - b44)
+    const h46 = (-a31 + a32 + a41 - a42) * (-b12 - b32)
+    const h47 = (a41 - a43) * (-b13 - b14 - b23 - b24)
+    const h48 = (-a43 - a44) * (-b43 - b44)
+    const h49 = -a23 * (-b31 + b32 + b41 - b42)
+    const c11 = h1 - h2 - h5 + h9 + h15 + h33
+    const c12 = -h15 - h16 + h17 - h18 - h21 + h22 - h23 + h26 - h33 - h41 + h44 + h49
+    const c13 = h2 + h5 + h6 - h9 - h29 - h33 + h34 + h38
+    const c14 = -h16 + h17 - h20 - h21 + h22 - h23 + h25 + h26 - h29 - h32 - h33 + h34 + h38 - h41 + h42 + h43
+    const c21 = -h7 + h8 - h10 + h11 - h14 + h15 + h16 - h17 + h18 + h21 - h31 + h33 - h35 - h36
+    const c22 = h7 - h8 + h10 - h11 - h15 - h16 + h17 - h18 - h21 + h22 - h23 + h26 - h33 + h44
+    const c23 = -h7 + h8 + h11 + h12 - h16 + h17 - h20 - h21 - h29 - h33 + h34 + h36 + h38 + h46
+    const c24 = -h7 + h8 + h11 + h12 - h16 + h17 - h20 - h21 + h22 - h23 + h25 + h26 - h29 - h33 + h34 + h38
+    const c31 = h1 - h2 + h3 - h5 + h33 - h34 + h37 - h40
+    const c32 = h17 - h18 - h19 - h21 - h23 + h24 + h26 - h33 + h34 - h37 + h40 - h43 + h44 + h45 - h47 + h49
+    const c33 = h4 + h5 - h29 - h33 + h34 + h40
+    const c34 = -h21 + h26 - h27 + h28 - h29 - h32 - h33 + h34 + h40 - h47
+    const c41 = h8 - h10 + h11 - h13 + h17 - h18 - h19 - h21 + h31 - h33 + h34 + h35 + h36 - h37 - h39 + h40
+    const c42 = -h8 + h10 - h11 + h13 - h17 + h18 + h19 + h21 + h23 - h24 - h26 + h33 - h34 + h37 - h40 - h44
+    const c43 = h11 + h21 - h28 + h29 + h30 + h33 - h34 - h35 - h36 + h39 - h40 + h48
+    const c44 = h11 + h21 - h26 + h27 - h28 + h29 + h33 - h34 - h40 + h48
+
+    // write out results
+    out[0] = c11;
+    out[1] = c12;
+    out[2] = c13;
+    out[3] = c14;
+
+    out[4] = c21;
+    out[5] = c22;
+    out[6] = c23;
+    out[7] = c24;
+
+    out[8] = c31;
+    out[9] = c32;
+    out[10] = c33;
+    out[11] = c34;
+
+    out[12] = c41;
+    out[13] = c42;
+    out[14] = c43;
+    out[15] = c44;
+}

package/core/geom/3d/plane/orient3d_fast.js

@@ -20,17 +20,13 @@
 export function orient3d_fast(points, a, b, c, d) {
     const a3 = a * 3;
     const d3 = d * 3;
+    const b3 = b * 3;
+    const c3 = c * 3;
 
     const d_x = points[d3];
 
     const adx = points[a3] - d_x;
-
-    const b3 = b * 3;
-
     const bdx = points[b3] - d_x;
-
-    const c3 = c * 3;
-
     const cdx = points[c3] - d_x;
 
     const d_y = points[d3 + 1];

package/core/geom/3d/tetrahedra/README.md

@@ -0,0 +1,7 @@
+collection of tools for working with tetrahedra (3d simplex)
+
+The main feature is tetrahedrasation (triangulation in 3d space) 
+
+References
+---
+[Wikipedia - Delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation)

package/core/geom/3d/tetrahedra/compute_bounding_simplex_3d.js

@@ -19,6 +19,8 @@ const SIMPLEX_PROJECTION_AXES = new Float32Array([
 
 /**
  * Compute bounding tetrahedron (3d simplex) for a given set of input points
+ * The algorithm is pretty basic, it projects each point onto 4 planes and pushes planes away from origin to the furthest projected point
+ * then, we take intersection points between those planes to get our bounding tetrahedron
  *
  * @see https://github.com/bryanmcnett/aabo/blob/master/aabo.cpp
  * @author Alexander Goldring (c) 2021
@@ -149,7 +151,7 @@ export function compute_bounding_simplex_3d(
     min_c -= padding;
     min_d -= padding;
 
-    // lets compute intersection points for each tri-plane combination to find simplex corners
+    // let's compute intersection points for each tri-plane combination to find simplex corners
     plane_computeConvex3PlaneIntersection(
         result, result_offset,
         SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,

package/core/geom/3d/tetrahedra/delaunay/Cavity.js

@@ -0,0 +1,48 @@
+export class Cavity {
+    constructor() {
+        /**
+         *
+         * @type {number[]}
+         */
+        this.indices = [];
+
+        /**
+         *
+         * @type {number}
+         */
+        this.size = 0;
+    }
+
+    update() {
+        // compute in/out state for each side of each tetra
+    }
+
+    /**
+     *
+     * @param {number} i
+     */
+    push(i) {
+        this.indices[this.size++] = i;
+    }
+
+    /**
+     *
+     * @param {number} i
+     * @returns {boolean}
+     */
+    includes(i) {
+        const n = this.size;
+
+        for (let j = 0; j < n; j++) {
+            if (this.indices[j] === i) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    reset() {
+        this.size = 0;
+    }
+}

package/core/geom/3d/tetrahedra/{compute_delaunay_tetrahedral_mesh.js → delaunay/compute_delaunay_tetrahedral_mesh.js}

@@ -1,19 +1,16 @@
 //
 
-import { compute_bounding_simplex_3d } from "./compute_bounding_simplex_3d.js";
-import { TetrahedraCollection } from "./tetrahedra_collection.js";
+import { compute_bounding_simplex_3d } from "../compute_bounding_simplex_3d.js";
+import { TetrahedralMesh } from "../tetrahedra_collection.js";
 
 /**
  * @see https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm
  * @see [1] "One machine, one minute, three billion tetrahedra" by Célestin Marot et al
  * @param {number[]} input serialized set of 3d points (x,y,z)
  * @param {number} n number of points in the input
+ * @returns {TetrahedralMesh}
  */
 export function compute_delaunay_tetrahedral_mesh(input, n) {
-    if (n < 4) {
-        // no mesh can be created, too few points
-        return;
-    }
 
     /**
      * According to [1] number of tetrahedra is around 6 times greater than number of input vertices, we use that fact to pre-allocate memory
@@ -24,7 +21,14 @@ export function compute_delaunay_tetrahedral_mesh(input, n) {
      * The +7 is for the initial "super" tetrahedron and 6 tetras for intermediate triangulation
      */
     const tetrahedron_count_upper_bound = Math.ceil((n * n - 3 * n - 2) / 2) + 7;
-    const tetrahedrons = new TetrahedraCollection(tetrahedron_count_upper_bound);
+
+    const tetrahedrons = new TetrahedralMesh(tetrahedron_count_upper_bound);
+
+    if (n < 4) {
+        // no mesh can be created, too few points
+        return tetrahedrons;
+    }
+
     // TODO apply spatial sort to point, to get better cache locality
 
     // compute bounds over the input
@@ -46,5 +50,9 @@ export function compute_delaunay_tetrahedral_mesh(input, n) {
 
     // remove tetras formed by with the super bounding volume
     tetrahedrons.removeTetrasConnectedToPoints(points, n, n + 3);
+
+
+    return tetrahedrons;
 }
 
+

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_compute_cavity.js

@@ -0,0 +1,73 @@
+import { assert } from "../../../../assert.js";
+import { point_in_tetrahedron_circumsphere } from "../point_in_tetrahedron_circumsphere.js";
+import { INVALID_NEIGHBOUR } from "../tetrahedra_collection.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {Cavity} cavity
+ * @param {number[]|Float32Array} points
+ * @param {number} containing_tetra tetrahedron that contains point
+ * @param {number} point_index point that forms the cavity
+ */
+export function tetrahedral_mesh_compute_cavity(mesh, cavity, points, containing_tetra, point_index) {
+    assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
+
+    cavity.reset();
+
+    /**
+     *
+     * @type {number[]}
+     */
+    const open_set = [
+        containing_tetra
+    ];
+
+    /**
+     *
+     * @type {number[]}
+     */
+    const closed_set = [];
+
+    // 2. find the Delaunay "cavity", a set of tetrahedrons who's circumsphere overlarlaps the point
+    // perform breadth-first expansion on the containing tetra to identify the cavity
+    while (open_set.length > 0) {
+
+        const tetra = open_set.pop();
+        cavity.push(tetra);
+        closed_set.push(tetra);
+
+        // get neighbours
+        for (let i = 0; i < 4; i++) {
+
+            const neighbour_encoded = mesh.getNeighbour(tetra, i);
+            const neighbour_tetra_index = neighbour_encoded >>> 2;
+
+            if (
+                (neighbour_encoded === INVALID_NEIGHBOUR) // no neighbour
+                || closed_set.includes(neighbour_tetra_index)   // already visited
+                || open_set.includes(neighbour_tetra_index) // already in open set
+            ) {
+
+                continue;
+            }
+
+            const a = mesh.getCornerIndex(neighbour_tetra_index, 0);
+            const b = mesh.getCornerIndex(neighbour_tetra_index, 1);
+            const c = mesh.getCornerIndex(neighbour_tetra_index, 2);
+            const d = mesh.getCornerIndex(neighbour_tetra_index, 3);
+
+            // check neighbour
+            const is_in_sphere = point_in_tetrahedron_circumsphere(points, a, b, c, d, containing_tetra);
+
+            if (is_in_sphere) {
+                open_set.push(neighbour_tetra_index);
+            } else {
+                // move directly to closed set
+                closed_set.push(neighbour_tetra_index);
+            }
+
+
+        }
+    }
+}

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_walk_toward_cavity.js

@@ -0,0 +1,48 @@
+import { orient3d_fast } from "../../plane/orient3d_fast.js";
+
+/**
+ * Walk from a given tetrahedron in the mesh towards tetrahedron that contains input point
+ * This is an essential method for incrementally finding the next tetrahedron for cavity computation
+ *
+ * @see https://git.immc.ucl.ac.be/hextreme/hxt_seqdel/-/blob/master/src/hxt_tetrahedra.c#L330
+ * @see p3 "One machine, one minute, three billion tetrahedra" by Célestin Marot, Jeanne Pellerin, Jean-François Remacle
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]} points
+ * @param {number} current_tet
+ * @param {number} current_vertex
+ * @returns {number}
+ */
+function tetrahedral_mesh_walk_toward_cavity(mesh, points, current_tet, current_vertex) {
+
+    let entering_face = 4;
+
+    let curTet = current_tet;
+
+    while (true) {
+
+        let i;
+        for (i = 0; i < 4; i++) {
+
+            // we walk whenever the volume is positive
+            const a_i = (i + 1) & 3;
+            const b_i = (i & 2) ^ 3;
+            const c_i = (i + 3) & 2;
+
+            const a_index = mesh.getCornerIndex(curTet, a_i);
+            const b_index = mesh.getCornerIndex(curTet, b_i);
+            const c_index = mesh.getCornerIndex(curTet, c_i);
+
+            if (i !== entering_face && orient3d_fast(points, a_index, b_index, c_index, current_vertex) < 0.0) {
+                const neighbour = mesh.getNeighbour(curTet, i);
+                curTet = neighbour >> 2;
+                entering_face = neighbour & 3;
+                break;
+            }
+        }
+
+        if (i === 4) {
+            return curTet;
+        }
+    }
+
+}