@woosh/meep-engine 2.33.35 → 2.33.39

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

@@ -0,0 +1,177 @@
+import { v3_dot } from "../../v3_dot.js";
+import { min2 } from "../../../math/min2.js";
+import { max2 } from "../../../math/max2.js";
+import { plane_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
+
+/**
+ * Planes used to bound the simplex
+ * NOTE: these might be computed for a given set of points instead, to produce a tighter fit, but this was good enough for my needs so far
+ *
+ * @readonly
+ * @type {Float32Array}
+ */
+const SIMPLEX_PROJECTION_AXES = new Float32Array([
+    Math.sqrt(8 / 9), 0, -1 / 3.,
+    -Math.sqrt(2 / 9), Math.sqrt(2 / 3), -1 / 3,
+    -Math.sqrt(2 / 9), -Math.sqrt(2 / 3), -1 / 3,
+    0, 0, 1
+]);
+
+/**
+ * Compute bounding tetrahedron (3d simplex) for a given set of input points
+ *
+ * @see https://github.com/bryanmcnett/aabo/blob/master/aabo.cpp
+ * @author Alexander Goldring (c) 2021
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} input_count
+ * @param {number} padding Planar offset for each of the simple sides, positive padding value will create a larger simplex. Useful for ensuring that input points do not lie directly on the simplex planes
+ */
+export function compute_bounding_simplex_3d(
+    result,
+    result_offset,
+    input,
+    input_count,
+    padding
+) {
+    if (input_count <= 0) {
+        // no inputs
+        return;
+    }
+
+    // initialize
+    let x = input[0];
+    let y = input[1];
+    let z = input[2];
+
+    let a = v3_dot(
+        x,
+        y,
+        z,
+        SIMPLEX_PROJECTION_AXES[0],
+        SIMPLEX_PROJECTION_AXES[1],
+        SIMPLEX_PROJECTION_AXES[2],
+    );
+    let b = v3_dot(
+        x,
+        y,
+        z,
+        SIMPLEX_PROJECTION_AXES[3],
+        SIMPLEX_PROJECTION_AXES[4],
+        SIMPLEX_PROJECTION_AXES[5],
+    );
+    let c = v3_dot(
+        x,
+        y,
+        z,
+        SIMPLEX_PROJECTION_AXES[6],
+        SIMPLEX_PROJECTION_AXES[7],
+        SIMPLEX_PROJECTION_AXES[8],
+    );
+    let d = v3_dot(
+        x,
+        y,
+        z,
+        SIMPLEX_PROJECTION_AXES[9],
+        SIMPLEX_PROJECTION_AXES[10],
+        SIMPLEX_PROJECTION_AXES[11],
+    );
+
+    let min_a = a;
+    let min_b = b;
+    let min_c = c;
+    let min_d = d;
+
+    let max_a = a;
+    let max_b = b;
+    let max_c = c;
+    let max_d = d;
+
+    for (let i = 1; i < input_count; i++) {
+
+        const i3 = i * 3;
+
+        x = input[i3];
+        y = input[i3 + 1];
+        z = input[i3 + 2];
+
+        a = v3_dot(
+            x,
+            y,
+            z,
+            SIMPLEX_PROJECTION_AXES[0],
+            SIMPLEX_PROJECTION_AXES[1],
+            SIMPLEX_PROJECTION_AXES[2],
+        );
+        b = v3_dot(
+            x,
+            y,
+            z,
+            SIMPLEX_PROJECTION_AXES[3],
+            SIMPLEX_PROJECTION_AXES[4],
+            SIMPLEX_PROJECTION_AXES[5],
+        );
+        c = v3_dot(
+            x,
+            y,
+            z,
+            SIMPLEX_PROJECTION_AXES[6],
+            SIMPLEX_PROJECTION_AXES[7],
+            SIMPLEX_PROJECTION_AXES[8],
+        );
+        d = v3_dot(
+            x,
+            y,
+            z,
+            SIMPLEX_PROJECTION_AXES[9],
+            SIMPLEX_PROJECTION_AXES[10],
+            SIMPLEX_PROJECTION_AXES[11],
+        );
+
+        min_a = min2(min_a, a);
+        min_b = min2(min_b, b);
+        min_c = min2(min_c, c);
+        min_d = min2(min_d, d);
+
+        max_a = max2(max_a, a);
+        max_b = max2(max_b, b);
+        max_c = max2(max_c, c);
+        max_d = max2(max_d, d);
+    }
+
+    // we now have the planar offset for each projection axis
+
+    // apply padding offset
+    min_a -= padding;
+    min_b -= padding;
+    min_c -= padding;
+    min_d -= padding;
+
+    // lets 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,
+        SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
+        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c
+    );
+    plane_computeConvex3PlaneIntersection(
+        result, result_offset + 3,
+        SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
+        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
+        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
+    );
+    plane_computeConvex3PlaneIntersection(
+        result, result_offset + 6,
+        SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
+        SIMPLEX_PROJECTION_AXES[3], SIMPLEX_PROJECTION_AXES[4], SIMPLEX_PROJECTION_AXES[5], -min_b,
+        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
+    );
+    plane_computeConvex3PlaneIntersection(
+        result, result_offset + 9,
+        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c,
+        SIMPLEX_PROJECTION_AXES[0], SIMPLEX_PROJECTION_AXES[1], SIMPLEX_PROJECTION_AXES[2], -min_a,
+        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
+    );
+}

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

@@ -0,0 +1,66 @@
+import { compute_bounding_simplex_3d } from "./compute_bounding_simplex_3d.js";
+import { v3_distance } from "../../v3_distance.js";
+import { orient3d_fast } from "../plane/orient3d_fast.js";
+
+test('one point', () => {
+    const r = [];
+    compute_bounding_simplex_3d(r, 0, [1, 2, 3], 1, 0);
+
+    for (let i = 0; i < 4; i++) {
+        const i3 = i * 3;
+
+        expect(r[i3]).toBeCloseTo(1);
+        expect(r[i3 + 1]).toBeCloseTo(2);
+        expect(r[i3 + 2]).toBeCloseTo(3);
+    }
+});
+
+test('planar containment, one point', () => {
+    const r = [];
+
+    compute_bounding_simplex_3d(r, 0, [0, 0, 0], 1, 1);
+
+    r.push(0, 0, 0);
+
+    expect(orient3d_fast(r, 1, 3, 2, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 2, 3, 0, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 3, 1, 0, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 0, 1, 2, 4)).toBeLessThan(0);
+});
+
+test('positive padding results in larger simplex', () => {
+    const r_0 = [];
+    const r_n = [];
+    const r_p = [];
+
+    const volume = [
+        -100, 0, 0,
+        100, 0, 0,
+        0, -100, 0,
+        0, 100, 0,
+        0, 0, -100,
+        0, 0, 100,
+    ];
+
+    compute_bounding_simplex_3d(r_0, 0, volume, 6, 0);
+    compute_bounding_simplex_3d(r_n, 0, volume, 6, -1);
+    compute_bounding_simplex_3d(r_p, 0, volume, 6, 1);
+
+    function compute_distance_sum(ref, points, point_count) {
+        let r = 0;
+        for (let i = 0; i < point_count; i++) {
+            const i3 = i * 3;
+
+            r += v3_distance(points[i3], points[i3 + 1], points[i3 + 2], ref[0], ref[1], ref[2]);
+        }
+
+        return r;
+    }
+
+    const d_0 = compute_distance_sum([0, 0, 0], r_0, 4);
+    const d_n = compute_distance_sum([0, 0, 0], r_n, 4);
+    const d_p = compute_distance_sum([0, 0, 0], r_p, 4);
+
+    expect(d_0).toBeLessThan(d_p);
+    expect(d_0).toBeGreaterThan(d_n);
+});

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

@@ -0,0 +1,271 @@
+import { array_copy } from "../../../collection/array/copyArray.js";
+import { v3_dot } from "../../v3_dot.js";
+
+const MAX_FLOAT32 = 3.4028234663852886e+38;
+const SMALL_NUMBER = 1e-12;
+const VTK_MAX_WARNS = 3;
+
+/**
+ * Compute the circumcenter (center[3]) and radius squared (method
+ * return value) of a tetrahedron defined by the four points x1, x2,
+ * x3, and x4.
+ *
+ * @see https://github.com/Kitware/VTK/blob/ac3fd8005bce7b3da4423c305f61ffd9df9695ef/Common/DataModel/vtkTetra.cxx
+ * @param {number[]} result [center_x, center_y, center_z, radius_squared]
+ * @param {number[]} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ */
+export function compute_circumsphere(
+    result,
+    points,
+    a, b, c, d
+) {
+    const n12 = [];
+    const n13 = [];
+    const n14 = [];
+
+    const x12 = [];
+    const x13 = [];
+    const x14 = [];
+
+    //  calculate normals and intersection points of bisecting planes.
+    for (let i = 0; i < 3; i++) {
+        const v_a = points[a * 3 + i];
+
+        const v_b = points[b * 3 + i];
+        n12[i] = v_b - v_a;
+        const v_c = points[c * 3 + i];
+        n13[i] = v_c - v_a;
+        const v_d = points[d * 3 + i];
+        n14[i] = v_d - v_a;
+
+        x12[i] = (v_b + v_a) * 0.5;
+        x13[i] = (v_c + v_a) * 0.5;
+        x14[i] = (v_d + v_a) * 0.5;
+    }
+
+    const A = [];
+
+    array_copy(n12, 0, A, 0, 3);
+    array_copy(n13, 0, A, 3, 3);
+    array_copy(n14, 0, A, 6, 3);
+
+    const rhs = [];
+
+    rhs[0] = v3_dot(n12[0], n12[1], n12[2], x12[0], x12[1], x12[2]);
+    rhs[1] = v3_dot(n13[0], n13[1], n13[2], x13[0], x13[1], x13[2]);
+    rhs[2] = v3_dot(n14[0], n14[1], n14[2], x14[0], x14[1], x14[2]);
+
+    // Solve system of equations
+    if (solve_linear_system(A, rhs, 3) === false) {
+        // failed to solve, fall-back to infinitely-sized sphere centered around origin
+        result[0] = result[1] = result[2] = 0;
+        result[3] = MAX_FLOAT32;
+        return;
+    } else {
+        result[0] = rhs[0];
+        result[1] = rhs[1];
+        result[2] = rhs[2];
+    }
+
+    let sum = 0;
+    let diff;
+
+    for (let i = 0; i < 3; i++) {
+        const rhs_offset = rhs[i];
+
+        diff = points[a * 3 + i] - rhs_offset;
+        sum += diff * diff;
+        diff = points[b * 3 + i] - rhs_offset;
+        sum += diff * diff;
+        diff = points[c * 3 + i] - rhs_offset;
+        sum += diff * diff;
+        diff = points[d * 3 + i] - rhs_offset;
+        sum += diff * diff;
+    }
+
+    // divide
+    sum *= 0.25;
+
+    if (sum >= MAX_FLOAT32) {
+        result[3] = MAX_FLOAT32;
+    } else {
+        result[3] = sum;
+    }
+}
+
+/**
+ * Solve linear equations Ax = b using Crout's method. Input is square matrix A
+ * and load vector b. Solution x is written over load vector. The dimension of
+ * the matrix is specified in size. If error is found, method returns a 0.
+ *
+ * @see https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx
+ *
+ * @param {number[]} A
+ * @param {number[]} x
+ * @param {number} size
+ * @returns {boolean}
+ */
+function solve_linear_system(A, x, size) {
+    const index = [];
+
+    if (luf_factor_linear_system(A, index, size) === 0) {
+        return false;
+    }
+
+    luf_solve_linear_system(A, index, x, size);
+
+    return true;
+}
+
+
+/**
+ * Factor linear equations Ax = b using LU decomposition A = LU where L is
+ * lower triangular matrix and U is upper triangular matrix. Input is
+ * square matrix A, integer array of pivot indices index[0->n-1], and size
+ * of square matrix n. Output factorization LU is in matrix A. If error is
+ * found, method returns 0.
+ * @param {number[]} A
+ * @param {number[]} index
+ * @param {number} size
+ */
+function luf_factor_linear_system(A, index, size) {
+    const scale = [];
+
+    // double scratch[10];
+    // double* scale = (size < 10 ? scratch : new double[size]);
+    //
+    // int i, j, k;
+    // int maxI = 0;
+    // double largest, temp1, temp2, sum;
+    //
+    // // Manage number of output warnings
+    // static int numWarns = 0;
+    //
+    // //
+
+    let numWarns = 0;
+    let i, j, k;
+    let maxI = 0;
+    let largest, temp1, temp2, sum;
+    // Loop over rows to get implicit scaling information
+    //
+    for (i = 0; i < size; ++i) {
+        for (largest = 0.0, j = 0; j < size; ++j) {
+            if ((temp2 = Math.abs(A[i * size + j])) > largest) {
+                largest = temp2;
+            }
+        }
+
+        if (largest === 0.0 && numWarns++ < VTK_MAX_WARNS) {
+            // vtkGenericWarningMacro(<< "Unable to factor linear system");
+            return 0;
+        }
+        scale[i] = 1.0 / largest;
+    }
+    //
+    // Loop over all columns using Crout's method
+    //
+    for (j = 0; j < size; ++j) {
+        for (i = 0; i < j; ++i) {
+            sum = A[i * size + j];
+            for (k = 0; k < i; ++k) {
+                sum -= A[i * size + k] * A[k * size + j];
+            }
+            A[i * size + j] = sum;
+        }
+        //
+        // Begin search for largest pivot element
+        //
+        for (largest = 0.0, i = j; i < size; ++i) {
+            sum = A[i * size + j];
+            for (k = 0; k < j; ++k) {
+                sum -= A[i * size + k] * A[k * size + j];
+            }
+            A[i * size + j] = sum;
+
+            if ((temp1 = scale[i] * Math.abs(sum)) >= largest) {
+                largest = temp1;
+                maxI = i;
+            }
+        }
+        //
+        // Check for row interchange
+        //
+        if (j !== maxI) {
+            for (k = 0; k < size; ++k) {
+                temp1 = A[maxI * size + k];
+                A[maxI * size + k] = A[j * size + k];
+                A[j * size + k] = temp1;
+            }
+            scale[maxI] = scale[j];
+        }
+        //
+        // Divide by pivot element and perform elimination
+        //
+        index[j] = maxI;
+
+        if (Math.abs(A[j * size + j]) <= SMALL_NUMBER && numWarns++ < VTK_MAX_WARNS) {
+            //vtkGenericWarningMacro(<< "Unable to factor linear system");
+            return 0;
+        }
+
+        if (j !== (size - 1)) {
+            temp1 = 1.0 / A[j * size + j];
+            for (i = j + 1; i < size; ++i) {
+                A[i * size + j] *= temp1;
+            }
+        }
+    }
+
+    return 1;
+}
+
+/**
+ * Solve linear equations Ax = b using LU decomposition A = LU where L is
+ * lower triangular matrix and U is upper triangular matrix. Input is
+ * factored matrix A=LU, integer array of pivot indices index[0->n-1],
+ * load vector x[0->n-1], and size of square matrix n. Note that A=LU and
+ * index[] are generated from method LUFactorLinearSystem). Also, solution
+ * vector is written directly over input load vector.
+ * @param {number[]} A
+ * @param {number[]} index
+ * @param {number[]} x
+ * @param {number} size
+ */
+function luf_solve_linear_system(A, index, x, size) {
+    let i, j, ii, idx;
+    let sum;
+    //
+    // Proceed with forward and backsubstitution for L and U
+    // matrices.  First, forward substitution.
+    //
+    for (ii = -1, i = 0; i < size; ++i) {
+        idx = index[i];
+        sum = x[idx];
+        x[idx] = x[i];
+
+        if (ii >= 0) {
+            for (j = ii; j <= (i - 1); ++j) {
+                sum -= A[i * size + j] * x[j];
+            }
+        } else if (sum !== 0.0) {
+            ii = i;
+        }
+
+        x[i] = sum;
+    }
+    //
+    // Now, back substitution
+    //
+    for (i = size - 1; i >= 0; i--) {
+        sum = x[i];
+        for (j = i + 1; j < size; ++j) {
+            sum -= A[i * size + j] * x[j];
+        }
+        x[i] = sum / A[i * size + i];
+    }
+}

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

@@ -0,0 +1,50 @@
+//
+
+import { compute_bounding_simplex_3d } from "./compute_bounding_simplex_3d.js";
+import { TetrahedraCollection } 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
+ */
+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
+     * From the book of Cheng et al. 'Delaunay Mesh Generation' A triangulation of n vertices in R^3 has at most `ntet=(n^2 − 3n − 2)/2` tetrahedra,
+     * at most nedg=(n^2 − n)/2` edges (this is simply the 2-combination of n)
+     * and at most `ntri=n^2 − 3n = 2*ntet+2` triangles
+     *
+     * 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);
+    // TODO apply spatial sort to point, to get better cache locality
+
+    // compute bounds over the input
+    const points = new Float32Array((n + 4) * 3);
+
+    points.set(input);
+
+    /*
+     create super bounding volume
+     */
+    compute_bounding_simplex_3d(points, n * 3, points, n, 1);
+
+    tetrahedrons.append(points, n, n + 1, n + 2, n + 3);
+
+    // add all points to the mesh
+    for (let i = 0; i < n; i++) {
+        tetrahedrons.insertPoint(points, i);
+    }
+
+    // remove tetras formed by with the super bounding volume
+    tetrahedrons.removeTetrasConnectedToPoints(points, n, n + 3);
+}
+

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

@@ -0,0 +1,14 @@
+import { compute_delaunay_tetrahedral_mesh } from "./compute_delaunay_tetrahedral_mesh.js";
+
+test('single point', () => {
+    compute_delaunay_tetrahedral_mesh([1, 2, 3], 1);
+});
+
+test('exactly 4 points', () => {
+    compute_delaunay_tetrahedral_mesh([
+        -1, 0, 0,
+        1, 0, 0,
+        0.5, 1, 0,
+        0.5, 0, 1
+    ], 4);
+});

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

@@ -0,0 +1,77 @@
+/**
+ * Approximate 3D insphere test.  Nonrobust.
+ *
+ * Return a positive value if the point pe lies inside the
+ * sphere passing through pa, pb, pc, and pd; a negative value
+ * if it lies outside; and zero if the five points are
+ * cospherical.  The points pa, pb, pc, and pd must be ordered
+ * so that they have a positive orientation (as defined by
+ * orient3d()), or the sign of the result will be reversed.
+ *
+ * @see "Adaptive Precision Floating-Point Arithmetic and Fast Robust Geometric Predicates." Technical Report CMU-CS-96-140, School of Computer Science, Carnegie Mellon University, Pittsburgh, Pennsylvania, May 1996
+ * @see http://www.cs.cmu.edu/~quake/robust.html
+ * @see https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/predicates/src/predicates.c
+ * @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
+ * @returns {number}
+ */
+export function point_in_tetrahedron_circumsphere(points, a, b, c, d, e) {
+    const ex = points[e * 3];
+    const ey = points[e * 3 + 1];
+    const ez = points[e * 3 + 2];
+
+    const aex = points[a * 3] - ex;
+    const bex = points[b * 3] - ex;
+    const cex = points[c * 3] - ex;
+    const dex = points[d * 3] - ex;
+
+    const aey = points[a * 3 + 1] - ey;
+    const bey = points[b * 3 + 1] - ey;
+    const cey = points[c * 3 + 1] - ey;
+    const dey = points[d * 3 + 1] - ey;
+
+    const aez = points[a * 3 + 2] - ez;
+    const bez = points[b * 3 + 2] - ez;
+    const cez = points[c * 3 + 2] - ez;
+    const dez = points[d * 3 + 1] - ez;
+
+    const aexbey = aex * bey;
+    const bexaey = bex * aey;
+    const ab = aexbey - bexaey;
+    const bexcey = bex * cey;
+    const cexbey = cex * bey;
+    const bc = bexcey - cexbey;
+    const cexdey = cex * dey;
+    const dexcey = dex * cey;
+    const cd = cexdey - dexcey;
+    const dexaey = dex * aey;
+    const aexdey = aex * dey;
+    const da = dexaey - aexdey;
+
+    const aexcey = aex * cey;
+    const cexaey = cex * aey;
+    const ac = aexcey - cexaey;
+    const bexdey = bex * dey;
+    const dexbey = dex * bey;
+    const bd = bexdey - dexbey;
+
+    const abc = aez * bc - bez * ac + cez * ab;
+    const bcd = bez * cd - cez * bd + dez * bc;
+    const cda = cez * da + dez * ac + aez * cd;
+    const dab = dez * ab + aez * bd + bez * da;
+
+    const alift = aex * aex + aey * aey + aez * aez;
+    const blift = bex * bex + bey * bey + bez * bez;
+    const clift = cex * cex + cey * cey + cez * cez;
+    const dlift = dex * dex + dey * dey + dez * dez;
+
+    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;
+}