@woosh/meep-engine 2.42.7 → 2.43.0

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

@@ -0,0 +1,140 @@
+import hxt_wasm from "./hxt.wasm";
+import { min2 } from "../../../../math/min2.js";
+import { max2 } from "../../../../math/max2.js";
+
+var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+function updateGlobalBufferAndViews(buf) {
+    buffer = buf;
+    HEAP8 = new Int8Array(buf);
+    HEAP16 = new Int16Array(buf);
+    HEAP32 = new Int32Array(buf);
+    HEAPU8 = new Uint8Array(buf);
+    HEAPU16 = new Uint16Array(buf);
+    HEAPU32 = new Uint32Array(buf);
+    HEAPF32 = new Float32Array(buf);
+    HEAPF64 = new Float64Array(buf)
+}
+
+let instance;
+
+function emscripten_realloc_buffer(size) {
+    try {
+        wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);
+        updateGlobalBufferAndViews(wasmMemory.buffer);
+        return 1
+    } catch (e) {
+    }
+}
+
+function _emscripten_resize_heap(requestedSize) {
+    var oldSize = HEAPU8.length;
+    requestedSize = requestedSize >>> 0;
+    var maxHeapSize = getHeapMax();
+    if (requestedSize > maxHeapSize) {
+        return false
+    }
+    let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;
+    for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+        var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+        overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+        var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));
+        var replacement = emscripten_realloc_buffer(newSize);
+        if (replacement) {
+            return true
+        }
+    }
+    return false
+}
+
+function _emscripten_memcpy_big(dest, src, num) {
+    HEAPU8.copyWithin(dest, src, src + num)
+}
+
+function _fd_close(fd) {
+    return 52
+}
+
+function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+    return 70
+}
+
+function _fd_write(fd, iov, iovcnt, pnum) {
+    var num = 0;
+    for (var i = 0; i < iovcnt; i++) {
+        var ptr = HEAPU32[iov >> 2];
+        var len = HEAPU32[iov + 4 >> 2];
+        iov += 8;
+        for (var j = 0; j < len; j++) {
+            printChar(fd, HEAPU8[ptr + j])
+        }
+        num += len
+    }
+    HEAPU32[pnum >> 2] = num;
+    return 0
+}
+
+var asmLibraryArg = {
+    "e": _emscripten_memcpy_big,
+    "b": _emscripten_resize_heap,
+    "d": _fd_close,
+    "a": _fd_seek,
+    "c": _fd_write
+};
+
+/**
+ *
+ * @param {number[]} _points
+ * @param {number} n
+ * @return {Promise<void>}
+ */
+export async function hxt(_points, n) {
+
+    if (instance === undefined) {
+        var info = { "a": asmLibraryArg };
+
+        updateGlobalBufferAndViews(new ArrayBuffer(4 * 1024 * 1024));
+
+        const response = await fetch(hxt_wasm);
+        const bytes = await response.arrayBuffer();
+
+        const module = await WebAssembly.instantiate(bytes, info);
+
+        instance = module.instance;
+    }
+
+    /*
+
+	double* points, // x0, y0, z0, x1,y1,z1, ...
+	uint32_t point_count, // number of points in the input buffer
+	double* bbox, //6 floats: min_x, min_y, min_z, max_x, max_y, max_z
+	LinkedTetrahedron* output
+
+     */
+
+    const points = new Float64Array(_points);
+
+    const bbox = new Float64Array(6);
+
+    for (let i = 0; i < n; i++) {
+
+        const x = points[i * 3];
+        const y = points[i * 3 + 1];
+        const z = points[i * 3 + 2];
+
+        bbox[0] = min2(x, bbox[0]);
+        bbox[1] = min2(y, bbox[1]);
+        bbox[2] = min2(z, bbox[2]);
+
+        bbox[3] = max2(x, bbox[3]);
+        bbox[4] = max2(y, bbox[4]);
+        bbox[5] = max2(z, bbox[5]);
+
+    }
+
+    const output_tets = new Uint8Array(10 * 1024 * 1024);
+
+    const out_tet_count = instance.exports["h"](points, n, bbox, output_tets);
+
+    console.log(out_tet_count);
+}

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

@@ -16,38 +16,52 @@
  * @param {number} b tetrahedral point index
  * @param {number} c tetrahedral point index
  * @param {number} d tetrahedral point index
- * @param {number} e reference point index
+ * @param {number} e reference point index that we are testing against the tetrahedron
  * @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;
+export function point_in_tetrahedron_circumsphere(
+    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 ex = points[e3];
+    const ey = points[e3 + 1];
+    const ez = points[e3 + 2];
+
+
+    const aex = points[a3] - ex;
+    const bex = points[b3] - ex;
+    const cex = points[c3] - ex;
+    const dex = points[d3] - ex;
+
+    const aey = points[a3 + 1] - ey;
+    const bey = points[b3 + 1] - ey;
+    const cey = points[c3 + 1] - ey;
+    const dey = points[d3 + 1] - ey;
+
+    const aez = points[a3 + 2] - ez;
+    const bez = points[b3 + 2] - ez;
+    const cez = points[c3 + 2] - ez;
+    const dez = points[d3 + 2] - 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;
@@ -55,6 +69,7 @@ export function point_in_tetrahedron_circumsphere(points, a, b, c, d, e) {
     const aexcey = aex * cey;
     const cexaey = cex * aey;
     const ac = aexcey - cexaey;
+
     const bexdey = bex * dey;
     const dexbey = dex * bey;
     const bd = bexdey - dexbey;

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

@@ -0,0 +1,98 @@
+import { EngineHarness } from "../../../../engine/EngineHarness.js";
+import { compute_delaunay_tetrahedral_mesh } from "./delaunay/compute_delaunay_tetrahedral_mesh.js";
+import { LineBasicMaterial, Uint32BufferAttribute } from "three";
+import { BufferGeometry } from "three/src/core/BufferGeometry.js";
+import { Float32BufferAttribute } from "three/src/core/BufferAttribute.js";
+import { ShadedGeometry } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { DrawMode } from "../../../../engine/graphics/ecs/mesh-v2/DrawMode.js";
+import EntityBuilder from "../../../../engine/ecs/EntityBuilder.js";
+import { Transform } from "../../../../engine/ecs/transform/Transform.js";
+import { ShadedGeometrySystem } from "../../../../engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import { GizmoRenderingPlugin } from "../../../../engine/graphics/render/gizmo/GizmoRenderingPlugin.js";
+import { Gizmo } from "../../../../engine/graphics/render/gizmo/Gizmo.js";
+import { LAYOUT_TETRA_BYTE_SIZE } from "./tetrahedra_collection.js";
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine,
+        enableWater: false
+    });
+
+    const offset = [7.5, 1, 7.5];
+    const scale = [.5, .5, .5];
+
+    const points = [
+        0, 0, 0,
+        10, 0, 0,
+        10, 0, 10,
+        0, 0, 10,
+
+        0, 10, 0,
+        10, 10, 0,
+        10, 10, 10,
+        0, 10, 10,
+    ];
+
+    const tetrahedra = compute_delaunay_tetrahedral_mesh(points, points.length / 3);
+
+    const lines = [];
+
+    for (let i = tetrahedra.__occupancy.nextSetBit(0); i !== -1; i = tetrahedra.__occupancy.nextSetBit(i + 1)) {
+
+        const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
+
+        const a = tetrahedra.__view.getUint32(tet_address);
+        const b = tetrahedra.__view.getUint32(tet_address + 4);
+        const c = tetrahedra.__view.getUint32(tet_address + 8);
+        const d = tetrahedra.__view.getUint32(tet_address + 12);
+
+        lines.push(a, b);
+        lines.push(a, c);
+        lines.push(a, d);
+
+        lines.push(b, c);
+        lines.push(c, d);
+        lines.push(b, d);
+
+    }
+
+    const geometry = new BufferGeometry();
+
+    geometry.setIndex(new Uint32BufferAttribute(lines, 1, false));
+    geometry.setAttribute('position', new Float32BufferAttribute(points, 3, false));
+
+
+    new EntityBuilder()
+        .add(ShadedGeometry.from(geometry, new LineBasicMaterial({ color: 0xFF0000 }), DrawMode.LineSegments))
+        .add(Transform.fromJSON({
+            position: { x: offset[0], y: offset[1], z: offset[2] },
+            scale: { x: scale[0], y: scale[1], z: scale[2] },
+        }))
+        .build(engine.entityManager.dataset);
+
+    engine.graphics.on.preRender.add(() => {
+
+        Gizmo.color = [1, 1, 1, 1];
+
+        for (let i = 0; i < points.length; i += 3) {
+
+            Gizmo.draw_solid_sphere([
+                points[i] * scale[0] + offset[0],
+                points[i + 1] * scale[1] + offset[1],
+                points[i + 2] * scale[2] + offset[2]
+            ], 0.1);
+        }
+    });
+}
+
+new EngineHarness().initialize({
+    configuration(config, engine) {
+        config.addSystem(new ShadedGeometrySystem(engine));
+        config.addPlugin(GizmoRenderingPlugin);
+    }
+}).then(main);

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

@@ -1,83 +1,44 @@
 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";
+import { Cavity } from "./delaunay/Cavity.js";
+import { tetrahedral_mesh_compute_cavity } from "./delaunay/tetrahedral_mesh_compute_cavity.js";
 
 /**
+ * Size in bytes of a single tetrahedron record
  * @readonly
  * @type {number}
  */
-const LAYOUT_TETRA_BYTE_SIZE = 9 * 4;
+export 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;
-    }
-}
+export const INVALID_NEIGHBOUR = 0xFFFFFFFF;
 
 const SCRATCH_CAVITY = new Cavity();
 
 /**
- *
+ * Only keeps track of tetrahedra, actual point coordinates are stored outside. For most useful operations point coordinates are passed in
  * 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
+ *      vertex_id_a :: uint32
+ *      vertex_id_b :: uint32
+ *      vertex_id_c :: uint32
+ *      vertex_id_d :: uint32
+ *      neighbour_a :: uint32         - neighbour tetrahedron, opposite to vertex A
+ *      neighbour_b :: uint32         - neighbour tetrahedron, opposite to vertex B
+ *      neighbour_c :: uint32         - neighbour tetrahedron, opposite to vertex C
+ *      neighbour_d :: uint32         - neighbour tetrahedron, opposite to vertex D
  *      sub_determinant :: float    - ?
  * Layout is similar to [1], but is interleaved for better cache locality
+ *
+ * @see [1] 2018 "One machine, one minute, three billion tetrahedra" by Célestin Marot,  Jeanne Pellerin and Jean-François Remacle
+ * @see https://git.immc.ucl.ac.be/hextreme/hxt_seqdel (C source code for [1])
  */
-export class TetrahedraCollection {
+export class TetrahedralMesh {
     constructor(initial_size) {
         this.__buffer = new ArrayBuffer(initial_size * LAYOUT_TETRA_BYTE_SIZE);
 
@@ -160,6 +121,24 @@ export class TetrahedraCollection {
         return this.__view.setUint32(tetra_address + (4 + neighbour_index) * 4, neighbour);
     }
 
+    validateLength() {
+        return this.countOccupancy() === this.__length;
+    }
+
+    /**
+     * Counts number of occupied(used) elements in the pool
+     * Should be the same as __length
+     * @return {number}
+     */
+    countOccupancy() {
+        let r = 0;
+        for (let i = this.__occupancy.nextSetBit(0); i !== -1; i = this.__occupancy.nextSetBit(i + 1)) {
+            r++;
+        }
+
+        return r;
+    }
+
     /**
      *
      * @param {number[]|Float32Array} points
@@ -191,10 +170,14 @@ export class TetrahedraCollection {
         view.setUint32(address + 24, INVALID_NEIGHBOUR);
         view.setUint32(address + 28, INVALID_NEIGHBOUR);
 
+        //assert(this.validateLength());
+
         this.__occupancy.set(tetra_index, true);
 
         this.__length++;
 
+        // assert(this.validateLength());
+
         return tetra_index;
     }
 
@@ -221,9 +204,13 @@ export class TetrahedraCollection {
             this.setNeighbour(neighbour_index, neighbour_point, INVALID_NEIGHBOUR);
         }
 
+        //assert(this.validateLength());
+
         // mark as dead
         this.__occupancy.clear(tera_index);
         this.__length--;
+
+        //assert(this.validateLength());
     }
 
     /**
@@ -236,16 +223,15 @@ export class TetrahedraCollection {
     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)) {
+        for (let 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);
+                const point_index = data_view.getUint32(tet_address + 4 * j);
 
                 if (point_index >= range_start && point_index <= range_end) {
                     // point index is in range, tetra should be removed
@@ -286,94 +272,34 @@ export class TetrahedraCollection {
 
     /**
      *
-     * @param {Cavity} cavity
-     * @param {number[]|Float32Array} points
-     * @param {number} index
+     * @param {number} tet_index
+     * @param {number} point_index should be an integer between 0 and 3
+     * @returns {number}
      */
-    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);
-                }
-
-
-            }
-        }
+    getCornerIndex(tet_index, point_index) {
+        return this.__view.getUint32(tet_index * LAYOUT_TETRA_BYTE_SIZE + point_index * 4);
     }
 
+
     /**
      *
      * @param {number[]|Float32Array} points
      * @param {number} index
      */
     insertPoint(points, index) {
+        const debug_length_initial = this.__length;
+
         // Compute the cavity, that is the set of tetrahedra that need to be removed and rebuilt
-        this.computeCavity(SCRATCH_CAVITY, points, index);
+        tetrahedral_mesh_compute_cavity(this, 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 data = this.__view;
+
             const cavity_index = cavity_indices[i];
 
             // take each side of the tetra
@@ -440,7 +366,10 @@ export class TetrahedraCollection {
 
             // clear out cavity, connectivity was already patched in the previous step
             this.__occupancy.set(cavity_index, false);
+            this.__length--;
         }
+
+        assert.greaterThan(this.__length, debug_length_initial, 'after insertion number of tetrahedra must grow, not shrink')
     }
 
     /**