@woosh/meep-engine 2.43.1 → 2.43.4

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

@@ -1,140 +0,0 @@
-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/tetrahedra_collection.js

@@ -1,383 +0,0 @@
-import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
-import { assert } from "../../../assert.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}
- */
-export const LAYOUT_TETRA_BYTE_SIZE = 9 * 4;
-
-/**
- * @readonly
- * @type {number}
- */
-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 :: 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 TetrahedralMesh {
-    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);
-    }
-
-    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
-     * @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);
-
-        //assert(this.validateLength());
-
-        this.__occupancy.set(tetra_index, true);
-
-        this.__length++;
-
-        // assert(this.validateLength());
-
-        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);
-        }
-
-        //assert(this.validateLength());
-
-        // mark as dead
-        this.__occupancy.clear(tera_index);
-        this.__length--;
-
-        //assert(this.validateLength());
-    }
-
-    /**
-     * 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 j = 0;
-
-        const occupancy = this.__occupancy;
-        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 * j);
-
-                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 {number} tet_index
-     * @param {number} point_index should be an integer between 0 and 3
-     * @returns {number}
-     */
-    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
-        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;
-
-        for (let i = 0; i < cavity_size; i++) {
-            const data = this.__view;
-
-            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);
-            this.__length--;
-        }
-
-        assert.greaterThan(this.__length, debug_length_initial, 'after insertion number of tetrahedra must grow, not shrink')
-    }
-
-    /**
-     * 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');
-    }
-}