@woosh/meep-engine 2.163.11 → 2.164.0

package/src/core/geom/3d/tetrahedra/delaunay/fill_in_a_cavity.js

@@ -1,166 +1,7 @@
-import { assert } from "../../../../assert.js";
-import { array_copy } from "../../../../collection/array/array_copy.js";
-import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
-
-/**
- *
- * @param {TetrahedralMesh} mesh
- * @param {ArrayLike<number>|number[]|Float32Array} points
- * @param {BitSet} visited_flags
- * @param {Cavity} cavity
- * @returns {number} new current tet
- */
-export function fill_in_a_cavity(mesh, points, visited_flags, cavity) {
-
-    let clength = cavity.__deleted_size; // cavity size
-    const blength = cavity.__boundary_size; // boundary size
-
-    assert.equal(blength & 1, 0, 'there is always a pair number of triangle on the boundary. N points, 2N triangle, 3N edges');
-
-    /*
-    Re-use tets that would be deleted, if there are not enough dead tets - allocate new ones as necessary
-     */
-    const deleted_tets = cavity.__deleted;
-    if (blength > clength) {
-
-        for (let i = clength; i < blength; i++) {
-            // allocate tets for the cavity filling, remember them inside the "deleted" set for now
-            deleted_tets[i] = mesh.allocate();
-        }
-
-        clength = blength;
-    }
-
-    const boundary = cavity.__boundary;
-    const start = clength - blength;
-
-    for (let i = 0; i < blength; i++) {
-        // go over the faces in the cavity boundary and matching tet that will be filling the space
-
-        const current_tet_index = deleted_tets[i + start];
-
-        const i5 = i * 5;
-
-        // write filling tet's corners
-        mesh.setVertexIndex(current_tet_index, 0, boundary[i5]); // "ball"/cavity center point is written here
-        mesh.setVertexIndex(current_tet_index, 1, boundary[i5 + 1]);
-        mesh.setVertexIndex(current_tet_index, 2, boundary[i5 + 2]);
-        mesh.setVertexIndex(current_tet_index, 3, boundary[i5 + 3]);
-
-        const encoded_boundary_tet = boundary[i5 + 4];
-
-        mesh.setNeighbour(current_tet_index, 0, encoded_boundary_tet); // connect opposing neighbour
-
-        const encoded_current_tet = current_tet_index << 2;
-
-        if (encoded_boundary_tet !== INVALID_NEIGHBOUR) {
-            // update neighbour
-            mesh.setNeighbour(encoded_boundary_tet >> 2, encoded_boundary_tet & 3, encoded_current_tet);
-        }
-
-        // boundary[i5 + 4] = encoded_current_tet;
-
-        visited_flags.set(current_tet_index, false); // clear flag
-    }
-
-    computeAdjecencies(mesh, cavity, start, blength);
-
-
-    for (let i = 0; i < start; i++) {
-        // cleanup any orphaned tets that we didn't re-use
-        mesh.delete(deleted_tets[i]);
-    }
-
-    // debug_validate_mesh(mesh, points);
-
-    cavity.__boundary_size = 0;
-    cavity.__deleted_size = 0;
-
-    /*
-    Pick a tet from the created ball, it will generally be a good guess for next point
-     */
-    return deleted_tets[start];
-
-}
-
-
-/**
- * filling back the cavity
- * N+2 point on the surface of the cavity
- * 2N triangle on the surface of the cavity, x3 (4*0.5+1) data = 6N+9 uint64_t
- * => enough place for the 3N edge x2 data = 6N uint64_t
- * @param {TetrahedralMesh} mesh
- * @param {Cavity} cavity
- * @param {number} start
- * @param {number} boundary_length
- */
-function computeAdjecencies(mesh, cavity, start, boundary_length) {
-    const boundary = cavity.__boundary;
-
-    let tlength = 0;
-
-    const Tmp = boundary; // we know there is enough space...
-
-    for (let i = 0; i < boundary_length; i++) {
-
-        const cur_tet = cavity.__deleted[start + i];
-
-        // pointer to the position of Node[0] in the Tmp array
-
-        for (let j = 0; j < 3; j++) {
-
-            // define the edge by the minimum vertex and the other
-            const index_0 = (j + 1) % 3 + 1;
-            const index_1 = (j + 2) % 3 + 1;
-
-            const n0 = mesh.getVertexIndex(cur_tet, index_0);
-            const n1 = mesh.getVertexIndex(cur_tet, index_1);
-
-            const current_tet_neighbour_id = j + 1;
-            const encoded_current_tet = (cur_tet << 2) | (current_tet_neighbour_id & 3);
-
-            // linear searching/pushing into Tmp
-            let k = 0;
-            for (; k < tlength; k++) {
-                // this is the only nested loop... the one that cost it all
-
-                if (Tmp[k * 3] === n0 && Tmp[k * 3 + 1] === n1)
-                    // found a match, stop here
-                    break;
-            }
-
-            if (k === tlength) {
-                // we did not find it
-                const offset = tlength * 3;
-
-                // flip the edge order and store it. Neighbouring tet will have edge order reversed
-                Tmp[offset] = n1;
-                Tmp[offset + 1] = n0;
-
-                Tmp[offset + 2] = encoded_current_tet;
-
-                tlength++;
-            } else {
-                // we found the neighbour !
-                const encoded_neighbour = Tmp[k * 3 + 2];
-
-                mesh.setNeighbour(cur_tet, current_tet_neighbour_id, encoded_neighbour);
-                mesh.setNeighbour(encoded_neighbour >> 2, encoded_neighbour & 3, encoded_current_tet);
-
-                // reduce search space, there can only be one neighbour pair, after it's found we can remove the entry from lookup table
-                tlength--;
-
-                if (k < tlength) {
-                    // put the last entry in the one we just discovered
-                    array_copy(Tmp, tlength * 3, Tmp, k * 3, 3);
-                }
-            }
-        }
-    }
-
-    assert.equal(tlength, 0, 'Failed to compute adjacencies');
-
-    // if (!validate_patched_ball_adjacencies(mesh, cavity.__deleted, start, boundary_length, console.error)) {
-    //     debugger;
-    // }
-}
+import { tetrahedral_mesh_fill_cavity } from "./tetrahedral_mesh_fill_cavity.js";
+
+/**
+ * @deprecated Renamed to {@link tetrahedral_mesh_fill_cavity}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const fill_in_a_cavity = tetrahedral_mesh_fill_cavity;

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_fill_cavity.d.ts

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|number[]|Float32Array} points
+ * @param {BitSet} visited_flags
+ * @param {Cavity} cavity
+ * @returns {number} new current tet
+ */
+export function tetrahedral_mesh_fill_cavity(mesh: TetrahedralMesh, points: ArrayLike<number> | number[] | Float32Array, visited_flags: BitSet, cavity: Cavity): number;
+//# sourceMappingURL=tetrahedral_mesh_fill_cavity.d.ts.map

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_fill_cavity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_mesh_fill_cavity.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_fill_cavity.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,4EALW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,0CAGrC,MAAM,CAyElB"}

package/src/core/geom/3d/tetrahedra/delaunay/tetrahedral_mesh_fill_cavity.js

@@ -0,0 +1,166 @@
+import { assert } from "../../../../assert.js";
+import { array_copy } from "../../../../collection/array/array_copy.js";
+import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|number[]|Float32Array} points
+ * @param {BitSet} visited_flags
+ * @param {Cavity} cavity
+ * @returns {number} new current tet
+ */
+export function tetrahedral_mesh_fill_cavity(mesh, points, visited_flags, cavity) {
+
+    let clength = cavity.__deleted_size; // cavity size
+    const blength = cavity.__boundary_size; // boundary size
+
+    assert.equal(blength & 1, 0, 'there is always a pair number of triangle on the boundary. N points, 2N triangle, 3N edges');
+
+    /*
+    Re-use tets that would be deleted, if there are not enough dead tets - allocate new ones as necessary
+     */
+    const deleted_tets = cavity.__deleted;
+    if (blength > clength) {
+
+        for (let i = clength; i < blength; i++) {
+            // allocate tets for the cavity filling, remember them inside the "deleted" set for now
+            deleted_tets[i] = mesh.allocate();
+        }
+
+        clength = blength;
+    }
+
+    const boundary = cavity.__boundary;
+    const start = clength - blength;
+
+    for (let i = 0; i < blength; i++) {
+        // go over the faces in the cavity boundary and matching tet that will be filling the space
+
+        const current_tet_index = deleted_tets[i + start];
+
+        const i5 = i * 5;
+
+        // write filling tet's corners
+        mesh.setVertexIndex(current_tet_index, 0, boundary[i5]); // "ball"/cavity center point is written here
+        mesh.setVertexIndex(current_tet_index, 1, boundary[i5 + 1]);
+        mesh.setVertexIndex(current_tet_index, 2, boundary[i5 + 2]);
+        mesh.setVertexIndex(current_tet_index, 3, boundary[i5 + 3]);
+
+        const encoded_boundary_tet = boundary[i5 + 4];
+
+        mesh.setNeighbour(current_tet_index, 0, encoded_boundary_tet); // connect opposing neighbour
+
+        const encoded_current_tet = current_tet_index << 2;
+
+        if (encoded_boundary_tet !== INVALID_NEIGHBOUR) {
+            // update neighbour
+            mesh.setNeighbour(encoded_boundary_tet >> 2, encoded_boundary_tet & 3, encoded_current_tet);
+        }
+
+        // boundary[i5 + 4] = encoded_current_tet;
+
+        visited_flags.set(current_tet_index, false); // clear flag
+    }
+
+    computeAdjecencies(mesh, cavity, start, blength);
+
+
+    for (let i = 0; i < start; i++) {
+        // cleanup any orphaned tets that we didn't re-use
+        mesh.delete(deleted_tets[i]);
+    }
+
+    // debug_validate_mesh(mesh, points);
+
+    cavity.__boundary_size = 0;
+    cavity.__deleted_size = 0;
+
+    /*
+    Pick a tet from the created ball, it will generally be a good guess for next point
+     */
+    return deleted_tets[start];
+
+}
+
+
+/**
+ * filling back the cavity
+ * N+2 point on the surface of the cavity
+ * 2N triangle on the surface of the cavity, x3 (4*0.5+1) data = 6N+9 uint64_t
+ * => enough place for the 3N edge x2 data = 6N uint64_t
+ * @param {TetrahedralMesh} mesh
+ * @param {Cavity} cavity
+ * @param {number} start
+ * @param {number} boundary_length
+ */
+function computeAdjecencies(mesh, cavity, start, boundary_length) {
+    const boundary = cavity.__boundary;
+
+    let tlength = 0;
+
+    const Tmp = boundary; // we know there is enough space...
+
+    for (let i = 0; i < boundary_length; i++) {
+
+        const cur_tet = cavity.__deleted[start + i];
+
+        // pointer to the position of Node[0] in the Tmp array
+
+        for (let j = 0; j < 3; j++) {
+
+            // define the edge by the minimum vertex and the other
+            const index_0 = (j + 1) % 3 + 1;
+            const index_1 = (j + 2) % 3 + 1;
+
+            const n0 = mesh.getVertexIndex(cur_tet, index_0);
+            const n1 = mesh.getVertexIndex(cur_tet, index_1);
+
+            const current_tet_neighbour_id = j + 1;
+            const encoded_current_tet = (cur_tet << 2) | (current_tet_neighbour_id & 3);
+
+            // linear searching/pushing into Tmp
+            let k = 0;
+            for (; k < tlength; k++) {
+                // this is the only nested loop... the one that cost it all
+
+                if (Tmp[k * 3] === n0 && Tmp[k * 3 + 1] === n1)
+                    // found a match, stop here
+                    break;
+            }
+
+            if (k === tlength) {
+                // we did not find it
+                const offset = tlength * 3;
+
+                // flip the edge order and store it. Neighbouring tet will have edge order reversed
+                Tmp[offset] = n1;
+                Tmp[offset + 1] = n0;
+
+                Tmp[offset + 2] = encoded_current_tet;
+
+                tlength++;
+            } else {
+                // we found the neighbour !
+                const encoded_neighbour = Tmp[k * 3 + 2];
+
+                mesh.setNeighbour(cur_tet, current_tet_neighbour_id, encoded_neighbour);
+                mesh.setNeighbour(encoded_neighbour >> 2, encoded_neighbour & 3, encoded_current_tet);
+
+                // reduce search space, there can only be one neighbour pair, after it's found we can remove the entry from lookup table
+                tlength--;
+
+                if (k < tlength) {
+                    // put the last entry in the one we just discovered
+                    array_copy(Tmp, tlength * 3, Tmp, k * 3, 3);
+                }
+            }
+        }
+    }
+
+    assert.equal(tlength, 0, 'Failed to compute adjacencies');
+
+    // if (!validate_patched_ball_adjacencies(mesh, cavity.__deleted, start, boundary_length, console.error)) {
+    //     debugger;
+    // }
+}

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

@@ -12,7 +12,7 @@ import { seededRandom } from "../../../math/random/seededRandom.js";
 import { number_pretty_print } from "../../../primitives/numbers/number_pretty_print.js";
 import { delay } from "../../../process/delay.js";
 import { AABB3 } from "../aabb/AABB3.js";
-import { make_justified_point_grid } from "../util/make_justified_point_grid.js";
+import { aabb3_emit_point_grid } from "../util/aabb3_emit_point_grid.js";
 import { compute_delaunay_tetrahedral_mesh } from "./delaunay/compute_delaunay_tetrahedral_mesh.js";
 import { tetrahedral_mesh_build_from_grid } from "./delaunay/grid/tetrahedral_mesh_build_from_grid.js";
 import { build_tetrahedral_mesh_buffer_geometry } from "./graphics/build_tetrahedral_mesh_buffer_geometry.js";
@@ -36,7 +36,7 @@ function make_delaunay_grid(tetrahedra, points) {
         );
     }
 
-    make_justified_point_grid(
+    aabb3_emit_point_grid(
         new AABB3(-100, 0, -100, 100, 150, 100),
         20,
         (x, y, z) => {

package/src/core/geom/3d/tetrahedra/prototype_tetrahedrize_mesh.js

@@ -36,12 +36,10 @@ import { BinaryTopology } from "../topology/struct/binary/BinaryTopology.js";
 import {
     bt_mesh_from_indexed_geometry
 } from "../topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
-import {
-    triangle_mesh_compute_signed_volume
-} from "../triangle/triangle_mesh_compute_signed_volume.js";
+import { tri3_mesh_compute_signed_volume } from "../triangle/tri3_mesh_compute_signed_volume.js";
 import { compute_tetrahedral_mesh_from_surface } from "./compute_tetrahedral_mesh_from_surface.js";
-import { compute_tetrahedron_quality } from "./compute_tetrahedron_quality.js";
-import { compute_tetrahedron_volume } from "./compute_tetrahedron_volume.js";
+import { tetrahedral_mesh_compute_tet_quality } from "./tetrahedral_mesh_compute_tet_quality.js";
+import { tetrahedral_mesh_compute_tet_volume } from "./tetrahedral_mesh_compute_tet_volume.js";
 import { tetrahedral_mesh_improve_quality } from "./tetrahedral_mesh_improve_quality.js";
 import { TetrahedralMesh } from "./TetrahedralMesh.js";
 
@@ -268,7 +266,7 @@ function tetrahedralize_geometry(input_geometry) {
     const surface = new BinaryTopology();
     bt_mesh_from_indexed_geometry(surface, indices, positions);
 
-    const surface_volume = Math.abs(triangle_mesh_compute_signed_volume(positions, indices));
+    const surface_volume = Math.abs(tri3_mesh_compute_signed_volume(positions, indices));
 
     const tet_mesh = new TetrahedralMesh();
     let tet_positions;
@@ -333,8 +331,8 @@ function measure_tet_stats(tet_mesh, tet_positions) {
     let q_sum = 0;
     let sliver_count = 0;
     tet_mesh.forEach((tet, m) => {
-        tet_volume += compute_tetrahedron_volume(m, tet_positions, tet);
-        const q = compute_tetrahedron_quality(m, tet_positions, tet);
+        tet_volume += tetrahedral_mesh_compute_tet_volume(m, tet_positions, tet);
+        const q = tetrahedral_mesh_compute_tet_quality(m, tet_positions, tet);
         if (q < min_quality) min_quality = q;
         q_sum += q;
         if (q < SLIVER_QUALITY_THRESHOLD) sliver_count++;

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.js

@@ -2,7 +2,7 @@ import { assert } from "../../../assert.js";
 import { BVH, NULL_NODE } from "../../../bvh2/bvh3/BVH.js";
 import { bvh_query_user_data_ray } from "../../../bvh2/bvh3/query/bvh_query_user_data_ray.js";
 import { SurfacePoint3 } from "../SurfacePoint3.js";
-import { computeTriangleRayIntersection } from "../triangle/computeTriangleRayIntersection.js";
+import { tri3_ray_intersection } from "../triangle/tri3_ray_intersection.js";
 
 // Three irrational, mutually unrelated ray directions used for majority-vote
 // inside/outside classification. A single ray is fragile: when it grazes a
@@ -80,8 +80,8 @@ const vc = [0, 0, 0];
  */
 function single_ray_parity_inside(bvh, root, surface, ox, oy, oz, dx, dy, dz) {
     const candidate_count = bvh_query_user_data_ray(
-        bvh, root,
         ray_candidates, 0,
+        bvh, root,
         ox, oy, oz,
         dx, dy, dz
     );
@@ -97,7 +97,7 @@ function single_ray_parity_inside(bvh, root, surface, ox, oy, oz, dx, dy, dz) {
         surface.vertex_read_coordinate(vb, 0, surface.loop_read_vertex(l1));
         surface.vertex_read_coordinate(vc, 0, surface.loop_read_vertex(l2));
 
-        const hit = computeTriangleRayIntersection(
+        const hit = tri3_ray_intersection(
             ray_hit,
             ox, oy, oz,
             dx, dy, dz,

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_quality.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Mesh-form wrapper for {@link tetrahedron_compute_quality}: fetches the 4
+ * vertex IDs of `tet` and forwards to the indexed primitive.
+ *
+ * Sibling of {@link compute_tetrahedron_volume}; same convention (the
+ * `compute_*` prefix marks the mesh-bound form, the `tetrahedron_compute_*`
+ * prefix marks the indexed primitive).
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>} points flat (x,y,z) positions
+ * @param {number} tet
+ * @returns {number} quality in [0, 1]
+ */
+export function tetrahedral_mesh_compute_tet_quality(mesh: TetrahedralMesh, points: ArrayLike<number>, tet: number): number;
+//# sourceMappingURL=tetrahedral_mesh_compute_tet_quality.d.ts.map

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_mesh_compute_tet_quality.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_quality.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,oFAJW,UAAU,MAAM,CAAC,OACjB,MAAM,GACJ,MAAM,CAQlB"}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_quality.js

@@ -0,0 +1,22 @@
+import { tetrahedron_compute_quality } from "./tetrahedron_compute_quality.js";
+
+/**
+ * Mesh-form wrapper for {@link tetrahedron_compute_quality}: fetches the 4
+ * vertex IDs of `tet` and forwards to the indexed primitive.
+ *
+ * Sibling of {@link compute_tetrahedron_volume}; same convention (the
+ * `compute_*` prefix marks the mesh-bound form, the `tetrahedron_compute_*`
+ * prefix marks the indexed primitive).
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>} points flat (x,y,z) positions
+ * @param {number} tet
+ * @returns {number} quality in [0, 1]
+ */
+export function tetrahedral_mesh_compute_tet_quality(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_quality(points, a, b, c, d);
+}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_volume.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|number[]} points
+ * @param {number} tet_index
+ * @return {number}
+ */
+export function tetrahedral_mesh_compute_tet_volume(mesh: TetrahedralMesh, points: ArrayLike<number> | number[], tet_index: number): number;
+//# sourceMappingURL=tetrahedral_mesh_compute_tet_volume.d.ts.map

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_volume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_mesh_compute_tet_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_volume.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,mFAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,aAC1B,MAAM,GACL,MAAM,CAUjB"}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_volume.js

@@ -0,0 +1,18 @@
+import { tetrahedron_compute_signed_volume } from "./tetrahedron_compute_signed_volume.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|number[]} points
+ * @param {number} tet_index
+ * @return {number}
+ */
+export function tetrahedral_mesh_compute_tet_volume(mesh, points, tet_index) {
+
+    const a = mesh.getVertexIndex(tet_index, 0);
+    const b = mesh.getVertexIndex(tet_index, 1);
+    const c = mesh.getVertexIndex(tet_index, 2);
+    const d = mesh.getVertexIndex(tet_index, 3);
+
+    return tetrahedron_compute_signed_volume(points, a, b, c, d);
+}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_get_neighbours.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Write the face-adjacent neighbour tetrahedra of `tet_id` into `out`,
+ * non-allocating, and return how many were written.
+ *
+ * A tetrahedron has up to four neighbours — one across each face — and a face on
+ * the mesh surface has none. {@link TetrahedralMesh} stores this adjacency
+ * directly: neighbour slot `i` is the tet across the face opposite vertex `i`,
+ * encoded as `[tet_id:30][opposite_corner:2]` (or {@link INVALID_NEIGHBOUR} for a
+ * surface face). This decodes the tet ids (`encoded >>> 2`, an UNSIGNED shift so
+ * 30-bit ids near the top of the range survive) and skips surface faces, packing
+ * the survivors contiguously from `out_offset`.
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {Int32Array|Uint32Array|number[]} out destination for neighbour tet ids
+ *   (needs room for up to 4 entries from `out_offset`)
+ * @param {number} out_offset offset into `out` at which to start writing
+ * @param {number} tet_id tetrahedron whose neighbours to read
+ * @returns {number} number of neighbours written (0..4); surface faces are skipped
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tetrahedral_mesh_get_neighbours(mesh: TetrahedralMesh, out: Int32Array | Uint32Array | number[], out_offset: number, tet_id: number): number;
+//# sourceMappingURL=tetrahedral_mesh_get_neighbours.d.ts.map

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_get_neighbours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_mesh_get_neighbours.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_get_neighbours.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4EATW,UAAU,GAAC,WAAW,GAAC,MAAM,EAAE,cAE/B,MAAM,UACN,MAAM,GACJ,MAAM,CAkBlB"}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_get_neighbours.js

@@ -0,0 +1,39 @@
+import { assert } from "../../../assert.js";
+import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
+
+/**
+ * Write the face-adjacent neighbour tetrahedra of `tet_id` into `out`,
+ * non-allocating, and return how many were written.
+ *
+ * A tetrahedron has up to four neighbours — one across each face — and a face on
+ * the mesh surface has none. {@link TetrahedralMesh} stores this adjacency
+ * directly: neighbour slot `i` is the tet across the face opposite vertex `i`,
+ * encoded as `[tet_id:30][opposite_corner:2]` (or {@link INVALID_NEIGHBOUR} for a
+ * surface face). This decodes the tet ids (`encoded >>> 2`, an UNSIGNED shift so
+ * 30-bit ids near the top of the range survive) and skips surface faces, packing
+ * the survivors contiguously from `out_offset`.
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {Int32Array|Uint32Array|number[]} out destination for neighbour tet ids
+ *   (needs room for up to 4 entries from `out_offset`)
+ * @param {number} out_offset offset into `out` at which to start writing
+ * @param {number} tet_id tetrahedron whose neighbours to read
+ * @returns {number} number of neighbours written (0..4); surface faces are skipped
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tetrahedral_mesh_get_neighbours(mesh, out, out_offset, tet_id) {
+    assert.defined(mesh, 'mesh');
+    assert.equal(mesh.isTetrahedralMesh, true, 'mesh.isTetrahedralMesh !== true');
+
+    let count = 0;
+    for (let f = 0; f < 4; f++) {
+        const encoded = mesh.getNeighbour(tet_id, f);
+        if (encoded !== INVALID_NEIGHBOUR) {
+            out[out_offset + count] = encoded >>> 2;
+            count++;
+        }
+    }
+    return count;
+}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_improve_quality.js

@@ -2,7 +2,7 @@ import { assert } from "../../../assert.js";
 import {
     tetrahedral_mesh_build_vertex_to_tets_map
 } from "./tetrahedral_mesh_build_vertex_to_tets_map.js";
-import { compute_tetrahedron_quality } from "./compute_tetrahedron_quality.js";
+import { tetrahedral_mesh_compute_tet_quality } from "./tetrahedral_mesh_compute_tet_quality.js";
 import {
     tetrahedral_mesh_find_tets_around_edge
 } from "./tetrahedral_mesh_find_tets_around_edge.js";
@@ -131,7 +131,7 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
             const tet = live[li];
             if (!mesh.exists(tet)) continue;
 
-            let q = compute_tetrahedron_quality(mesh, points, tet);
+            let q = tetrahedral_mesh_compute_tet_quality(mesh, points, tet);
             if (q >= target_quality) continue;
 
             // ---- Smoothing ---------------------------------------------------
@@ -156,7 +156,7 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
                         stats.smoothings_committed++;
                         any_improvement = true;
                         // Re-fetch quality of `tet` — it may have improved.
-                        q = compute_tetrahedron_quality(mesh, points, tet);
+                        q = tetrahedral_mesh_compute_tet_quality(mesh, points, tet);
                         if (q >= target_quality) break;
                     } else {
                         points[v3]     = old_x;
@@ -168,7 +168,7 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
             }
 
             if (!mesh.exists(tet)) continue;
-            q = compute_tetrahedron_quality(mesh, points, tet);
+            q = tetrahedral_mesh_compute_tet_quality(mesh, points, tet);
             if (q >= target_quality) continue;
 
             // ---- 2-3 flip across each internal face -------------------------
@@ -188,8 +188,8 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
                     const shared_i2 = enc & 3;
 
                     const q_before = Math.min(
-                        compute_tetrahedron_quality(mesh, points, tet),
-                        compute_tetrahedron_quality(mesh, points, neighbour_tet)
+                        tetrahedral_mesh_compute_tet_quality(mesh, points, tet),
+                        tetrahedral_mesh_compute_tet_quality(mesh, points, neighbour_tet)
                     );
 
                     // Derive the would-be vertex IDs of the 3 new tets.
@@ -228,7 +228,7 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
             }
 
             if (!mesh.exists(tet)) continue;
-            q = compute_tetrahedron_quality(mesh, points, tet);
+            q = tetrahedral_mesh_compute_tet_quality(mesh, points, tet);
             if (q >= target_quality) continue;
 
             // ---- 3-2 flip on each edge whose ring has exactly 3 tets --------
@@ -263,9 +263,9 @@ export function tetrahedral_mesh_improve_quality(mesh, points, options = {}) {
                     const r2 = scratch_edge_ring[2];
 
                     const q_before_32 = Math.min(
-                        compute_tetrahedron_quality(mesh, points, r0),
-                        compute_tetrahedron_quality(mesh, points, r1),
-                        compute_tetrahedron_quality(mesh, points, r2)
+                        tetrahedral_mesh_compute_tet_quality(mesh, points, r0),
+                        tetrahedral_mesh_compute_tet_quality(mesh, points, r1),
+                        tetrahedral_mesh_compute_tet_quality(mesh, points, r2)
                     );
 
                     // Compute the 3-2 flip's would-be new tet vertex IDs.
@@ -345,7 +345,7 @@ function find_slot(mesh, tet, vertex_id) {
 function scan_min_quality(mesh, points) {
     let min_q = 1;
     mesh.forEach((tet, m) => {
-        const q = compute_tetrahedron_quality(m, points, tet);
+        const q = tetrahedral_mesh_compute_tet_quality(m, points, tet);
         if (q < min_q) min_q = q;
     });
     return min_q;
@@ -380,7 +380,7 @@ function local_min_quality_around_vertex(mesh, points, v_id, vertex_to_tets) {
         }
         if (!still_incident) continue;
 
-        const q = compute_tetrahedron_quality(mesh, points, tet);
+        const q = tetrahedral_mesh_compute_tet_quality(mesh, points, tet);
         if (q < min_q) min_q = q;
     }
     return min_q;