@woosh/meep-engine 2.33.36 → 2.33.37

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,199 @@
+//
+
+import { compute_bounding_simplex_3d } from "./compute_bounding_simplex_3d.js";
+import { point_in_tetrahedron_circumsphere } from "./point_in_tetrahedron_circumsphere.js";
+import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
+import { assert } from "../../../assert.js";
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const LAYOUT_TETRA_BYTE_SIZE = 9 * 4;
+const INVALID_NEIGHBOUR = 0xFFFFFFFF;
+
+/**
+ *
+ * Layout:
+ *      vertex_id_a :: uint
+ *      vertex_id_b :: uint
+ *      vertex_id_c :: uint
+ *      vertex_id_d :: uint
+ *      neighbour_a :: uint         - neighbour tetrahedron, opposite to vertex A
+ *      neighbour_b :: uint         - neighbour tetrahedron, opposite to vertex B
+ *      neighbour_c :: uint         - neighbour tetrahedron, opposite to vertex C
+ *      neighbour_d :: uint         - neighbour tetrahedron, opposite to vertex D
+ *      sub_determinant :: float    - ?
+ * Layout is similar to [1], but is interleaved for better cache locality
+ */
+class TetrahedraCollection {
+    constructor(initial_size) {
+        this.__buffer = new ArrayBuffer(initial_size * 4 * 9);
+
+        this.__view = new DataView(this.__buffer);
+
+        this.__capacity = initial_size;
+        this.__length = 0;
+    }
+
+    /**
+     *
+     * @param {number} tetra_index
+     * @param {number} neighbour_index
+     * @returns {number}
+     */
+    getNeighbour(tetra_index, neighbour_index) {
+        const tetra_address = LAYOUT_TETRA_BYTE_SIZE * tetra_index;
+        return this.__view.getUint32(tetra_address + (4 + neighbour_index) * 4);
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} points
+     * @param {number} a
+     * @param {number} b
+     * @param {number} c
+     * @param {number} d
+     */
+    append(points, a, b, c, d) {
+        const address = this.__length * LAYOUT_TETRA_BYTE_SIZE;
+
+        // TODO check if there's enough room
+
+        const view = this.__view;
+
+        view.setUint32(address, a);
+        view.setUint32(address + 4, b);
+        view.setUint32(address + 8, c);
+        view.setUint32(address + 12, d);
+
+        // set neighbours
+        view.setUint32(address + 16, INVALID_NEIGHBOUR);
+        view.setUint32(address + 20, INVALID_NEIGHBOUR);
+        view.setUint32(address + 24, INVALID_NEIGHBOUR);
+        view.setUint32(address + 28, INVALID_NEIGHBOUR);
+
+        this.__length++;
+    }
+
+    /**
+     *
+     * @param {number[]} points
+     * @param {number} index
+     * @returns {number} index of tetra or -1 if no containing tetra found
+     */
+    findTetraContainingPoint(points, index) {
+        const data_view = this.__view;
+
+        // TODO improve this
+        const n = this.__length;
+        for (let i = 0; i < n; i++) {
+
+            const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
+
+            const a = data_view.getUint32(tet_address);
+            const b = data_view.getUint32(tet_address + 4);
+            const c = data_view.getUint32(tet_address + 8);
+            const d = data_view.getUint32(tet_address + 12);
+
+            if (tetrahedron_contains_point(points, a, b, c, d, index)) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} points
+     * @param {number} index
+     */
+    insertPoint(points, index) {
+
+        // 1. walk to tetrahedron that contains this point
+        const containing_tetra = this.findTetraContainingPoint(points, index);
+
+        assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
+
+        const cavity = [];
+        const open_set = [
+            containing_tetra
+        ];
+
+        const data_view = this.__view;
+
+        // 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);
+
+            // get neighbours
+            for (let i = 0; i < 4; i++) {
+                const neighbour = this.getNeighbour(tetra, i);
+
+                if (
+                    (neighbour === INVALID_NEIGHBOUR) // no neighbour
+                    || cavity.includes(neighbour)   // already visited
+                    || open_set.includes(neighbour) // already in open set
+                ) {
+
+                    continue;
+                }
+
+                const neighbour_address = neighbour * LAYOUT_TETRA_BYTE_SIZE;
+                const a = data_view.getUint32(neighbour_address);
+                const b = data_view.getUint32(neighbour_address + 4);
+                const c = data_view.getUint32(neighbour_address + 8);
+                const d = data_view.getUint32(neighbour_address + 12);
+
+                // check neighbour
+                const is_in_sphere = point_in_tetrahedron_circumsphere(points, a, b, c, d, index);
+
+                if (is_in_sphere) {
+                    open_set.push(neighbour);
+                }
+            }
+        }
+
+        // 3. remove the cavity tetrahedrons
+
+        // 4. fill the cavity by creating new tetrahedrons connecting the point to the faces of cavity boundary
+    }
+}
+
+/**
+ * @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} input_point_count
+ */
+export function compute_delaunay_tetrahedral_mesh(input, input_point_count) {
+    /**
+     * According to [1] number of tetrahedra is around 6 times greater than number of input vertices, we use that fact to pre-allocate memory
+     */
+    const tetrahedrons = new TetrahedraCollection(input_point_count * 6.01);
+    // TODO apply spatial sort to point, to get better cache locality
+
+    // compute bounds over the input
+    const points = new Float32Array((input_point_count + 4) * 3);
+
+    points.set(input);
+
+    /*
+     create super bounding volume
+     */
+    compute_bounding_simplex_3d(points, input_point_count * 3, points, input_point_count, 1);
+
+    tetrahedrons.append(points, input_point_count, input_point_count + 1, input_point_count + 2, input_point_count + 3);
+
+    // add all points to the mesh
+    for (let i = 0; i < input_point_count; i++) {
+        tetrahedrons.insertPoint(points, i);
+    }
+
+    // remove tetras formed by with the super bounding volume
+    // TODO implement
+}
+