@woosh/meep-engine 2.43.3 → 2.43.5

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

@@ -0,0 +1,75 @@
+import { BufferGeometry, Float32BufferAttribute, Uint32BufferAttribute } from "three";
+import { BitSet } from "../../../binary/BitSet.js";
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} tetrahedra
+ * @param {Float32Array|number[]} points
+ * @return {BufferGeometry}
+ */
+export function build_tetrahedral_mesh_buffer_geometry(tetrahedra, points) {
+    const lines = [];
+
+    const occupancy = new BitSet();
+
+    const point_count = points.length / 3;
+
+    assert.isNonNegativeInteger(point_count, 'point_count');
+
+    /**
+     *
+     * @param {number} a
+     * @param {number} b
+     */
+    function ensure_line(a, b) {
+        assert.isNonNegativeInteger(a, 'a');
+        assert.isNonNegativeInteger(b, 'b');
+
+        assert.lessThan(a, point_count, 'index A is out of bounds');
+        assert.lessThan(b, point_count, 'index B is out of bounds');
+
+        let v0, v1;
+
+        if (a < b) {
+            v0 = a;
+            v1 = b;
+        } else {
+            v0 = b;
+            v1 = a;
+        }
+
+        const index = v0 * point_count + v1;
+
+        if (occupancy.getAndSet(index)) {
+            // already recorded
+            return;
+        }
+
+        // no line record yet, create it
+        lines.push(v0, v1);
+    }
+
+    tetrahedra.forEach((tet, mesh) => {
+        assert.ok(mesh.exists(tet), `Visited un-allocated tet ${tet}`);
+
+        const a = mesh.getVertexIndex(tet, 0);
+        const b = mesh.getVertexIndex(tet, 1);
+        const c = mesh.getVertexIndex(tet, 2);
+        const d = mesh.getVertexIndex(tet, 3);
+
+        ensure_line(a, b);
+        ensure_line(a, c);
+        ensure_line(a, d);
+
+        ensure_line(b, c);
+        ensure_line(c, d);
+        ensure_line(b, d);
+    })
+
+    const geometry = new BufferGeometry();
+
+    geometry.setIndex(new Uint32BufferAttribute(lines, 1, false));
+    geometry.setAttribute('position', new Float32BufferAttribute(points, 3, false));
+    return geometry;
+}

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

@@ -1,3 +1,5 @@
+import { assert } from "../../../../assert.js";
+
 export class Cavity {
     constructor() {
         /**
@@ -13,7 +15,7 @@ export class Cavity {
         this.__deleted_size = 0;
 
         /**
-         * 5-tuples
+         * flat array of 5-tuples
          * @type {number[]}
          * @private
          */
@@ -59,6 +61,8 @@ export class Cavity {
      * @param {number} i
      */
     push_deleted(i) {
+        assert.equal(this.includes(i), false, `ball element ${i} already exists`);
+
         this.__deleted[this.__deleted_size++] = i;
     }
 

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

@@ -2,22 +2,34 @@
 
 import { compute_bounding_simplex_3d } from "../compute_bounding_simplex_3d.js";
 import { TetrahedralMesh } from "../TetrahedralMesh.js";
-import { tetrahedral_mesh_walk_toward_cavity } from "./tetrahedral_mesh_walk_toward_cavity.js";
-import { tetrahedral_mesh_compute_sub_determinant } from "./tetrahedral_mesh_compute_sub_determinant.js";
+import {
+    tetrahedral_mesh_walk_towards_containing_tetrahedron
+} from "./tetrahedral_mesh_walk_towards_containing_tetrahedron.js";
 import { Cavity } from "./Cavity.js";
-import { tetrahedral_mesh_compute_cavity2 } from "./tetrahedral_mesh_compute_cavity2.js";
+import { tetrahedral_mesh_compute_cavity } from "./tetrahedral_mesh_compute_cavity.js";
 import { fill_in_a_cavity } from "./fill_in_a_cavity.js";
-import { debug_validate_mesh } from "./debug_validate_mesh.js";
+import { BitSet } from "../../../../binary/BitSet.js";
+import { assert } from "../../../../assert.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 {TetrahedralMesh} mesh
  * @param {number[]} input serialized set of 3d points (x,y,z)
  * @param {number} n number of points in the input
- * @returns {TetrahedralMesh}
+ * @returns {boolean}
  */
-export function compute_delaunay_tetrahedral_mesh(input, n) {
+export function compute_delaunay_tetrahedral_mesh(mesh, input, n) {
+    assert.notNull(mesh, 'mesh');
+    assert.defined(mesh, 'mesh');
+
+    assert.isNonNegativeInteger(n, 'n');
+
+    if (n < 4) {
+        // no mesh can be created, too few points
+        return false;
+    }
 
     /**
      * According to [1] number of tetrahedra is around 6 times greater than number of input vertices, we use that fact to pre-allocate memory
@@ -27,21 +39,17 @@ 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 mesh = new TetrahedralMesh(tetrahedron_count_upper_bound);
+    // start with a fairly low capacity for best-case scenario, rely on internal resizing after that
 
-    if (n < 4) {
-        // no mesh can be created, too few points
-        return mesh;
-    }
+    mesh.growCapacity(n + 1);
 
     const CAVITY = new Cavity();
 
     // TODO apply spatial sort to point, to get better cache locality
 
-    // compute bounds over the input
-    const sub_determinants = new Float32Array(tetrahedron_count_upper_bound * 4);
+    const build_flags = BitSet.fixedSize(n);
+
     const points = new Float32Array((n + 4) * 3);
 
     points.set(input);
@@ -49,7 +57,7 @@ export function compute_delaunay_tetrahedral_mesh(input, n) {
     /*
      create bounding volume tetrahedron over input set
      */
-    compute_bounding_simplex_3d(points, n * 3, points, n, 1);
+    compute_bounding_simplex_3d(points, n * 3, points, n, 10);
 
     const super_tet = mesh.allocate();
 
@@ -58,36 +66,27 @@ export function compute_delaunay_tetrahedral_mesh(input, n) {
     mesh.setVertexIndex(super_tet, 2, n + 2);
     mesh.setVertexIndex(super_tet, 3, n + 3);
 
-    // make circular references on neighbour (algorithm doesn't work otherwise)
-    // mesh.setNeighbour(super_tet, 0, super_tet << 2 | 0);
-    // mesh.setNeighbour(super_tet, 1, super_tet << 2 | 1);
-    // mesh.setNeighbour(super_tet, 2, super_tet << 2 | 2);
-    // mesh.setNeighbour(super_tet, 3, super_tet << 2 | 3);
-
-    tetrahedral_mesh_compute_sub_determinant(sub_determinants, 0, mesh, points, 0);
-
-    debug_validate_mesh(mesh, points);
+    // debug_validate_mesh(mesh, points);
 
     // add all points to the mesh
     let current_tet = 0;
 
     for (let i = 0; i < n; i++) {
 
-        current_tet = tetrahedral_mesh_walk_toward_cavity(mesh, points, current_tet, i);
+        current_tet = tetrahedral_mesh_walk_towards_containing_tetrahedron(mesh, points, current_tet, i);
 
-        tetrahedral_mesh_compute_cavity2(mesh, points, sub_determinants, CAVITY, current_tet, i);
-        // tetrahedral_mesh_compute_cavity(mesh, CAVITY, points, current_tet, i);
+        tetrahedral_mesh_compute_cavity(mesh, points, build_flags, CAVITY, current_tet, i);
 
-        current_tet = fill_in_a_cavity(mesh, points, sub_determinants, CAVITY, current_tet);
+        current_tet = fill_in_a_cavity(mesh, points, build_flags, CAVITY, current_tet);
 
     }
 
     // remove tetras formed by with the super bounding volume
-    mesh.removeTetrasConnectedToPoints(points, n, n + 3);
+    mesh.removeTetrasConnectedToPoints(n, n + 3);
 
 
-    debug_validate_mesh(mesh, points);
+    // debug_validate_mesh(mesh, points);
 
-    return mesh;
+    return true;
 }
 

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

@@ -1,19 +1,18 @@
 import { assert } from "../../../../assert.js";
-import { tetrahedral_mesh_compute_sub_determinant } from "./tetrahedral_mesh_compute_sub_determinant.js";
 import { array_copy } from "../../../../collection/array/copyArray.js";
 import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
-import { debug_validate_mesh } from "./debug_validate_mesh.js";
+import { validate_neighbour } from "../validate_tetrahedral_mesh.js";
 
 /**
  *
  * @param {TetrahedralMesh} mesh
  * @param {ArrayLike<number>|number[]|Float32Array} points
- * @param {ArrayLike<number>|number[]|Float32Array} subdets
+ * @param {BitSet} visited_flags
  * @param {Cavity} cavity
  * @param {number} cur_tet
  * @returns {number} new current tet
  */
-export function fill_in_a_cavity(mesh, points, subdets, cavity, cur_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
@@ -23,11 +22,12 @@ export function fill_in_a_cavity(mesh, points, subdets, cavity, cur_tet) {
     /*
     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
-            cavity.__deleted[i] = mesh.allocate();
+            deleted_tets[i] = mesh.allocate();
         }
 
         clength = blength;
@@ -39,7 +39,7 @@ export function fill_in_a_cavity(mesh, points, subdets, cavity, cur_tet) {
     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 = cavity.__deleted[i + start];
+        const current_tet_index = deleted_tets[i + start];
 
         const i5 = i * 5;
 
@@ -62,21 +62,51 @@ export function fill_in_a_cavity(mesh, points, subdets, cavity, cur_tet) {
 
         // boundary[i5 + 4] = encoded_current_tet;
 
-        // compute SubDet
-        tetrahedral_mesh_compute_sub_determinant(subdets, current_tet_index * 4, mesh, points, current_tet_index);
+        visited_flags.set(current_tet_index, false); // clear flag
     }
 
     computeAdjacencies(mesh, cavity, start, blength);
-    // computeAdjacenciesSlow(mesh, cavity, start, blength);
 
-    debug_validate_mesh(mesh, points);
+
+    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 = start;
+    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];
 
-    return cavity.__deleted[start];
+        // 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;
 }
 
 /**
@@ -95,7 +125,6 @@ function computeAdjacencies(mesh, cavity, start, blength) {
     let tlength = 0;
 
     const Tmp = boundary; // we know there is enough space...
-    const index = [2, 3, 1, 2];
 
     for (let i = 0; i < blength; i++) {
 
@@ -104,9 +133,13 @@ function computeAdjacencies(mesh, cavity, start, blength) {
         // 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 n0 = mesh.getVertexIndex(cur_tet, index[j]);
-            const n1 = mesh.getVertexIndex(cur_tet, index[j + 1]);
+            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);
@@ -134,10 +167,10 @@ function computeAdjacencies(mesh, cavity, start, blength) {
                 tlength++;
             } else {
                 // we found the neighbour !
-                const encoded_pairValue = Tmp[k * 3 + 2];
+                const encoded_neighbour = Tmp[k * 3 + 2];
 
-                mesh.setNeighbour(cur_tet, current_tet_neighbour_id, encoded_pairValue);
-                mesh.setNeighbour(encoded_pairValue >> 2, encoded_pairValue & 3, encoded_current_tet);
+                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--;
@@ -152,4 +185,7 @@ function computeAdjacencies(mesh, cavity, start, blength) {
 
     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

@@ -0,0 +1,89 @@
+import { assert } from "../../../../assert.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,
+    points,
+    visited_flags,
+    cavity,
+    containing_tetra,
+    point_index
+) {
+    assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
+
+    // add the tet to cavity
+    cavity.push_deleted(containing_tetra);
+    visited_flags.set(containing_tetra, true);
+
+    for (let start = cavity.__deleted_size - 1; start < cavity.__deleted_size; start++) {
+        const cur_tet = cavity.__deleted[start];
+
+        for (let i = 0; i < 4; i++) {
+            const encoded_neighbour = mesh.getNeighbour(cur_tet, i);
+
+            const k0 = (1 << i) & 3;
+            const k1 = (i + 2) % 3;
+            const k2 = (~((i + 1) >> 1) & 2) + 1;
+
+            if (encoded_neighbour === INVALID_NEIGHBOUR) {
+                // no neighbour, include this side into boundary
+
+                cavity.push_boundary(
+                    point_index,
+                    mesh.getVertexIndex(cur_tet, k0),
+                    mesh.getVertexIndex(cur_tet, k1),
+                    mesh.getVertexIndex(cur_tet, k2),
+                    encoded_neighbour,
+                );
+
+                continue;
+            }
+
+            const neighbour_index = encoded_neighbour >> 2;
+
+            if (visited_flags.get(neighbour_index)) {
+                // already visited
+                continue;
+            }
+
+            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
+
+                cavity.push_boundary(
+                    point_index,
+                    mesh.getVertexIndex(cur_tet, k0),
+                    mesh.getVertexIndex(cur_tet, k1),
+                    mesh.getVertexIndex(cur_tet, k2),
+                    encoded_neighbour,
+                );
+
+            } else {
+                // 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_walk_toward_cavity.js → tetrahedral_mesh_walk_towards_containing_tetrahedron.js}

@@ -1,6 +1,6 @@
-import { orient3d_fast } from "../../plane/orient3d_fast.js";
 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
@@ -10,15 +10,15 @@ import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
  * @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} current_tet
- * @param {number} current_vertex
+ * @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_toward_cavity(mesh, points, current_tet, current_vertex) {
+export function tetrahedral_mesh_walk_towards_containing_tetrahedron(mesh, points, hint_tetrahedron, search_vertex_index) {
 
     let entering_face = 4;
 
-    let curTet = current_tet;
+    let cur_tet = hint_tetrahedron;
 
     while (true) {
 
@@ -30,25 +30,28 @@ export function tetrahedral_mesh_walk_toward_cavity(mesh, points, current_tet, c
             const b_i = (i & 2) ^ 3;
             const c_i = (i + 3) & 2;
 
-            const a_index = mesh.getVertexIndex(curTet, a_i);
-            const b_index = mesh.getVertexIndex(curTet, b_i);
-            const c_index = mesh.getVertexIndex(curTet, c_i);
+            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) {
 
-            if (i !== entering_face && orient3d_fast(points, a_index, b_index, c_index, current_vertex) < 0.0) {
                 // point is outside the tet on the neighbour's side, move in that direction
-                const neighbour = mesh.getNeighbour(curTet, i);
+                const neighbour = mesh.getNeighbour(cur_tet, i);
 
                 assert.notEqual(neighbour, INVALID_NEIGHBOUR, 'walked outside of the mesh');
 
-                curTet = neighbour >>> 2;
+                cur_tet = neighbour >>> 2;
                 entering_face = neighbour & 3;
+
                 break;
+
             }
         }
 
         if (i === 4) {
             // point is inside the tet
-            return curTet;
+            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
 ) {
@@ -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
+    );
+}