@woosh/meep-engine 2.33.36 → 2.33.40

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;
+}

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

@@ -0,0 +1,454 @@
+import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
+import { assert } from "../../../assert.js";
+import { point_in_tetrahedron_circumsphere } from "./point_in_tetrahedron_circumsphere.js";
+import { BitSet } from "../../../binary/BitSet.js";
+import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
+import { max3 } from "../../../math/max3.js";
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const LAYOUT_TETRA_BYTE_SIZE = 9 * 4;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const INVALID_NEIGHBOUR = 0xFFFFFFFF;
+
+class Cavity {
+    constructor() {
+        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;
+    }
+}
+
+const SCRATCH_CAVITY = new Cavity();
+
+/**
+ *
+ * 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
+ */
+export class TetrahedraCollection {
+    constructor(initial_size) {
+        this.__buffer = new ArrayBuffer(initial_size * LAYOUT_TETRA_BYTE_SIZE);
+
+        this.__view = new DataView(this.__buffer);
+
+        this.__capacity = initial_size;
+        this.__length = 0;
+
+
+        /**
+         * Marks which indices are in use
+         * @type {BitSet}
+         * @private
+         */
+        this.__occupancy = new BitSet();
+    }
+
+    /**
+     *
+     * @param {number} n
+     */
+    setCapacity(n) {
+        if (n === this.__capacity) {
+            // do nothing
+            return;
+        }
+
+        if (n < this.__length) {
+            throw new Error('Dropping information, not supported');
+        }
+
+        // allocate new buffer
+        const new_buffer = new ArrayBuffer(n * LAYOUT_TETRA_BYTE_SIZE);
+
+        // move data across from old buffer to the new one
+        const destination_uint8 = new Uint8Array(new_buffer);
+        const source_uint8 = new Uint8Array(this.__buffer);
+
+        typed_array_copy(source_uint8, destination_uint8);
+
+        // set new buffer
+        this.__buffer = new_buffer;
+        this.__view = new DataView(new_buffer);
+    }
+
+    /**
+     *
+     * @param {number} n
+     */
+    ensureCapacity(n) {
+
+        const new_capacity = max3(
+            n,
+            this.__capacity * 1.2,
+            this.__capacity + 32
+        );
+
+        this.setCapacity(new_capacity);
+    }
+
+    /**
+     *
+     * @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} tetra_index
+     * @param {number} neighbour_index which neighbour to set (0..11)
+     * @param {number} neighbour index of the neighbour
+     */
+    setNeighbour(tetra_index, neighbour_index, neighbour) {
+        const tetra_address = LAYOUT_TETRA_BYTE_SIZE * tetra_index;
+        return this.__view.setUint32(tetra_address + (4 + neighbour_index) * 4, neighbour);
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} points
+     * @param {number} a
+     * @param {number} b
+     * @param {number} c
+     * @param {number} d
+     * @returns {number} index of the new tetra
+     */
+    append(points, a, b, c, d) {
+        const tetra_index = this.__occupancy.nextClearBit(0);
+        const address = tetra_index * LAYOUT_TETRA_BYTE_SIZE;
+
+        if (tetra_index >= this.__capacity) {
+            // needs to be increased in size
+            this.ensureCapacity(tetra_index);
+        }
+
+        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.__occupancy.set(tetra_index, true);
+
+        this.__length++;
+
+        return tetra_index;
+    }
+
+    /**
+     * Remove tetrahedron
+     * @param {number} tera_index
+     */
+    remove(tera_index) {
+
+        // find neighbours and remove reference to self
+        for (let i = 0; i < 4; i++) {
+            const neighbour_encoded = this.getNeighbour(tera_index, i);
+
+            if (neighbour_encoded === INVALID_NEIGHBOUR) {
+                // no neighbour
+                continue;
+            }
+
+            // get tetrahedra index and point index
+            const neighbour_index = neighbour_encoded >> 2;
+            const neighbour_point = neighbour_encoded & 4;
+
+            // clear reference to self
+            this.setNeighbour(neighbour_index, neighbour_point, INVALID_NEIGHBOUR);
+        }
+
+        // mark as dead
+        this.__occupancy.clear(tera_index);
+        this.__length--;
+    }
+
+    /**
+     * Remove tetrahedrons who's points touch the "super-tetrahedron's" points that was inserted originally
+     * These points are identified by an offset + count parameters
+     * @param {number[]|Float32Array} points
+     * @param {number} range_start
+     * @param {number} range_end
+     */
+    removeTetrasConnectedToPoints(points, range_start, range_end) {
+        const data_view = this.__view;
+
+        let i = 0;
+        let j = 0;
+
+        const occupancy = this.__occupancy;
+        for (i = occupancy.nextSetBit(0); i !== -1; i = occupancy.nextSetBit(i + 1)) {
+
+            const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
+
+            for (j = 0; j < 4; j++) {
+                const point_index = data_view.getUint32(tet_address + 4 * i);
+
+                if (point_index >= range_start && point_index <= range_end) {
+                    // point index is in range, tetra should be removed
+                    this.remove(i);
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @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 {Cavity} cavity
+     * @param {number[]|Float32Array} points
+     * @param {number} index
+     */
+    computeCavity(cavity, points, index) {
+
+        // 1.identify tetrahedron that contains this point
+        const containing_tetra = this.findTetraContainingPoint(points, index);
+
+        assert.isNonNegativeInteger(containing_tetra, 'containing_tetra');
+
+        cavity.reset();
+
+        /**
+         *
+         * @type {number[]}
+         */
+        const open_set = [
+            containing_tetra
+        ];
+
+        /**
+         *
+         * @type {number[]}
+         */
+        const closed_set = [];
+
+        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);
+            closed_set.push(tetra);
+
+            // get neighbours
+            for (let i = 0; i < 4; i++) {
+                const neighbour_encoded = this.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 neighbour_address = neighbour_tetra_index * 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_tetra_index);
+                } else {
+                    // move directly to closed set
+                    closed_set.push(neighbour_tetra_index);
+                }
+
+
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} points
+     * @param {number} index
+     */
+    insertPoint(points, index) {
+        // Compute the cavity, that is the set of tetrahedra that need to be removed and rebuilt
+        this.computeCavity(SCRATCH_CAVITY, points, index);
+
+
+        // identify cavity "edge" - the set of tetras that are neighbours of the tetras that form the cavity
+        const cavity_size = SCRATCH_CAVITY.size;
+        const cavity_indices = SCRATCH_CAVITY.indices;
+        const data = this.__view;
+
+        for (let i = 0; i < cavity_size; i++) {
+            const cavity_index = cavity_indices[i];
+
+            // take each side of the tetra
+            const tetra_address = cavity_index * LAYOUT_TETRA_BYTE_SIZE;
+
+            const a = data.getUint32(tetra_address);
+            const b = data.getUint32(tetra_address + 4);
+            const c = data.getUint32(tetra_address + 8);
+            const d = data.getUint32(tetra_address + 12);
+
+            // attempt to form 4 tetras using the sides of the cavity
+            const a_neighbour = data.getUint32(tetra_address + 16);
+            const a_neighbour_index = a_neighbour >> 2;
+
+            const b_neighbour = data.getUint32(tetra_address + 20);
+            const b_neighbour_index = b_neighbour >> 2;
+
+            const c_neighbour = data.getUint32(tetra_address + 24);
+            const c_neighbour_index = c_neighbour >> 2;
+
+            const d_neighbour = data.getUint32(tetra_address + 28);
+            const d_neighbour_index = d_neighbour >> 2;
+
+
+            if (a_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(a_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, b, d, c, index);
+                // patch in neighbours
+                if (a_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, a_neighbour);
+                    this.setNeighbour(a_neighbour_index, a_neighbour & 3, tet);
+                }
+            }
+            if (b_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(b_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, c, d, a, index);
+                if (b_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, b_neighbour);
+                    this.setNeighbour(b_neighbour_index, b_neighbour & 3, tet);
+                }
+            }
+            if (c_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(c_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, d, b, a, index);
+                if (c_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, c_neighbour);
+                    this.setNeighbour(c_neighbour_index, c_neighbour & 3, tet);
+                }
+            }
+            if (d_neighbour === INVALID_NEIGHBOUR || cavity_indices.indexOf(d_neighbour_index) === 0) {
+                // ABC is a valid side
+                const tet = this.append(points, a, b, c, index);
+                if (d_neighbour !== INVALID_NEIGHBOUR) {
+                    this.setNeighbour(tet, 3, d_neighbour);
+                    this.setNeighbour(d_neighbour_index, d_neighbour & 3, tet);
+                }
+            }
+        }
+
+
+        // 3. remove the cavity tetrahedrons
+        for (let i = 0; i < cavity_size; i++) {
+            const cavity_index = cavity_indices[i];
+
+            // clear out cavity, connectivity was already patched in the previous step
+            this.__occupancy.set(cavity_index, false);
+        }
+    }
+
+    /**
+     * optimize tetrahedrons to reduce number of thin and long tetras
+     * @see https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/tetMesh/src/HXTSPR.c
+     */
+    optimize() {
+
+        throw new Error('Not Implemented');
+    }
+}

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

@@ -0,0 +1,26 @@
+import { orient3d_fast } from "../plane/orient3d_fast.js";
+
+/**
+ * Containment test, whether tetrahedron defined by A,B,C,D contains point E or not
+ * Implemented using planar tests on each of side of the tetrahedron
+ *
+ * NOTE:    similar to https://gitlab.onelab.info/gmsh/gmsh/-/blob/master/contrib/hxt/tetMesh/src/HXTSPR.c
+ *          We skip identity checks and bounding box checks. Identity is a waste of time when building tetrahedral mesh,
+ *          since each inserted point will be new to the mesh, box checks are not relevant as we don't track those
+ *
+ * @param {number[]} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} e
+ * @returns {boolean}
+ */
+export function tetrahedron_contains_point(points, a, b, c, d, e) {
+    return !(
+        orient3d_fast(points, b, d, c, e) > 0
+        || orient3d_fast(points, c, d, a, e) > 0
+        || orient3d_fast(points, d, b, a, e) > 0
+        || orient3d_fast(points, a, b, c, e) > 0
+    );
+}

package/core/geom/Quaternion.js

@@ -1298,6 +1298,10 @@ class Quaternion {
         this.set(x, y, z, w);
     }
 
+    /**
+     * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+     * @param value
+     */
     decodeFromUint32(value) {
         //read components
         const max = value & 0x3;

package/core/math/hash/murmur3_32.js

@@ -0,0 +1,39 @@
+/**
+ * NOTE: based on https://github.com/garycourt/murmurhash-js/blob/master/murmurhash3_gc.js
+ * @param {Uint32Array} key
+ * @param {number} seed
+ * @returns {number}
+ */
+export function murmur3_32(key, seed) {
+    let h1 = seed;
+    let k1;
+    let i = 0;
+
+    const bytes = key.length;
+
+    while (i < bytes) {
+        k1 = key[i];
+        ++i;
+
+        k1 = ((((k1 & 0xffff) * 0xcc9e2d51) + ((((k1 >>> 16) * 0xcc9e2d51) & 0xffff) << 16)));
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = ((((k1 & 0xffff) * 0x1b873593) + ((((k1 >>> 16) * 0x1b873593) & 0xffff) << 16)));
+
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1 = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16)));
+        h1 = (((h1 & 0xffff) + 0x6b64) + ((((h1 >>> 16) + 0xe654) & 0xffff) << 16));
+    }
+
+    // mix in array length
+    h1 ^= bytes;
+
+    h1 ^= h1 >>> 16;
+    h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16));
+    h1 ^= h1 >>> 13;
+    h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16)));
+    h1 ^= h1 >>> 16;
+
+    // cast to uint32
+    return h1 >>> 0;
+}

package/core/process/undo/ActionProcessor.d.ts

@@ -22,4 +22,6 @@ export class ActionProcessor<CTX, MD> {
     doMany(actions: Action<CTX>[]): void
 
     do(action: Action<CTX>): this
+
+    clear(): void
 }