@woosh/meep-engine 2.43.1 → 2.43.4

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

@@ -0,0 +1,233 @@
+import { TetrahedralMesh } from "./TetrahedralMesh.js";
+import { jest } from "@jest/globals";
+
+test("constructor does not throw", () => {
+    expect(() => new TetrahedralMesh(1)).not.toThrow();
+});
+
+test("capacity set in constructor is respected", () => {
+    const mesh = new TetrahedralMesh(7);
+
+    expect(mesh.getCapacity()).toBe(7);
+});
+
+test("attempting to set capacity below what's used will throw", () => {
+    const mesh = new TetrahedralMesh(1);
+
+    mesh.allocate();
+    mesh.allocate();
+
+    expect(() => mesh.setCapacity(1)).toThrow();
+});
+
+test("set/get capacity consistence", () => {
+    const mesh = new TetrahedralMesh(2);
+
+    mesh.setCapacity(1);
+
+    expect(mesh.getCapacity()).toBe(1);
+
+    mesh.setCapacity(1); // idempotency check
+
+    expect(mesh.getCapacity()).toBe(1);
+
+    mesh.setCapacity(2);
+
+    expect(mesh.getCapacity()).toBe(2);
+});
+
+
+test("set/get neighbour consistency", () => {
+    const mesh = new TetrahedralMesh(7);
+
+    const tet = mesh.allocate();
+
+    mesh.setNeighbour(tet, 0, 7);
+    mesh.setNeighbour(tet, 1, 3);
+    mesh.setNeighbour(tet, 2, 11);
+    mesh.setNeighbour(tet, 3, 13);
+
+    //
+    expect(mesh.getNeighbour(tet, 0)).toBe(7);
+    expect(mesh.getNeighbour(tet, 1)).toBe(3);
+    expect(mesh.getNeighbour(tet, 2)).toBe(11);
+    expect(mesh.getNeighbour(tet, 3)).toBe(13);
+});
+
+test("set/get vertex index consistency", () => {
+    const mesh = new TetrahedralMesh(7);
+    const tet = mesh.allocate();
+
+    mesh.setVertexIndex(tet, 0, 3);
+    mesh.setVertexIndex(tet, 1, 7);
+    mesh.setVertexIndex(tet, 2, 11);
+    mesh.setVertexIndex(tet, 3, 13);
+
+    //
+    expect(mesh.getVertexIndex(tet, 0)).toBe(3);
+    expect(mesh.getVertexIndex(tet, 1)).toBe(7);
+    expect(mesh.getVertexIndex(tet, 2)).toBe(11);
+    expect(mesh.getVertexIndex(tet, 3)).toBe(13);
+});
+
+test("allocation within capacity doesn't resize capacity", () => {
+    const mesh = new TetrahedralMesh(1);
+
+    expect(mesh.getCapacity()).toBe(1);
+
+    mesh.allocate();
+
+    expect(mesh.getCapacity()).toBe(1); // allocation fits in the capacity, so no growth is expected
+});
+
+test("allocation beyond capacity does not destroy existing data", () => {
+    const mesh = new TetrahedralMesh(1);
+
+    const t0 = mesh.allocate();
+
+    expect(mesh.getCapacity()).toBe(1);
+
+    for (let i = 0; i < 4; i++) {
+        mesh.setNeighbour(t0, i, 1);
+        mesh.setVertexIndex(t0, i, 3);
+    }
+
+    mesh.allocate(); // allocation over capacity
+
+    expect(mesh.getCapacity()).toBeGreaterThan(1);
+
+    for (let i = 0; i < 4; i++) {
+        expect(mesh.getNeighbour(t0, i)).toBe(1);
+        expect(mesh.getVertexIndex(t0, i)).toBe(3);
+    }
+
+});
+
+test("allocation increases size", () => {
+    const mesh = new TetrahedralMesh(1);
+
+    expect(mesh.size()).toBe(0);
+
+    mesh.allocate();
+
+    expect(mesh.size()).toBe(1);
+});
+
+test("remove method reduces size", () => {
+    const mesh = new TetrahedralMesh(1);
+
+    const tet = mesh.allocate();
+
+    expect(mesh.size()).toBe(1);
+
+    mesh.delete(tet);
+
+    expect(mesh.size()).toBe(0);
+});
+
+
+test("forEach visits all allocated tets", () => {
+    const mesh = new TetrahedralMesh();
+
+    const t0 = mesh.allocate();
+    const t1 = mesh.allocate();
+
+    const mock = jest.fn();
+
+    mesh.forEach(mock);
+
+    expect(mock).toHaveBeenCalledTimes(2);
+    expect(mock).toHaveBeenCalledWith(t0, mesh);
+    expect(mock).toHaveBeenCalledWith(t1, mesh);
+});
+
+test("'exists' method", () => {
+    const mesh = new TetrahedralMesh();
+
+    expect(mesh.exists(0)).toBe(false);
+
+    const tet = mesh.allocate();
+
+    expect(mesh.exists(tet)).toBe(true);
+    expect(mesh.exists(tet + 1)).toBe(false);
+
+    mesh.delete(tet);
+
+    expect(mesh.exists(tet)).toBe(false);
+    expect(mesh.exists(tet + 1)).toBe(false);
+});
+
+
+test("after calling 'removeTetrasConnectedToPoints' matching points are no logner indexed by live tetrahedrons", () => {
+
+
+    const tetrahedra = new TetrahedralMesh();
+
+    /*
+     * This "magic" mesh is a result of tetrahedral mesh generator with following input:  0, 0, 0, 10, 0, 0, 10, 0, 10, 0, 0, 10, 0, 10, 0,
+     * The mesh was generated on 27/10/2022
+     * It's a very small example with 21 total tets that was failing this test
+     *
+     */
+    tetrahedra.deserialize_base64('AAAAARUAAQAAAAAAAAAFAAAABgAAAAsAAAAUAAAAHwAAADQAAAADAAAABwAAAAUAAAAIAAAA/////yoAAABAAAAALgAAAAAAAAAFAAAABgAAAAgAAAD/////HAAAACgAAAAAAAAAAgAAAAUAAAAHAAAABgAAAP////8TAAAAFQAAACwAAAACAAAABgAAAAcAAAAIAAAA/////zwAAAAwAAAADQAAAAIAAAABAAAABQAAAAYAAAABAAAADgAAACAAAAA4AAAABAAAAAEAAAAGAAAACAAAAB0AAAAyAAAASQAAACEAAAABAAAAAAAAAAYAAAAIAAAACQAAABgAAABIAAAAAgAAAAQAAAACAAAABgAAAAEAAAAWAAAAGwAAACUAAAAzAAAABAAAAAMAAAACAAAAAQAAADsAAAAiAAAAUwAAAEYAAAADAAAABQAAAAAAAAAIAAAACgAAAEwAAAAFAAAANQAAAAMAAAAHAAAAAgAAAAUAAAAPAAAAOgAAAAcAAABEAAAABAAAAAYAAAACAAAACAAAABIAAAA+AAAAGQAAACMAAAADAAAAAQAAAAAAAAAFAAAAAwAAACsAAAA5AAAAUAAAAAMAAAACAAAAAQAAAAUAAAAXAAAANgAAAC0AAAAkAAAABAAAAAIAAAAHAAAACAAAABEAAABCAAAAMQAAAEUAAAAEAAAABwAAAAMAAAAIAAAABgAAAE4AAAA9AAAARwAAAAQAAAADAAAABwAAAAIAAAAvAAAAPwAAACcAAABDAAAABAAAAAAAAAABAAAACAAAAB4AAAAaAAAATQAAAFEAAAAEAAAAAwAAAAAAAAAIAAAAKQAAAEoAAABBAAAAUgAAAAQAAAADAAAAAQAAAAAAAAA3AAAASwAAAE8AAAAmAAAA');
+
+    tetrahedra.removeTetrasConnectedToPoints(5, 8);
+
+    //The mesh should contain only 5 vertices
+
+    tetrahedra.forEach((tet, mesh) => {
+
+        for (let i = 0; i < 4; i++) {
+            expect(mesh.getVertexIndex(tet, i)).toBeLessThan(5);
+        }
+
+    });
+});
+
+test('relocate operation copies tet data and updates back-links correctly', () => {
+    const mesh = new TetrahedralMesh();
+
+    const a = mesh.allocate();
+    const b = mesh.allocate();
+    const dest = mesh.allocate();
+
+    mesh.setVertexIndex(a, 0, 3);
+    mesh.setVertexIndex(a, 1, 7);
+    mesh.setVertexIndex(a, 2, 11);
+    mesh.setVertexIndex(a, 3, 13);
+
+    mesh.setNeighbour(a, 0, b << 2);
+    mesh.setNeighbour(b, 0, a << 2);
+
+    mesh.relocate(a, dest);
+
+    expect(mesh.getVertexIndex(dest, 0)).toBe(3);
+    expect(mesh.getVertexIndex(dest, 1)).toBe(7);
+    expect(mesh.getVertexIndex(dest, 2)).toBe(11);
+    expect(mesh.getVertexIndex(dest, 3)).toBe(13);
+
+    expect(mesh.getNeighbour(dest, 0)).toBe(b << 2);
+
+    // check back-link
+    expect(mesh.getNeighbour(b, 0)).toBe(dest << 2);
+});
+
+test('Compaction is non-destructive when moving resident data from the very end of the allocated region', () => {
+    const mesh = new TetrahedralMesh();
+
+    const a = mesh.allocate();
+    const b = mesh.allocate();
+
+    // force move "a" to free set
+    mesh.__free[mesh.__free_pointer++] = a;
+
+    expect(mesh.exists(b)).toBe(true);
+    expect(mesh.exists(a)).toBe(false);
+
+    mesh.compact();
+
+    expect(mesh.size()).toBe(1);
+
+    expect(mesh.exists(0)).toBe(true);
+    expect(mesh.exists(1)).toBe(false);
+});

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/compute_bounding_simplex_3d.js

@@ -156,7 +156,7 @@ export function compute_bounding_simplex_3d(
         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
+        SIMPLEX_PROJECTION_AXES[9], SIMPLEX_PROJECTION_AXES[10], SIMPLEX_PROJECTION_AXES[11], -min_d
     );
     plane_computeConvex3PlaneIntersection(
         result, result_offset + 3,
@@ -168,7 +168,7 @@ export function compute_bounding_simplex_3d(
         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
+        SIMPLEX_PROJECTION_AXES[6], SIMPLEX_PROJECTION_AXES[7], SIMPLEX_PROJECTION_AXES[8], -min_c
     );
     plane_computeConvex3PlaneIntersection(
         result, result_offset + 9,

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

@@ -22,10 +22,10 @@ test('planar containment, one point', () => {
 
     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);
+    expect(orient3d_fast(r, 2, 3, 1, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 0, 3, 2, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 0, 1, 3, 4)).toBeLessThan(0);
+    expect(orient3d_fast(r, 2, 1, 0, 4)).toBeLessThan(0);
 });
 
 test('positive padding results in larger simplex', () => {

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

@@ -1,16 +1,55 @@
+import { assert } from "../../../../assert.js";
+
 export class Cavity {
     constructor() {
         /**
          *
          * @type {number[]}
          */
-        this.indices = [];
+        this.__deleted = [];
+
+        /**
+         *
+         * @type {number}
+         */
+        this.__deleted_size = 0;
+
+        /**
+         * flat array of 5-tuples
+         * @type {number[]}
+         * @private
+         */
+        this.__boundary = [];
 
         /**
          *
          * @type {number}
+         * @private
          */
-        this.size = 0;
+        this.__boundary_size = 0;
+    }
+
+    /**
+     * Add boundary information
+     * @param vta
+     * @param node1
+     * @param node2
+     * @param node3
+     * @param bnd
+     */
+    push_boundary(vta, node1, node2, node3, bnd) {
+
+        const n = this.__boundary_size;
+
+        const n5 = n * 5;
+
+        this.__boundary[n5] = vta;
+        this.__boundary[n5 + 1] = node1;
+        this.__boundary[n5 + 2] = node2;
+        this.__boundary[n5 + 3] = node3;
+        this.__boundary[n5 + 4] = bnd;
+
+        this.__boundary_size++;
     }
 
     update() {
@@ -21,8 +60,10 @@ export class Cavity {
      *
      * @param {number} i
      */
-    push(i) {
-        this.indices[this.size++] = i;
+    push_deleted(i) {
+        assert.equal(this.includes(i), false, `ball element ${i} already exists`);
+
+        this.__deleted[this.__deleted_size++] = i;
     }
 
     /**
@@ -31,10 +72,10 @@ export class Cavity {
      * @returns {boolean}
      */
     includes(i) {
-        const n = this.size;
+        const n = this.__deleted_size;
 
         for (let j = 0; j < n; j++) {
-            if (this.indices[j] === i) {
+            if (this.__deleted[j] === i) {
                 return true;
             }
         }
@@ -43,6 +84,7 @@ export class Cavity {
     }
 
     reset() {
-        this.size = 0;
+        this.__deleted_size = 0;
+        this.__boundary_size = 0;
     }
 }

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

@@ -1,16 +1,35 @@
 //
 
 import { compute_bounding_simplex_3d } from "../compute_bounding_simplex_3d.js";
-import { TetrahedralMesh } from "../tetrahedra_collection.js";
+import { TetrahedralMesh } from "../TetrahedralMesh.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_cavity } from "./tetrahedral_mesh_compute_cavity.js";
+import { fill_in_a_cavity } from "./fill_in_a_cavity.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
@@ -20,39 +39,54 @@ 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 tetrahedrons = 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 tetrahedrons;
-    }
+    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 build_flags = BitSet.fixedSize(n);
+
     const points = new Float32Array((n + 4) * 3);
 
     points.set(input);
 
     /*
-     create super bounding volume
+     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();
+
+    mesh.setVertexIndex(super_tet, 0, n);
+    mesh.setVertexIndex(super_tet, 1, n + 1);
+    mesh.setVertexIndex(super_tet, 2, n + 2);
+    mesh.setVertexIndex(super_tet, 3, n + 3);
 
-    tetrahedrons.append(points, n, n + 1, n + 2, n + 3);
+    // debug_validate_mesh(mesh, points);
 
     // add all points to the mesh
+    let current_tet = 0;
+
     for (let i = 0; i < n; i++) {
-        tetrahedrons.insertPoint(points, i);
+
+        current_tet = tetrahedral_mesh_walk_towards_containing_tetrahedron(mesh, points, current_tet, i);
+
+        tetrahedral_mesh_compute_cavity(mesh, points, build_flags, CAVITY, current_tet, i);
+
+        current_tet = fill_in_a_cavity(mesh, points, build_flags, CAVITY, current_tet);
+
     }
 
     // remove tetras formed by with the super bounding volume
-    tetrahedrons.removeTetrasConnectedToPoints(points, n, n + 3);
+    mesh.removeTetrasConnectedToPoints(n, n + 3);
 
 
-    return tetrahedrons;
-}
+    // debug_validate_mesh(mesh, points);
 
+    return true;
+}
 

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

@@ -0,0 +1,19 @@
+import { validate_tetrahedral_mesh } from "../validate_tetrahedral_mesh.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|Float32Array} points
+ */
+export function debug_validate_mesh(mesh, points) {
+    const problems = [];
+
+    function add(x) {
+        problems.push(x);
+    }
+
+    if (!validate_tetrahedral_mesh(mesh, points, add)) {
+        debugger;
+        console.error(problems.join('\n'));
+    }
+}