@woosh/meep-engine 2.43.1 → 2.43.4

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

@@ -0,0 +1,191 @@
+import { assert } from "../../../../assert.js";
+import { array_copy } from "../../../../collection/array/copyArray.js";
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
+import { validate_neighbour } from "../validate_tetrahedral_mesh.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|number[]|Float32Array} points
+ * @param {BitSet} visited_flags
+ * @param {Cavity} cavity
+ * @param {number} cur_tet
+ * @returns {number} new current tet
+ */
+export function fill_in_a_cavity(mesh, points, visited_flags, cavity, cur_tet) {
+
+    let clength = cavity.__deleted_size; // cavity size
+    const blength = cavity.__boundary_size; // boundary size
+
+    assert.equal(blength & 1, 0, 'there is always a pair number of triangle on the boundary. N points, 2N triangle, 3N edges');
+
+    /*
+    Re-use tets that would be deleted, if there are not enough dead tets - allocate new ones as necessary
+     */
+    const deleted_tets = cavity.__deleted;
+    if (blength > clength) {
+
+        for (let i = clength; i < blength; i++) {
+            // allocate tets for the cavity filling, remember them inside the "deleted" set for now
+            deleted_tets[i] = mesh.allocate();
+        }
+
+        clength = blength;
+    }
+
+    const boundary = cavity.__boundary;
+    const start = clength - blength;
+
+    for (let i = 0; i < blength; i++) {
+        // go over the faces in the cavity boundary and matching tet that will be filling the space
+
+        const current_tet_index = deleted_tets[i + start];
+
+        const i5 = i * 5;
+
+        // write filling tet's corners
+        mesh.setVertexIndex(current_tet_index, 0, boundary[i5]); // "ball"/cavity center point is written here
+        mesh.setVertexIndex(current_tet_index, 1, boundary[i5 + 1]);
+        mesh.setVertexIndex(current_tet_index, 2, boundary[i5 + 2]);
+        mesh.setVertexIndex(current_tet_index, 3, boundary[i5 + 3]);
+
+        const encoded_boundary_tet = boundary[i5 + 4];
+
+        mesh.setNeighbour(current_tet_index, 0, encoded_boundary_tet); // connect opposing neighbour
+
+        const encoded_current_tet = current_tet_index << 2;
+
+        if (encoded_boundary_tet !== INVALID_NEIGHBOUR) {
+            // update neighbour
+            mesh.setNeighbour(encoded_boundary_tet >> 2, encoded_boundary_tet & 3, encoded_current_tet);
+        }
+
+        // boundary[i5 + 4] = encoded_current_tet;
+
+        visited_flags.set(current_tet_index, false); // clear flag
+    }
+
+    computeAdjacencies(mesh, cavity, start, blength);
+
+
+    for (let i = 0; i < start; i++) {
+        // cleanup any orphaned tets that we didn't re-use
+        mesh.delete(deleted_tets[i]);
+    }
+
+    // debug_validate_mesh(mesh, points);
+
+    cavity.__boundary_size = 0;
+    cavity.__deleted_size = 0;
+
+    /*
+    Pick a tet from the created ball, it will generally be a good guess for next point
+     */
+    return deleted_tets[start];
+
+}
+
+/**
+ * All tets within the ball must be connected to one another, we test that here
+ */
+function validate_patched_ball_adjacencies(mesh, ball_tets, ball_tets_offset, ball_tets_count, consumer) {
+    let valid = true;
+
+    let ball_index, tet;
+
+    for (let i = 0; i < ball_tets_count; i++) {
+        ball_index = ball_tets_offset + i;
+        tet = ball_tets[ball_index];
+
+        // except for 0th neighbour, all others must be valid as they represent connection within the ball itself
+        for (let j = 1; j < 4; j++) {
+
+            if (!validate_neighbour(mesh, tet, j, consumer)) {
+                valid = false;
+            }
+        }
+    }
+
+    return valid;
+}
+
+/**
+ * filling back the cavity
+ * N+2 point on the surface of the cavity
+ * 2N triangle on the surface of the cavity, x3 (4*0.5+1) data = 6N+9 uint64_t
+ * => enough place for the 3N edge x2 data = 6N uint64_t
+ * @param {TetrahedralMesh} mesh
+ * @param {Cavity} cavity
+ * @param {number} start
+ * @param {number} blength
+ */
+function computeAdjacencies(mesh, cavity, start, blength) {
+    const boundary = cavity.__boundary;
+
+    let tlength = 0;
+
+    const Tmp = boundary; // we know there is enough space...
+
+    for (let i = 0; i < blength; i++) {
+
+        const cur_tet = cavity.__deleted[start + i];
+
+        // pointer to the position of Node[0] in the Tmp array
+
+        for (let j = 0; j < 3; j++) {
+
+            // define the edge by the minimum vertex and the other
+            const index_0 = (j + 1) % 3 + 1;
+            const index_1 = (j + 2) % 3 + 1;
+
+            const n0 = mesh.getVertexIndex(cur_tet, index_0);
+            const n1 = mesh.getVertexIndex(cur_tet, index_1);
+
+            const current_tet_neighbour_id = j + 1;
+            const encoded_current_tet = (cur_tet << 2) | (current_tet_neighbour_id & 3);
+
+            // linear searching/pushing into Tmp
+            let k = 0;
+            for (; k < tlength; k++) {
+                // this is the only nested loop... the one that cost it all
+
+                if (Tmp[k * 3] === n0 && Tmp[k * 3 + 1] === n1)
+                    // found a match, stop here
+                    break;
+            }
+
+            if (k === tlength) {
+                // we did not find it
+                const offset = tlength * 3;
+
+                // flip the edge order and store it. Neighbouring tet will have edge order reversed
+                Tmp[offset] = n1;
+                Tmp[offset + 1] = n0;
+
+                Tmp[offset + 2] = encoded_current_tet;
+
+                tlength++;
+            } else {
+                // we found the neighbour !
+                const encoded_neighbour = Tmp[k * 3 + 2];
+
+                mesh.setNeighbour(cur_tet, current_tet_neighbour_id, encoded_neighbour);
+                mesh.setNeighbour(encoded_neighbour >> 2, encoded_neighbour & 3, encoded_current_tet);
+
+                // reduce search space, there can only be one neighbour pair, after it's found we can remove the entry from lookup table
+                tlength--;
+
+                if (k < tlength) {
+                    // put the last entry in the one we just discovered
+                    array_copy(Tmp, tlength * 3, Tmp, k * 3, 3);
+                }
+            }
+        }
+    }
+
+    assert.equal(tlength, 0, 'Failed to compute adjacencies');
+
+    // if (!validate_patched_ball_adjacencies(mesh, cavity.__deleted, start, blength, console.error)) {
+    //     debugger;
+    // }
+}

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

@@ -0,0 +1,27 @@
+import { tetrahedron_compute_signed_volume } from "../tetrahedron_compute_signed_volume.js";
+
+/**
+ * Debug method that validates cavity tet before pushing it
+ * @param {Cavity} cavity
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} neighbour
+ * @param {number[]} points
+ * @param {function(problem:string):*} consumer
+ */
+export function push_boundary_with_validation(points, cavity, a, b, c, d, neighbour, consumer = console.warn) {
+    let valid = true;
+    const vol = tetrahedron_compute_signed_volume(points, a, b, c, d);
+
+    if (vol < 0) {
+        consumer(`Pushing a negative volume(=${vol}) boundary tet ${[a, b, c, d].join(', ')}`);
+
+        valid = false;
+    }
+
+    cavity.push_boundary(a, b, c, d, neighbour);
+
+    return valid;
+}

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

@@ -1,73 +1,89 @@
 import { assert } from "../../../../assert.js";
-import { point_in_tetrahedron_circumsphere } from "../point_in_tetrahedron_circumsphere.js";
-import { INVALID_NEIGHBOUR } from "../tetrahedra_collection.js";
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
+import { in_sphere_robust } from "../in_sphere_robust.js";
 
 /**
  *
  * @param {TetrahedralMesh} mesh
  * @param {Cavity} cavity
  * @param {number[]|Float32Array} points
+ * @param {BitSet} visited_flags
  * @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) {
+export function tetrahedral_mesh_compute_cavity(
+    mesh,
+    points,
+    visited_flags,
+    cavity,
+    containing_tetra,
+    point_index
+) {
     assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
 
-    cavity.reset();
+    // add the tet to cavity
+    cavity.push_deleted(containing_tetra);
+    visited_flags.set(containing_tetra, true);
 
-    /**
-     *
-     * @type {number[]}
-     */
-    const open_set = [
-        containing_tetra
-    ];
+    for (let start = cavity.__deleted_size - 1; start < cavity.__deleted_size; start++) {
+        const cur_tet = cavity.__deleted[start];
 
-    /**
-     *
-     * @type {number[]}
-     */
-    const closed_set = [];
+        for (let i = 0; i < 4; i++) {
+            const encoded_neighbour = mesh.getNeighbour(cur_tet, i);
 
-    // 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 k0 = (1 << i) & 3;
+            const k1 = (i + 2) % 3;
+            const k2 = (~((i + 1) >> 1) & 2) + 1;
 
-        const tetra = open_set.pop();
-        cavity.push(tetra);
-        closed_set.push(tetra);
+            if (encoded_neighbour === INVALID_NEIGHBOUR) {
+                // no neighbour, include this side into boundary
 
-        // get neighbours
-        for (let i = 0; i < 4; i++) {
+                cavity.push_boundary(
+                    point_index,
+                    mesh.getVertexIndex(cur_tet, k0),
+                    mesh.getVertexIndex(cur_tet, k1),
+                    mesh.getVertexIndex(cur_tet, k2),
+                    encoded_neighbour,
+                );
 
-            const neighbour_encoded = mesh.getNeighbour(tetra, i);
-            const neighbour_tetra_index = neighbour_encoded >>> 2;
+                continue;
+            }
 
-            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
-            ) {
+            const neighbour_index = encoded_neighbour >> 2;
 
+            if (visited_flags.get(neighbour_index)) {
+                // already visited
                 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);
+            if (in_sphere_robust(
+                points,
+                mesh.getVertexIndex(neighbour_index, 0),
+                mesh.getVertexIndex(neighbour_index, 1),
+                mesh.getVertexIndex(neighbour_index, 2),
+                mesh.getVertexIndex(neighbour_index, 3),
+                point_index
+            ) < 0) {
+                // outside the cavity, meaning it defines boundary
 
-            // check neighbour
-            const is_in_sphere = point_in_tetrahedron_circumsphere(points, a, b, c, d, containing_tetra);
+                cavity.push_boundary(
+                    point_index,
+                    mesh.getVertexIndex(cur_tet, k0),
+                    mesh.getVertexIndex(cur_tet, k1),
+                    mesh.getVertexIndex(cur_tet, k2),
+                    encoded_neighbour,
+                );
 
-            if (is_in_sphere) {
-                open_set.push(neighbour_tetra_index);
             } else {
-                // move directly to closed set
-                closed_set.push(neighbour_tetra_index);
-            }
-
+                // assert.greaterThanOrEqual(visited_flags.length, neighbour_index * 4 + 3, 'subdet array is too small');
 
+                //part of the cavity, remove
+                cavity.push_deleted(neighbour_index);
+                visited_flags.set(neighbour_index, true);
+            }
         }
+
     }
+
+    // debug_validate_cavity_boundary(mesh, cavity);
 }

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

@@ -0,0 +1,77 @@
+/**
+ * Compute sub-determinants for a given tetrahedron
+ * NOTE: this implementation doesn't use GHOST vertices, all tets/vertices are assumed to be real and valid
+ * @see https://git.immc.ucl.ac.be/hextreme/hxt_seqdel/-/blob/master/src/hxt_tetrahedra.c#L754
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]|Float32Array} points
+ * @param {number} tetrahedron_index
+ */
+export function tetrahedral_mesh_compute_sub_determinant(result, result_offset, mesh, points, tetrahedron_index) {
+    /*
+     NOTE: the code is re-ordered slightly and inlined for speed, re-ordering is mostly to reduce register pressure
+     */
+    const a_index = mesh.getVertexIndex(tetrahedron_index, 0);
+    const b_index = mesh.getVertexIndex(tetrahedron_index, 1);
+    const c_index = mesh.getVertexIndex(tetrahedron_index, 2);
+    const d_index = mesh.getVertexIndex(tetrahedron_index, 3);
+
+    // read out coordinates
+    const a3 = a_index * 3;
+    const b3 = b_index * 3;
+    const c3 = c_index * 3;
+    const d3 = d_index * 3;
+
+    const a_x = points[a3];
+    const a_y = points[a3 + 1];
+    const a_z = points[a3 + 2];
+
+    const b_x = points[b3];
+    const b_y = points[b3 + 1];
+    const b_z = points[b3 + 2];
+
+    // construct AB, AC, AD
+    const ab_x = b_x - a_x;
+    const ab_y = b_y - a_y;
+    const ab_z = b_z - a_z;
+
+    const c_x = points[c3];
+    const c_y = points[c3 + 1];
+    const c_z = points[c3 + 2];
+
+    const ac_x = c_x - a_x;
+    const ac_y = c_y - a_y;
+    const ac_z = c_z - a_z;
+
+    const d_x = points[d3];
+    const d_y = points[d3 + 1];
+    const d_z = points[d3 + 2];
+
+    const ad_x = d_x - a_x;
+    const ad_y = d_y - a_y;
+    const ad_z = d_z - a_z;
+
+    const ab_w = ab_x * ab_x + ab_y * ab_y + ab_z * ab_z;
+    const ac_w = ac_x * ac_x + ac_y * ac_y + ac_z * ac_z;
+    const ad_w = ad_x * ad_x + ad_y * ad_y + ad_z * ad_z;
+
+    const cd12 = ac_z * ad_y - ac_y * ad_z;
+    const db12 = ad_z * ab_y - ad_y * ab_z;
+    const bc12 = ab_z * ac_y - ab_y * ac_z;
+
+    const cd30 = ac_x * ad_w - ac_w * ad_x;
+    const db30 = ad_x * ab_w - ad_w * ab_x;
+    const bc30 = ab_x * ac_w - ab_w * ac_x;
+
+    // each subdet is a simple triple product
+    const subdet_0 = ab_w * cd12 + ac_w * db12 + ad_w * bc12;
+    const subdet_1 = ab_z * cd30 + ac_z * db30 + ad_z * bc30;
+    const subdet_2 = ab_y * cd30 + ac_y * db30 + ad_y * bc30;
+    const subdet_3 = ab_x * cd12 + ac_x * db12 + ad_x * bc12;
+
+    result[result_offset] = subdet_0;
+    result[result_offset + 1] = subdet_1;
+    result[result_offset + 2] = subdet_2;
+    result[result_offset + 3] = subdet_3;
+}

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_compute_sub_determinant.spec.js

@@ -0,0 +1,30 @@
+import { TetrahedralMesh } from "../TetrahedralMesh.js";
+import { tetrahedral_mesh_compute_sub_determinant } from "./tetrahedral_mesh_compute_sub_determinant.js";
+
+test("sanity test", () => {
+    const mesh = new TetrahedralMesh(1);
+
+    const tet = mesh.allocate();
+
+    mesh.setVertexIndex(tet, 0, 0);
+    mesh.setVertexIndex(tet, 1, 1);
+    mesh.setVertexIndex(tet, 2, 2);
+    mesh.setVertexIndex(tet, 3, 3);
+
+    const result = [];
+
+    const points = [
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9,
+        10, 11, 12
+    ];
+
+    tetrahedral_mesh_compute_sub_determinant(result, 0, mesh, points, tet);
+
+    for (let i = 0; i < 4; i++) {
+        expect(typeof result[i]).toBe("number");
+        expect(result[i]).not.toBeNaN();
+    }
+
+});

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

@@ -0,0 +1,58 @@
+import { assert } from "../../../../assert.js";
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
+import { orient3d_robust } from "../../plane/orient3d_robust.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[]|Float32Array} points
+ * @param {number} hint_tetrahedron we will start here and walk towards our target
+ * @param {number} search_vertex_index
+ * @returns {number}
+ */
+export function tetrahedral_mesh_walk_towards_containing_tetrahedron(mesh, points, hint_tetrahedron, search_vertex_index) {
+
+    let entering_face = 4;
+
+    let cur_tet = hint_tetrahedron;
+
+    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.getVertexIndex(cur_tet, a_i);
+            const b_index = mesh.getVertexIndex(cur_tet, b_i);
+            const c_index = mesh.getVertexIndex(cur_tet, c_i);
+
+            if (i !== entering_face && orient3d_robust(points, a_index, b_index, c_index, search_vertex_index) < 0.0) {
+
+                // point is outside the tet on the neighbour's side, move in that direction
+                const neighbour = mesh.getNeighbour(cur_tet, i);
+
+                assert.notEqual(neighbour, INVALID_NEIGHBOUR, 'walked outside of the mesh');
+
+                cur_tet = neighbour >>> 2;
+                entering_face = neighbour & 3;
+
+                break;
+
+            }
+        }
+
+        if (i === 4) {
+            // point is inside the tet
+            return cur_tet;
+        }
+    }
+
+}

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

@@ -0,0 +1,60 @@
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
+import { array_range_equal_strict } from "../../../../collection/array/array_range_equal_strict.js";
+
+export function debug_validate_cavity_boundary(mesh, cavity) {
+    let valid = true;
+    const problems = [];
+
+    if (!validate_cavity_boundary(cavity, problem => problems.push(problem))) {
+        valid = false;
+    }
+
+    if (!valid) {
+        debugger;
+    }
+
+    return valid;
+}
+
+/**
+ *
+ * @param {Cavity} cavity
+ * @param {function(problem:string):*} consumer
+ * @returns {boolean}
+ */
+export function validate_cavity_boundary(cavity, consumer) {
+    let valid = true;
+
+    const boundary = cavity.__boundary;
+    const boundary_size = cavity.__boundary_size;
+
+    for (let i = 0; i < boundary_size; i++) {
+        const encoded_tet_0 = boundary[i * 5 + 4];
+
+        if (encoded_tet_0 === INVALID_NEIGHBOUR) {
+            // this is "no neighbour" marker, there are allowed to be many of these
+            continue;
+        }
+
+        for (let j = i + 1; j < boundary_size; j++) {
+
+            const encoded_tet_1 = boundary[j * 5 + 4];
+
+            if (encoded_tet_0 === encoded_tet_1) {
+                valid = false;
+
+                let message = `Duplicate neighbourhood ${encoded_tet_0} (tet=${(encoded_tet_0 >> 2)}, vert=${(encoded_tet_0 & 3)}), boundary elements [${i}, ${j}]`;
+
+                if (!array_range_equal_strict(boundary, i * 5, boundary, j * 5, 4)) {
+                    // boundary definitions are divergent
+                    message += `, boundary definitions are divergent - ${i}:[${boundary.slice(i * 5, i * 5 + 4).join(', ')}], ${j}:[${boundary.slice(j * 5, j * 5 + 4).join(', ')}]`
+                }
+
+                consumer(message);
+            }
+
+        }
+    }
+
+    return valid;
+}

package/core/geom/3d/tetrahedra/{point_in_tetrahedron_circumsphere.js → in_sphere_fast.js}

@@ -1,5 +1,5 @@
 /**
- * Approximate 3D insphere test.  Nonrobust.
+ * Approximate 3D insphere test.  Non-robust.
  *
  * Return a positive value if the point pe lies inside the
  * sphere passing through pa, pb, pc, and pd; a negative value
@@ -19,7 +19,7 @@
  * @param {number} e reference point index that we are testing against the tetrahedron
  * @returns {number}
  */
-export function point_in_tetrahedron_circumsphere(
+export function in_sphere_fast(
     points,
     a, b, c, d, e
 ) {
@@ -34,20 +34,20 @@ export function point_in_tetrahedron_circumsphere(
     const ey = points[e3 + 1];
     const ez = points[e3 + 2];
 
-
     const aex = points[a3] - ex;
-    const bex = points[b3] - ex;
-    const cex = points[c3] - ex;
-    const dex = points[d3] - ex;
-
     const aey = points[a3 + 1] - ey;
-    const bey = points[b3 + 1] - ey;
-    const cey = points[c3 + 1] - ey;
-    const dey = points[d3 + 1] - ey;
-
     const aez = points[a3 + 2] - ez;
+
+    const bex = points[b3] - ex;
+    const bey = points[b3 + 1] - ey;
     const bez = points[b3 + 2] - ez;
+
+    const cex = points[c3] - ex;
+    const cey = points[c3 + 1] - ey;
     const cez = points[c3 + 2] - ez;
+
+    const dex = points[d3] - ex;
+    const dey = points[d3 + 1] - ey;
     const dez = points[d3 + 2] - ez;
 
     const aexbey = aex * bey;
@@ -86,7 +86,5 @@ export function point_in_tetrahedron_circumsphere(
 
     const det = (dlift * abc - clift * dab) + (blift * cda - alift * bcd);
 
-    // TODO HXT uses 2 more methods to perform exact calculation (avoiding rounding errors), we could include that if necessary
-
     return det;
 }

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

@@ -0,0 +1,53 @@
+import { insphere } from "robust-predicates";
+
+/**
+ * Approximate 3D insphere test. Robust
+ *
+ *
+ * @param {number[]} points
+ * @param {number} a tetrahedral point index
+ * @param {number} b tetrahedral point index
+ * @param {number} c tetrahedral point index
+ * @param {number} d tetrahedral point index
+ * @param {number} e reference point index that we are testing against the tetrahedron
+ * @returns {number}
+ */
+export function in_sphere_robust(
+    points,
+    a, b, c, d, e
+) {
+
+    const a3 = a * 3;
+    const b3 = b * 3;
+    const c3 = c * 3;
+    const d3 = d * 3;
+    const e3 = e * 3;
+
+    const ax = points[a3];
+    const ay = points[a3 + 1];
+    const az = points[a3 + 2];
+
+    const bx = points[b3];
+    const by = points[b3 + 1];
+    const bz = points[b3 + 2];
+
+    const cx = points[c3];
+    const cy = points[c3 + 1];
+    const cz = points[c3 + 2];
+
+    const dx = points[d3];
+    const dy = points[d3 + 1];
+    const dz = points[d3 + 2];
+
+    const ex = points[e3];
+    const ey = points[e3 + 1];
+    const ez = points[e3 + 2];
+
+    return -insphere(
+        ax, ay, az,
+        bx, by, bz,
+        cx, cy, cz,
+        dx, dy, dz,
+        ex, ey, ez
+    );
+}