@woosh/meep-engine 2.163.10 → 2.164.0

package/src/engine/sound/simulation/probe/bakeVisibility.js

@@ -0,0 +1,178 @@
+import { CSRGraph } from "../../../../core/graph/csr/CSRGraph.js";
+import { probe_delaunay_edges } from "./probe_delaunay_edges.js";
+import { probe_densify_portals } from "./probe_densify_portals.js";
+import { probe_edge_visible } from "./probe_edge_visible.js";
+import { probe_visibility_augment } from "./probe_visibility_augment.js";
+import { probe_visibility_bridge_components } from "./probe_visibility_bridge_components.js";
+
+const NO_PORTALS = [];
+
+/**
+ * Bake the probe-visibility graph into a {@link AcousticProbeField}: a sparse, occlusion-respecting connectivity
+ * graph over the probes, weighted by distance, that sound routes through ({@link findAcousticPath}). Built
+ * topologically in three stages so the complete O(n²) pair graph is never enumerated (see
+ * VISIBILITY_GRAPH_PLAN.md):
+ *
+ *  - **A** — the Delaunay tetrahedralisation of the probe positions gives ≈6-7·n candidate edges
+ *    ({@link probe_delaunay_edges}); keep those with clear line of sight. Dropping the occluded ones
+ *    fragments the graph into islands (rooms) along walls.
+ *  - **B** — bridge islands that a doorway connects but the Delaunay edge missed, with the shortest visible
+ *    cross-component edges ({@link probe_visibility_bridge_components}). Sealed regions stay separate.
+ *  - **C** — add a budgeted handful of shortcut edges that straighten detours/corners
+ *    ({@link probe_visibility_augment}), since the local Delaunay base can route around clear lines.
+ *  - **D** — when `portals` are given, fan extra cross-opening CHORDS around each portal throat
+ *    ({@link probe_densify_portals}) so routing through an opening is symmetric, not funnelled through one
+ *    off-centre probe. No-op for an empty `portals`, so plain callers are unchanged.
+ *
+ * O(n) edges and O(n) shadow rays, not O(n²). The result is stored as a {@link CSRGraph} on the field
+ * (connectivity is an inherent property of the field). Offline (no WebAudio).
+ *
+ * @param {AcousticProbeField} probeField the field whose probes get connected (mutated: its visibility graph is set)
+ * @param {AcousticOccluderIndex} index the acoustic scene
+ * @param {ArrayLike<number>} [portals] probe indices of portal throats to densify around (stage D)
+ * @param {number} [minSpacing] the probe spacing hint — required (scales the densify radius/bias) iff `portals` given
+ * @returns {AcousticProbeField} the same field, now carrying its visibility graph
+ */
+export function bakeVisibility(probeField, index, portals = NO_PORTALS, minSpacing = 0) {
+    const n = probeField.size;
+
+    // Stage A: Delaunay candidate edges, kept where the line of sight is clear. The endpoints of the OCCLUDED
+    // (dropped) candidates border a wall — the only probes a missed doorway can be bridged from (stage B).
+    const candidates = probe_delaunay_edges(probeField);
+    /**
+     *
+     * @type {number[]}
+     */
+    const baseA = [];
+    /**
+     *
+     * @type {number[]}
+     */
+    const baseB = [];
+    const onWall = new Uint8Array(n);
+
+    /**
+     *
+     * @type {number[]}
+     */
+    const sources = [];
+    for (let i = 0; i < candidates.a.length; i++) {
+        const a = candidates.a[i];
+        const b = candidates.b[i];
+        if (probe_edge_visible(probeField, index, a, b)) {
+            baseA.push(a);
+            baseB.push(b);
+        } else {
+            if (onWall[a] === 0) {
+                onWall[a] = 1;
+                sources.push(a);
+            }
+            if (onWall[b] === 0) {
+                onWall[b] = 1;
+                sources.push(b);
+            }
+        }
+    }
+
+    // Stage B: bridge the islands that dropping occluded edges created, searching from the wall-adjacent probes
+    const bridges = probe_visibility_bridge_components(probeField, index, { a: baseA, b: baseB }, sources);
+
+    const currentA = baseA.concat(bridges.a);
+    const currentB = baseB.concat(bridges.b);
+
+    // Stage C: shortcut augmentation for path quality
+    const augment = probe_visibility_augment(probeField, index, { a: currentA, b: currentB });
+
+    let edgeA = currentA.concat(augment.a);
+    let edgeB = currentB.concat(augment.b);
+
+    // Stage D: portal densification — cross-opening chords so routing through an opening is symmetric. Runs
+    // after A-C so it dedups against the full base/bridge/augment edge set; no-op without portals.
+    if (portals.length > 0) {
+        const chords = probe_densify_portals(probeField, index, portals, { a: edgeA, b: edgeB }, minSpacing);
+        edgeA = edgeA.concat(chords.a);
+        edgeB = edgeB.concat(chords.b);
+    }
+
+    // assemble the final undirected edge list, weighted by inter-probe distance (the runtime recheck
+    // restores weights the same way)
+    const edgeCount = edgeA.length;
+
+    const edgeW = new Float32Array(edgeCount);
+    for (let e = 0; e < edgeCount; e++) {
+        const dx = probeField.probeX(edgeB[e]) - probeField.probeX(edgeA[e]);
+        const dy = probeField.probeY(edgeB[e]) - probeField.probeY(edgeA[e]);
+        const dz = probeField.probeZ(edgeB[e]) - probeField.probeZ(edgeA[e]);
+        edgeW[e] = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
+    // build CSR adjacency: each undirected edge contributes a row entry at BOTH endpoints
+    const adjacency_length = edgeCount * 2;
+
+    const degree = new Uint32Array(n);
+    for (let e = 0; e < edgeCount; e++) {
+        degree[edgeA[e]]++;
+        degree[edgeB[e]]++;
+    }
+
+    const edge_addresses = new Uint32Array(n + 1);
+    for (let v = 0; v < n; v++) {
+        edge_addresses[v + 1] = edge_addresses[v] + degree[v];
+    }
+
+    const adjacency = new Uint32Array(adjacency_length);
+    const edge_weights = new Float32Array(adjacency_length);
+    const cursor = edge_addresses.slice(0, n); // per-vertex write cursor, starting at each row's offset
+
+    for (let e = 0; e < edgeCount; e++) {
+        const a = edgeA[e];
+        const b = edgeB[e];
+        const w = edgeW[e];
+
+        adjacency[cursor[a]] = b;
+        edge_weights[cursor[a]] = w;
+        cursor[a]++;
+
+        adjacency[cursor[b]] = a;
+        edge_weights[cursor[b]] = w;
+        cursor[b]++;
+    }
+
+    const graph = CSRGraph.fromArrays(n, edge_addresses, adjacency, edge_weights);
+
+    probeField.setVisibilityGraph(graph);
+
+    return probeField;
+}
+
+/**
+ * Find the acoustic path from a source to the listener through a `field`'s baked visibility graph: snaps
+ * each end to its nearest probe and returns the shortest route as a list of probe positions `{x, y, z}`
+ * (inclusive), or null if they are in disconnected regions. The probe just before the listener's end is the
+ * EXIT POINT — the apparent direction the leaked sound arrives from (spatialize by exit, not by source).
+ *
+ * @param {AcousticProbeField} field a field with a baked visibility graph ({@link bakeVisibility})
+ * @param {number} sourceX
+ * @param {number} sourceY
+ * @param {number} sourceZ
+ * @param {number} listenerX
+ * @param {number} listenerY
+ * @param {number} listenerZ
+ * @returns {{x:number,y:number,z:number}[]|null}
+ */
+export function findAcousticPath(field, sourceX, sourceY, sourceZ, listenerX, listenerY, listenerZ) {
+    const from = field.nearestIndex(sourceX, sourceY, sourceZ);
+    const to = field.nearestIndex(listenerX, listenerY, listenerZ);
+
+    if (from === -1 || to === -1) {
+        return null;
+    }
+
+    const indices = field.shortestPath(from, to);
+
+    if (indices === null) {
+        return null;
+    }
+
+    return indices.map((i) => ({ x: field.probeX(i), y: field.probeY(i), z: field.probeZ(i) }));
+}

package/src/engine/sound/simulation/probe/echogram_band_rt60.d.ts

@@ -0,0 +1,17 @@
+/**
+ * RT60 (seconds) of one band's echogram, via Schroeder backward integration + a least-squares slope of
+ * the energy-decay curve over the −5 dB → −35 dB window (ISO 3382 T30, extrapolated to 60 dB). Returns 0
+ * when the band carries no reflected energy (open / anechoic) or when the window has too little decay to
+ * fit a slope.
+ *
+ * PRECONDITION: the echogram window (`binCount · binSeconds`) must exceed the RT60 being measured, or the
+ * decay never reaches −35 dB and the result floors to 0. Bakers size the window accordingly.
+ *
+ * @param {Float32Array} echogram band-major time bins
+ * @param {number} bandOffset first bin index of this band (`band · binCount`)
+ * @param {number} binCount bins per band
+ * @param {number} binSeconds seconds per bin
+ * @returns {number} RT60 in seconds (0 = no reverb)
+ */
+export function echogram_band_rt60(echogram: Float32Array, bandOffset: number, binCount: number, binSeconds: number): number;
+//# sourceMappingURL=echogram_band_rt60.d.ts.map

package/src/engine/sound/simulation/probe/echogram_band_rt60.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echogram_band_rt60.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/echogram_band_rt60.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,6CANW,YAAY,cACZ,MAAM,YACN,MAAM,cACN,MAAM,GACJ,MAAM,CA6DlB"}

package/src/engine/sound/simulation/probe/echogram_band_rt60.js

@@ -0,0 +1,83 @@
+/**
+ * Headroom (dB below the peak) where the decay fit starts, and the span fitted — ISO 3382 T30: skip the
+ * first 5 dB (direct-sound / early build-up), fit the next 30 dB, extrapolate the slope to a full 60 dB.
+ * @type {number}
+ */
+const START_DB = -5;
+const END_DB = -35;
+
+/**
+ * RT60 (seconds) of one band's echogram, via Schroeder backward integration + a least-squares slope of
+ * the energy-decay curve over the −5 dB → −35 dB window (ISO 3382 T30, extrapolated to 60 dB). Returns 0
+ * when the band carries no reflected energy (open / anechoic) or when the window has too little decay to
+ * fit a slope.
+ *
+ * PRECONDITION: the echogram window (`binCount · binSeconds`) must exceed the RT60 being measured, or the
+ * decay never reaches −35 dB and the result floors to 0. Bakers size the window accordingly.
+ *
+ * @param {Float32Array} echogram band-major time bins
+ * @param {number} bandOffset first bin index of this band (`band · binCount`)
+ * @param {number} binCount bins per band
+ * @param {number} binSeconds seconds per bin
+ * @returns {number} RT60 in seconds (0 = no reverb)
+ */
+export function echogram_band_rt60(echogram, bandOffset, binCount, binSeconds) {
+    // total reflected energy = the Schroeder energy-decay curve (EDC) at t = 0
+    let total = 0;
+    for (let i = 0; i < binCount; i++) {
+        total += echogram[bandOffset + i];
+    }
+
+    if (total <= 0) {
+        return 0;
+    }
+
+    // Walk forward, tracking energy already elapsed; EDC(t_i) = total − energyBefore is monotonically
+    // decreasing, so its dB curve is too. Accumulate a least-squares line over the [−5, −35] dB window.
+    let energyBefore = 0;
+    let n = 0;
+    let sumT = 0, sumD = 0, sumTD = 0, sumTT = 0;
+
+    for (let i = 0; i < binCount; i++) {
+        const edc = total - energyBefore;
+        energyBefore += echogram[bandOffset + i];
+
+        if (edc <= 0) {
+            break; // tail exhausted — log undefined beyond here
+        }
+
+        const db = 10 * Math.log10(edc / total);
+
+        if (db > START_DB) {
+            continue; // still inside the −5 dB headroom
+        }
+        if (db < END_DB) {
+            break; // past the T30 window
+        }
+
+        const t = i * binSeconds;
+        n++;
+        sumT += t;
+        sumD += db;
+        sumTD += t * db;
+        sumTT += t * t;
+    }
+
+    if (n < 2) {
+        return 0; // not enough decay in the window to fit a slope
+    }
+
+    const denom = n * sumTT - sumT * sumT;
+
+    if (denom <= 0) {
+        return 0;
+    }
+
+    const slope = (n * sumTD - sumT * sumD) / denom; // dB per second (negative for a decaying tail)
+
+    if (slope >= 0) {
+        return 0;
+    }
+
+    return -60 / slope;
+}

package/src/engine/sound/simulation/probe/probe_delaunay_edges.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Candidate undirected edges for a probe field's visibility graph, taken from the Delaunay
+ * tetrahedralisation of the probe positions: the edges of the tet mesh (6 per tetrahedron), deduplicated.
+ *
+ * This is the sparse, spatially-local candidate set that replaces the all-pairs O(n²) enumeration — a 3D
+ * Delaunay has ≈6–7·n edges, so this is O(n), not O(n²). The caller ({@link bakeVisibility}) then filters
+ * these by line of sight, bridges the resulting islands, and augments for path quality. Pure geometry;
+ * offline (no WebAudio); deterministic for given probe positions.
+ *
+ * `n < 4` (too few points for a tetrahedron) returns the complete set of pairs — at most 3 edges.
+ *
+ * Note: a 3D Delaunay base assumes the probes are not (near-)coplanar; a flat field tetrahedralises to
+ * slivers and may yield a sparse/fragmented base, which the caller's bridging stage then reconnects. Dense
+ * volumetric probe fields (the design target) are well-conditioned.
+ *
+ * @param {AcousticProbeField} field
+ * @returns {{a: Uint32Array, b: Uint32Array}} unique undirected edges, with `a[i] < b[i]`
+ */
+export function probe_delaunay_edges(field: AcousticProbeField): {
+    a: Uint32Array;
+    b: Uint32Array;
+};
+//# sourceMappingURL=probe_delaunay_edges.d.ts.map

package/src/engine/sound/simulation/probe/probe_delaunay_edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe_delaunay_edges.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_delaunay_edges.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH;OAFiB,WAAW;OAAK,WAAW;EA4F3C"}

package/src/engine/sound/simulation/probe/probe_delaunay_edges.js

@@ -0,0 +1,215 @@
+import { uf_find, uf_init, uf_union } from "../../../../core/collection/union-find/union_find.js";
+import { v3_morton_encode_bounded } from "../../../../core/geom/3d/morton/v3_morton_encode_bounded.js";
+import {
+    compute_delaunay_tetrahedral_mesh
+} from "../../../../core/geom/3d/tetrahedra/delaunay/compute_delaunay_tetrahedral_mesh.js";
+import { TetrahedralMesh } from "../../../../core/geom/3d/tetrahedra/TetrahedralMesh.js";
+
+// the 6 undirected edges of a tetrahedron as corner-index pairs (0..3)
+const TET_EDGE_LO = [0, 0, 0, 1, 1, 2];
+const TET_EDGE_HI = [1, 2, 3, 2, 3, 3];
+
+/**
+ * Candidate undirected edges for a probe field's visibility graph, taken from the Delaunay
+ * tetrahedralisation of the probe positions: the edges of the tet mesh (6 per tetrahedron), deduplicated.
+ *
+ * This is the sparse, spatially-local candidate set that replaces the all-pairs O(n²) enumeration — a 3D
+ * Delaunay has ≈6–7·n edges, so this is O(n), not O(n²). The caller ({@link bakeVisibility}) then filters
+ * these by line of sight, bridges the resulting islands, and augments for path quality. Pure geometry;
+ * offline (no WebAudio); deterministic for given probe positions.
+ *
+ * `n < 4` (too few points for a tetrahedron) returns the complete set of pairs — at most 3 edges.
+ *
+ * Note: a 3D Delaunay base assumes the probes are not (near-)coplanar; a flat field tetrahedralises to
+ * slivers and may yield a sparse/fragmented base, which the caller's bridging stage then reconnects. Dense
+ * volumetric probe fields (the design target) are well-conditioned.
+ *
+ * @param {AcousticProbeField} field
+ * @returns {{a: Uint32Array, b: Uint32Array}} unique undirected edges, with `a[i] < b[i]`
+ */
+export function probe_delaunay_edges(field) {
+    const n = field.size;
+
+    if (n < 4) {
+        return completeGraphEdges(n);
+    }
+
+    // Spatially sort the probes (Morton order) before the incremental tetrahedralisation: consecutive points
+    // then land in adjacent cells, so the Bowyer-Watson point-location walk reuses the previous tet and stays
+    // O(1) amortised instead of crossing the whole mesh (a ~10× build speed-up at scale). `order[k]` is the
+    // ORIGINAL probe index inserted at sorted position k; tet vertices come back in sorted space and are
+    // mapped back through `order` during extraction.
+    const order = mortonOrder(field, n);
+
+    const points = new Float32Array(n * 3);
+    for (let k = 0; k < n; k++) {
+        const p = order[k];
+        points[k * 3] = field.probeX(p);
+        points[k * 3 + 1] = field.probeY(p);
+        points[k * 3 + 2] = field.probeZ(p);
+    }
+
+    const mesh = new TetrahedralMesh();
+    compute_delaunay_tetrahedral_mesh(mesh, points, n);
+    mesh.compact(); // remove holes
+
+
+    // collect every tet edge (mapping sorted vertex indices back to original probe indices) as a canonical
+    // key `lo*n + hi` (lo<hi, both < n < 2^26, so the key is exact in f64), then sort+unique. The tet mesh
+    // shares each edge across a ring of tets, hence the dedup.
+    const keys = new Float64Array(mesh.count * 6);
+    let k = 0;
+
+    mesh.forEach((tet) => {
+        const v = TET_CORNERS;
+        v[0] = order[mesh.getVertexIndex(tet, 0)];
+        v[1] = order[mesh.getVertexIndex(tet, 1)];
+        v[2] = order[mesh.getVertexIndex(tet, 2)];
+        v[3] = order[mesh.getVertexIndex(tet, 3)];
+
+        for (let e = 0; e < 6; e++) {
+            const x = v[TET_EDGE_LO[e]];
+            const y = v[TET_EDGE_HI[e]];
+            const lo = x < y ? x : y;
+            const hi = x < y ? y : x;
+            keys[k] = lo * n + hi;
+            k++;
+        }
+    });
+
+    const used = keys.subarray(0, k);
+    used.sort(); // numeric ascending for a typed array
+
+    // count distinct keys
+    let uniqueCount = 0;
+    let prev = -1;
+    for (let i = 0; i < used.length; i++) {
+        if (used[i] !== prev) {
+            uniqueCount++;
+            prev = used[i];
+        }
+    }
+
+    const a = new Uint32Array(uniqueCount);
+    const b = new Uint32Array(uniqueCount);
+
+    let j = 0;
+    prev = -1;
+    for (let i = 0; i < used.length; i++) {
+        const key = used[i];
+        if (key === prev) {
+            continue;
+        }
+        prev = key;
+        const lo = Math.floor(key / n);
+        a[j] = lo;
+        b[j] = key - lo * n;
+        j++;
+    }
+
+    // A valid Delaunay 1-skeleton spans the whole point set (it triangulates the convex hull), so a
+    // DISCONNECTED extraction means the input was degenerate — (near-)coplanar/collinear probes the 3D
+    // tetrahedraliser cannot resolve. Fall back to the complete graph so connectivity is never lost; dense
+    // volumetric fields (the design target) are well-conditioned and never hit this. (A large genuinely
+    // coplanar field would make this O(n²) — outside scope; bakeProbeField fields are always 3D.)
+    if (!isConnected(n, a, b)) {
+        return completeGraphEdges(n);
+    }
+
+    return { a, b };
+}
+
+/**
+ * Whether the undirected edge set connects all `n` vertices into one component.
+ * @param {number} n
+ * @param {Uint32Array} a
+ * @param {Uint32Array} b
+ * @returns {boolean}
+ */
+function isConnected(n, a, b) {
+    const parent = new Uint32Array(n);
+    uf_init(parent, n);
+    for (let i = 0; i < a.length; i++) {
+        uf_union(parent, a[i], b[i]);
+    }
+    const root = uf_find(parent, 0);
+    for (let i = 1; i < n; i++) {
+        if (uf_find(parent, i) !== root) {
+            return false;
+        }
+    }
+    return true;
+}
+
+// scratch for a tet's 4 corner vertex indices (module-static; offline, single-threaded)
+const TET_CORNERS = [0, 0, 0, 0];
+
+/**
+ * Probe indices in Morton (Z-order) order — the spatially-coherent insertion order for the incremental
+ * Delaunay. Degenerate axes (a flat field) get a tiny span so the Morton key stays finite; the resulting
+ * order is then arbitrary, but a degenerate field falls back to the complete graph anyway.
+ * @param {AcousticProbeField} field
+ * @param {number} n
+ * @returns {Uint32Array} `order[k]` = original probe index at sorted position k
+ */
+function mortonOrder(field, n) {
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+
+    for (let i = 0; i < n; i++) {
+
+        const x = field.probeX(i);
+        const y = field.probeY(i);
+        const z = field.probeZ(i);
+
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+        if (z < minZ) minZ = z;
+        if (z > maxZ) maxZ = z;
+
+    }
+    const bounds = [
+        minX, minY, minZ,
+        maxX > minX ? maxX : minX + 1,
+        maxY > minY ? maxY : minY + 1,
+        maxZ > minZ ? maxZ : minZ + 1,
+    ];
+
+    const codes = new Uint32Array(n);
+    for (let i = 0; i < n; i++) {
+        codes[i] = v3_morton_encode_bounded(field.probeX(i), field.probeY(i), field.probeZ(i), bounds);
+    }
+
+    const order = new Uint32Array(n);
+    for (let i = 0; i < n; i++) {
+        order[i] = i;
+    }
+    order.sort((p, q) => codes[p] - codes[q]);
+
+    return order;
+}
+
+/**
+ * Every undirected pair over `n` points (the complete graph) — the `n < 4` base case where a Delaunay
+ * tetrahedron cannot form.
+ * @param {number} n
+ * @returns {{a: Uint32Array, b: Uint32Array}}
+ */
+function completeGraphEdges(n) {
+    const count = (n * (n - 1)) / 2;
+    const a = new Uint32Array(count);
+    const b = new Uint32Array(count);
+
+    let j = 0;
+    for (let i = 0; i < n; i++) {
+        for (let k = i + 1; k < n; k++) {
+            a[j] = i;
+            b[j] = k;
+            j++;
+        }
+    }
+
+    return { a, b };
+}

package/src/engine/sound/simulation/probe/probe_densify_portals.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Densify the visibility graph AROUND portal probes so routing through an opening is symmetric instead of
+ * funnelled through one off-centre probe. The cover places probes by clearance, with no notion of openings, so
+ * the single Delaunay/bridge edge that survives across a narrow doorway lands on whichever probe happened to
+ * be nearest — and every cross-opening path detours through it, giving a listener on the left and one on the
+ * right very different routed lengths. This adds the missing cross-opening CHORDS: for each portal, the
+ * mutually-visible pairs among its nearest neighbours whose connecting line threads PAST the portal throat
+ * (small point-to-segment distance — the user's bias). A fan of such chords gives Dijkstra direct, mirror-
+ * symmetric routes through the opening; the residual asymmetry drops to the probe spacing.
+ *
+ * Adds only edges to the existing edge set (deduped) — no new runtime object, nothing to serialize; the portal
+ * concept lives only during the bake. Run as a stage of {@link bakeVisibility}, before the CSR is assembled.
+ *
+ * Pure geometry; offline (no WebAudio).
+ *
+ * @param {import("./AcousticProbeField.js").AcousticProbeField} field
+ * @param {import("../core/AcousticOccluderIndex.js").AcousticOccluderIndex} index the acoustic scene
+ * @param {ArrayLike<number>} portals probe indices of the portal throats (the pre-seeded probes)
+ * @param {{a: ArrayLike<number>, b: ArrayLike<number>}} edges the edges already in the graph (for dedup)
+ * @param {number} minSpacing the probe spacing hint
+ * @param {{neighborRadiusFactor?: number, maxNeighbors?: number, biasFactor?: number}} [options]
+ * @returns {{a: number[], b: number[]}} the cross-opening chord edges to add (possibly empty)
+ */
+export function probe_densify_portals(field: import("./AcousticProbeField.js").AcousticProbeField, index: import("../core/AcousticOccluderIndex.js").AcousticOccluderIndex, portals: ArrayLike<number>, edges: {
+    a: ArrayLike<number>;
+    b: ArrayLike<number>;
+}, minSpacing: number, options?: {
+    neighborRadiusFactor?: number;
+    maxNeighbors?: number;
+    biasFactor?: number;
+}): {
+    a: number[];
+    b: number[];
+};
+//# sourceMappingURL=probe_densify_portals.d.ts.map

package/src/engine/sound/simulation/probe/probe_densify_portals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe_densify_portals.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_densify_portals.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CARW,OAAO,yBAAyB,EAAE,kBAAkB,SACpD,OAAO,kCAAkC,EAAE,qBAAqB,WAChE,UAAU,MAAM,CAAC,SACjB;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,cAC5C,MAAM;2BACkB,MAAM;mBAAiB,MAAM;iBAAe,MAAM;IACxE;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CAyEtC"}