@woosh/meep-engine 2.43.1 → 2.43.3

package/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_compute_sub_determinant.spec.js

@@ -0,0 +1,30 @@
+import { TetrahedralMesh } from "../TetrahedralMesh.js";
+import { tetrahedral_mesh_compute_sub_determinant } from "./tetrahedral_mesh_compute_sub_determinant.js";
+
+test("sanity test", () => {
+    const mesh = new TetrahedralMesh(1);
+
+    const tet = mesh.allocate();
+
+    mesh.setVertexIndex(tet, 0, 0);
+    mesh.setVertexIndex(tet, 1, 1);
+    mesh.setVertexIndex(tet, 2, 2);
+    mesh.setVertexIndex(tet, 3, 3);
+
+    const result = [];
+
+    const points = [
+        1, 2, 3,
+        4, 5, 6,
+        7, 8, 9,
+        10, 11, 12
+    ];
+
+    tetrahedral_mesh_compute_sub_determinant(result, 0, mesh, points, tet);
+
+    for (let i = 0; i < 4; i++) {
+        expect(typeof result[i]).toBe("number");
+        expect(result[i]).not.toBeNaN();
+    }
+
+});

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

@@ -0,0 +1,98 @@
+import { tetrahedral_mesh_compute_cavity } from "./tetrahedral_mesh_compute_cavity.js";
+import { assert } from "../../../../assert.js";
+import { Cavity } from "./Cavity.js";
+import { INVALID_NEIGHBOUR, LAYOUT_TETRA_BYTE_SIZE } from "../TetrahedralMesh.js";
+
+const SCRATCH_CAVITY = new Cavity();
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {number[]|Float32Array} points
+ * @param {number} index
+ */
+export function tetrahedral_mesh_insert_point(mesh, points, index) {
+    const debug_length_initial = mesh.__length;
+
+    // Compute the cavity, that is the set of tetrahedra that need to be removed and rebuilt
+    tetrahedral_mesh_compute_cavity(mesh, 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.__deleted_size;
+    const cavity_indices = SCRATCH_CAVITY.__deleted;
+
+    for (let i = 0; i < cavity_size; i++) {
+        const data = mesh.__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 = mesh.append(points, b, d, c, index);
+            // patch in neighbours
+            if (a_neighbour !== INVALID_NEIGHBOUR) {
+                mesh.setNeighbour(tet, 3, a_neighbour);
+                mesh.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 = mesh.append(points, c, d, a, index);
+            if (b_neighbour !== INVALID_NEIGHBOUR) {
+                mesh.setNeighbour(tet, 3, b_neighbour);
+                mesh.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 = mesh.append(points, d, b, a, index);
+            if (c_neighbour !== INVALID_NEIGHBOUR) {
+                mesh.setNeighbour(tet, 3, c_neighbour);
+                mesh.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 = mesh.append(points, a, b, c, index);
+            if (d_neighbour !== INVALID_NEIGHBOUR) {
+                mesh.setNeighbour(tet, 3, d_neighbour);
+                mesh.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
+        mesh.__occupancy.set(cavity_index, false);
+        mesh.__length--;
+    }
+
+    assert.greaterThan(mesh.__length, debug_length_initial, 'after insertion number of tetrahedra must grow, not shrink');
+}

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

@@ -1,4 +1,6 @@
 import { orient3d_fast } from "../../plane/orient3d_fast.js";
+import { assert } from "../../../../assert.js";
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
 
 /**
  * Walk from a given tetrahedron in the mesh towards tetrahedron that contains input point
@@ -7,12 +9,12 @@ import { orient3d_fast } from "../../plane/orient3d_fast.js";
  * @see https://git.immc.ucl.ac.be/hextreme/hxt_seqdel/-/blob/master/src/hxt_tetrahedra.c#L330
  * @see p3 "One machine, one minute, three billion tetrahedra" by Célestin Marot, Jeanne Pellerin, Jean-François Remacle
  * @param {TetrahedralMesh} mesh
- * @param {number[]} points
+ * @param {number[]|Float32Array} points
  * @param {number} current_tet
  * @param {number} current_vertex
  * @returns {number}
  */
-function tetrahedral_mesh_walk_toward_cavity(mesh, points, current_tet, current_vertex) {
+export function tetrahedral_mesh_walk_toward_cavity(mesh, points, current_tet, current_vertex) {
 
     let entering_face = 4;
 
@@ -28,19 +30,24 @@ function tetrahedral_mesh_walk_toward_cavity(mesh, points, current_tet, current_
             const b_i = (i & 2) ^ 3;
             const c_i = (i + 3) & 2;
 
-            const a_index = mesh.getCornerIndex(curTet, a_i);
-            const b_index = mesh.getCornerIndex(curTet, b_i);
-            const c_index = mesh.getCornerIndex(curTet, c_i);
+            const a_index = mesh.getVertexIndex(curTet, a_i);
+            const b_index = mesh.getVertexIndex(curTet, b_i);
+            const c_index = mesh.getVertexIndex(curTet, c_i);
 
             if (i !== entering_face && orient3d_fast(points, a_index, b_index, c_index, current_vertex) < 0.0) {
+                // point is outside the tet on the neighbour's side, move in that direction
                 const neighbour = mesh.getNeighbour(curTet, i);
-                curTet = neighbour >> 2;
+
+                assert.notEqual(neighbour, INVALID_NEIGHBOUR, 'walked outside of the mesh');
+
+                curTet = neighbour >>> 2;
                 entering_face = neighbour & 3;
                 break;
             }
         }
 
         if (i === 4) {
+            // point is inside the tet
             return curTet;
         }
     }

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

@@ -34,20 +34,20 @@ export function point_in_tetrahedron_circumsphere(
     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 bex = points[b3] - ex;
+    const bey = points[b3 + 1] - ey;
     const bez = points[b3 + 2] - ez;
+
+    const cex = points[c3] - ex;
+    const cey = points[c3 + 1] - ey;
     const cez = points[c3 + 2] - ez;
+
+    const dex = points[d3] - ex;
+    const dey = points[d3 + 1] - ey;
     const dez = points[d3 + 2] - ez;
 
     const aexbey = aex * bey;

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

@@ -10,7 +10,7 @@ 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";
+import { LAYOUT_TETRA_BYTE_SIZE } from "./TetrahedralMesh.js";
 
 /**
  *

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

@@ -0,0 +1,83 @@
+/**
+ * Compute signed volume of a tetrahedron with the last point at the origin
+ * @see "EFFICIENT FEATURE EXTRACTION FOR 2D/3D OBJECTS IN MESH REPRESENTATION" by Cha Zhang and Tsuhan Chen
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @return {number}
+ */
+function triangle_compute_signed_volume(
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+
+    const v321 = cx * by * az;
+    const v231 = bx * cy * az;
+    const v312 = cx * ay * bz;
+    const v132 = ax * cy * bz;
+    const v213 = bx * ay * cz;
+    const v123 = ax * by * cz;
+
+    return (1.0 / 6.0) * (-v321 + v231 + v312 - v132 - v213 + v123);
+
+}
+
+
+/**
+ * @see https://en.wikipedia.org/wiki/Tetrahedron
+ *
+ * @param {ArrayLike<number>|number[]|Float32Array} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @returns {number}
+ */
+export function tetrahedron_compute_signed_volume(points, a, b, c, d) {
+
+    const a3 = a * 3;
+    const b3 = b * 3;
+    const c3 = c * 3;
+    const d3 = d * 3;
+
+    const ax = points[a3];
+    const ay = points[a3 + 1];
+    const az = points[a3 + 2];
+
+    const bx = points[b3];
+    const by = points[b3 + 1];
+    const bz = points[b3 + 2];
+
+    const cx = points[c3];
+    const cy = points[c3 + 1];
+    const cz = points[c3 + 2];
+
+    const dx = points[d3];
+    const dy = points[d3 + 1];
+    const dz = points[d3 + 2];
+
+    const adx = ax - dx;
+    const ady = ay - dy;
+    const adz = az - dz;
+
+    const bdx = bx - dx;
+    const bdy = by - dy;
+    const bdz = bz - dz;
+
+    const cdx = cx - dx;
+    const cdy = cy - dy;
+    const cdz = cz - dz;
+
+    return triangle_compute_signed_volume(
+        adx, ady, adz,
+        bdx, bdy, bdz,
+        cdx, cdy, cdz
+    );
+}

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

@@ -0,0 +1,24 @@
+import { tetrahedron_compute_signed_volume } from "./tetrahedron_compute_signed_volume.js";
+
+test("0 volume", () => {
+    expect(tetrahedron_compute_signed_volume([
+        0, 0, 0
+    ], 0, 0, 0, 0)).toBe(0);
+});
+
+test("positive volume", () => {
+
+    expect(tetrahedron_compute_signed_volume([
+        1, 0, 1,
+        1, 0, 0,
+        0, 0, 0,
+        1, 1, 1
+    ], 1, 2, 3, 0)).toBeGreaterThan(0);
+
+    expect(tetrahedron_compute_signed_volume([
+        0, 0, 0,
+        2, 0, 0,
+        0, 2, 0,
+        0, 0, 2
+    ], 1, 2, 3, 0)).toBeGreaterThan(0);
+})

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

@@ -0,0 +1,66 @@
+import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
+
+test("basic containment", () => {
+    const tetrahedron = [
+        1, 0, 1,
+        1, 0, 0,
+        0, 0, 0,
+        1, 1, 1
+    ];
+
+    expect(
+        tetrahedron_contains_point([
+            ...tetrahedron,
+            //
+            0.5, 0.1, 0.5
+        ], 0, 1, 2, 3, 4)
+    ).toBe(true);
+
+    expect(
+        tetrahedron_contains_point([
+            ...tetrahedron,
+            //
+            -1, 0, 0
+        ], 0, 1, 2, 3, 4)
+    ).toBe(false);
+
+    expect(
+        tetrahedron_contains_point([
+            ...tetrahedron,
+            //
+            2, 0, 0
+        ], 0, 1, 2, 3, 4)
+    ).toBe(false);
+
+    expect(
+        tetrahedron_contains_point([
+            ...tetrahedron,
+            //
+            0, -1, 0
+        ], 0, 1, 2, 3, 4)
+    ).toBe(false);
+
+    expect(
+        tetrahedron_contains_point([
+            ...tetrahedron,
+            //
+            0, 2, 0
+        ], 0, 1, 2, 3, 4)
+    ).toBe(false);
+
+    expect(
+        tetrahedron_contains_point([
+            ...tetrahedron,
+            //
+            0, 0, -1
+        ], 0, 1, 2, 3, 4)
+    ).toBe(false);
+
+    expect(
+        tetrahedron_contains_point([
+            ...tetrahedron,
+            //
+            0, 0, 2
+        ], 0, 1, 2, 3, 4)
+    ).toBe(false);
+});

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

@@ -0,0 +1,119 @@
+import { tetrahedron_compute_signed_volume } from "./tetrahedron_compute_signed_volume.js";
+import { noop } from "../../../function/Functions.js";
+import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|number[]} points
+ * @param {number} tet
+ * @return {number}
+ */
+function get_tetrahedron_volume(mesh, points, 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);
+
+    return tetrahedron_compute_signed_volume(points, a, b, c, d);
+}
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {number} tet
+ * @param {function(problem:string):*} consumer
+ */
+function validate_tetrahedron_neighbourhood(mesh, tet, consumer = noop) {
+    let valid = true;
+
+    for (let i = 0; i < 4; i++) {
+        const neighbour = mesh.getNeighbour(tet, i);
+
+        if (neighbour === INVALID_NEIGHBOUR) {
+            continue;
+        }
+
+        // decode neighbour
+        const neighbour_tet = neighbour >> 2;
+        const neighbour_vertex_id = neighbour & 3;
+
+        if (!mesh.exists(neighbour_tet)) {
+            valid = false;
+
+            consumer(`Tetrahedron ${tet} Neighbour[${i}] ${neighbour_tet} does not exist in the mesh`);
+
+            continue;
+        }
+
+        const back_link = mesh.getNeighbour(neighbour_tet, neighbour_vertex_id);
+
+        if (back_link === INVALID_NEIGHBOUR) {
+            valid = false;
+            consumer(`Tetrahedron ${tet} Neighbour[${i}] ${neighbour_tet} links back to invalid neighbour (no neighbour), expected ${tet} instead`);
+            continue;
+        }
+
+        const back_link_tet = back_link >> 2;
+        const back_link_vertex_index = back_link & 3;
+
+        if (back_link_tet !== tet) {
+            valid = false;
+
+            consumer(`Tetrahedron ${tet} Neighbour[${i}] ${neighbour_tet} links back to a different tet, expected ${tet}, got ${back_link_tet}`)
+        } else if (back_link_vertex_index !== i) {
+            valid = false;
+
+            consumer(`Tetrahedron ${tet} Neighbour[${i}] ${neighbour_tet} links back to a different vertex, expected ${i}, got ${back_link_vertex_index}`);
+
+        }
+
+        for (let j = 0; j < 4; j++) {
+            const v = mesh.getVertexIndex(tet, j);
+
+            if (j === i) {
+                continue;
+            }
+
+            if (!mesh.tetContainsVertex(neighbour_tet, v)) {
+                valid = false;
+
+                consumer(`Tetrahedron ${tet} Neighbour[${i}] ${neighbour_tet} does not share vertex ${v} with the tet`);
+
+            }
+        }
+
+    }
+
+    return valid;
+}
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>} points
+ * @param {(problem:string)=>*} [consumer]
+ * @returns {boolean}
+ */
+export function validate_tetrahedral_mesh(mesh, points, consumer = noop) {
+    let is_valid = true;
+
+    mesh.forEach((tet, mesh) => {
+
+        const volume = get_tetrahedron_volume(mesh, points, tet);
+        if (volume < 0) {
+            is_valid = false;
+
+            consumer(`Tetrahedron ${tet} has negative volume ${volume}`);
+        }
+
+        if (!validate_tetrahedron_neighbourhood(mesh, tet, consumer)) {
+            is_valid = false;
+        }
+
+    });
+
+
+    return is_valid;
+}

package/core/geom/Bezier.js

@@ -1,30 +1,3 @@
-import Vector3 from "./Vector3.js";
-
-export function Bezier() {
-
-}
-
-Bezier.computeQuadratic = (function () {
-    const a = new Vector3();
-
-    function computeQuadratic(p0, p1, p2, t, result) {
-        const minus = 1 - t;
-        const minus2 = minus * minus;
-
-        result.copy(p0).multiplyScalar(minus2);
-
-        a.copy(p1).multiplyScalar(minus * 2 * t);
-        result.add(a);
-
-        a.copy(p2).multiplyScalar(t * t);
-        result.add(a);
-
-    }
-
-    return computeQuadratic;
-})();
-
-
 /**
  *
  * @param {Vector2} result

package/core/geom/Plane.js

@@ -5,10 +5,6 @@
 
 import { v3_dot } from "./v3_dot.js";
 
-function Plane() {
-
-}
-
 /**
 
  Algorithm taken from http://geomalgorithms.com/a05-_intersect-1.html. See the

package/core/geom/packing/miniball/Subspan.js

@@ -40,13 +40,13 @@ export class Subspan {
 
         /**
          * DxD square matrix, where D is number of dimensions
-         * @type {[]}
+         * @type {number[][]}
          */
         this.Q = null;
 
         /**
          * DxD square matrix, where D is number of dimensions
-         * @type {[]}
+         * @type {number[][]}
          */
         this.R = null;
 

package/core/geom/v3_lerp.js

@@ -11,7 +11,12 @@ import { lerp } from "../math/lerp.js";
  * @param {number} b_z
  * @param {number} fraction
  */
-export function v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction) {
+export function v3_lerp(
+    result,
+    a_x, a_y, a_z,
+    b_x, b_y, b_z,
+    fraction
+) {
 
     const x = lerp(a_x, b_x, fraction);
     const y = lerp(a_y, b_y, fraction);

package/core/math/isqrt.js

@@ -0,0 +1,28 @@
+/**
+ * Integer square root
+ *
+ * @author Jim Ulery (attributed on hextreme)
+ * @see https://en.wikipedia.org/wiki/Integer_square_root
+ * @see https://git.immc.ucl.ac.be/hextreme/hxt_seqdel/-/blob/master/src/hxt_tetrahedra.c#L54
+ *
+ * @param {number} input
+ * @returns {number}
+ */
+export function isqrt(input) {
+    let temp;
+
+    let g = 0;
+    let b = 0x8000;
+    let bshft = 15;
+
+    let val = input;
+
+    do {
+        if (val >= (temp = (((g << 1) + b) << bshft--))) {
+            g += b;
+            val -= temp;
+        }
+    } while (b >>= 1);
+
+    return g;
+}

package/core/math/isqrt.spec.js

@@ -0,0 +1,9 @@
+import { isqrt } from "./isqrt.js";
+
+test('1', () => {
+    expect(isqrt(1)).toBe(1);
+});
+
+test('4', () => {
+    expect(isqrt(4)).toBe(2);
+});

package/core/math/max.spec.js

@@ -0,0 +1,25 @@
+import { max2 } from "./max2.js";
+
+test("0,0", () => {
+    expect(max2(0, 0)).toBe(0);
+});
+
+test("0,1", () => {
+    expect(max2(0, 1)).toBe(1);
+});
+
+test("1,0", () => {
+    expect(max2(1, 0)).toBe(1);
+});
+
+test("-1,0", () => {
+    expect(max2(-1, 0)).toBe(0);
+});
+
+test("0,-1", () => {
+    expect(max2(0, -1)).toBe(0);
+});
+
+test("Infinity,-Infinity", () => {
+    expect(max2(Infinity, -Infinity)).toBe(Infinity);
+});

package/core/math/min2.spec.js

@@ -0,0 +1,25 @@
+import { min2 } from "./min2.js";
+
+test("0,0", () => {
+    expect(min2(0, 0)).toBe(0);
+});
+
+test("0,1", () => {
+    expect(min2(0, 1)).toBe(0);
+});
+
+test("1,0", () => {
+    expect(min2(1, 0)).toBe(0);
+});
+
+test("-1,0", () => {
+    expect(min2(-1, 0)).toBe(-1);
+});
+
+test("0,-1", () => {
+    expect(min2(0, -1)).toBe(-1);
+});
+
+test("Infinity,-Infinity", () => {
+    expect(min2(Infinity, -Infinity)).toBe(-Infinity);
+});