@woosh/meep-engine 2.163.11 → 2.164.0

package/src/core/geom/3d/shape/util/shape3_voxelize_to_grid.js

@@ -0,0 +1,153 @@
+import { assert } from "../../../../assert.js";
+import { v3_length } from "../../../vec3/v3_length.js";
+import { v3_matrix4_multiply } from "../../../vec3/v3_matrix4_multiply.js";
+import { aabb3_matrix4_project } from "../../aabb/aabb3_matrix4_project.js";
+
+// Reusable per-call scratch — keeps the function allocation-free under repeat
+// invocations (which is the expected pattern: re-voxelize the scene every frame
+// before stepping a simulation).
+const _scratch_aabb_world = new Float32Array(6);
+const _scratch_aabb_grid = new Float32Array(6);
+const _scratch_grid_pt = new Float32Array(3);
+const _scratch_world_pt = new Float32Array(3);
+
+/**
+ * Rasterize an {@link AbstractShape3D} into a cell-centered Uint8 grid mask.
+ *
+ * For each integer cell `(i, j, k)` in `[0, rx) × [0, ry) × [0, rz)`, the cell's
+ * center is recovered as the world-space point `grid_to_world * (i, j, k)`. If
+ * that point lies inside the shape — or close enough to its surface (see below)
+ * — the corresponding cell in `grid` is written as `1`.
+ *
+ * The grid is **not** cleared first. Cells outside the shape (and outside its
+ * proximity band) are left exactly as they were, which lets the caller compose
+ * multiple shapes into the same buffer by calling this function repeatedly. The
+ * caller is responsible for `grid.fill(0)` if a fresh mask is desired.
+ *
+ * **Proximity test.** A cell whose centre is outside the shape is still marked
+ * solid if `signed_distance_at_point(centre) < half_cell_diagonal`. This catches
+ * features that pass through a cell without containing its centre — e.g. a thin
+ * sheet bisecting a cubic cell at 45°. The threshold is the largest possible
+ * distance from a cell's centre to any point inside the cell, so any shape that
+ * intersects the cell at all is captured. Cheap fast path: `contains_point` is
+ * tested first (no sqrt for most shapes); the more expensive signed-distance
+ * call only runs for cells whose centre is outside.
+ *
+ * **Volume guard.** If the shape's total volume is less than half the volume of
+ * a single cell, the function returns immediately without writing anything. A
+ * shape that small can't be meaningfully represented as a unit-cell solid — the
+ * obstacle would end up perceptibly larger than the shape itself. Callers with
+ * sub-cell shapes should either refine the grid or use a different
+ * representation (e.g. a point-velocity effector).
+ *
+ * **Coord space.** `shape.contains_point` / `signed_distance_at_point` are
+ * called with **world** coordinates. For shapes that have their own local frame
+ * (e.g. `UnitSphereShape3D` centred at the origin), wrap them in a
+ * {@link TransformedShape3D} so they sit at the right world position before
+ * passing in. The voxelizer is otherwise agnostic to how the shape interprets
+ * its inputs.
+ *
+ * **Grid orientation.** `world_to_grid` and `grid_to_world` are full 4×4
+ * column-major affines, so the grid can be translated, scaled, or rotated in
+ * world space; the algorithm makes no axis-aligned assumption. Cell size per
+ * axis is recovered from the column lengths of `grid_to_world`, which is exact
+ * for orthogonal grids and an overestimate of cell volume for skewed ones — the
+ * latter only widens the volume-guard threshold, which is conservative.
+ *
+ * Designed to feed e.g. a fluid simulator's solid mask, but lives outside any
+ * specific package: anything that needs "rasterize a shape into a cell-centered
+ * boolean grid" can use it.
+ *
+ * @param {AbstractShape3D} shape  shape to voxelize; `contains_point` and
+ *     `signed_distance_at_point` are invoked with world-space points.
+ * @param {Float32Array|number[]} world_to_grid  column-major 4×4 affine;
+ *     world point → grid (cell-index) coords.
+ * @param {Float32Array|number[]} grid_to_world  column-major 4×4 affine;
+ *     grid (cell-index) coords → world cell center.
+ * @param {Uint8Array} grid  output mask, length must be ≥ `rx * ry * rz`.
+ *     Cells that don't pass the test are left untouched.
+ * @param {number} rx  positive integer.
+ * @param {number} ry  positive integer.
+ * @param {number} rz  positive integer.
+ */
+export function shape3_voxelize_to_grid(shape, world_to_grid, grid_to_world, grid, rx, ry, rz) {
+    assert.defined(shape, "shape");
+    assert.isArrayLike(world_to_grid, "world_to_grid");
+    assert.greaterThanOrEqual(world_to_grid.length, 16, "world_to_grid.length");
+    assert.isArrayLike(grid_to_world, "grid_to_world");
+    assert.greaterThanOrEqual(grid_to_world.length, 16, "grid_to_world.length");
+    assert.defined(grid, "grid");
+    assert.isPositiveInteger(rx, "rx");
+    assert.isPositiveInteger(ry, "ry");
+    assert.isPositiveInteger(rz, "rz");
+    assert.greaterThanOrEqual(grid.length, rx * ry * rz, "grid.length");
+
+    // Recover per-axis cell size from the column lengths of grid_to_world. For
+    // an axis-aligned uniform grid these are just the cell spacings; for an
+    // oriented grid they're the post-rotation lengths, which still bound the
+    // cell extent correctly.
+    const cs_x = v3_length(grid_to_world[0], grid_to_world[1], grid_to_world[2]);
+    const cs_y = v3_length(grid_to_world[4], grid_to_world[5], grid_to_world[6]);
+    const cs_z = v3_length(grid_to_world[8], grid_to_world[9], grid_to_world[10]);
+    const cell_volume = cs_x * cs_y * cs_z;
+
+    // Volume guard. See docstring — sub-cell shapes are skipped wholesale.
+    if (shape.volume < cell_volume * 0.5) {
+        return;
+    }
+
+    // Proximity threshold = half the cell diagonal in world units. Any shape
+    // whose surface comes within this radius of a cell centre might intersect
+    // the cell; this is the tightest threshold that won't miss grazing
+    // features.
+    const proximity_threshold = Math.sqrt(cs_x * cs_x + cs_y * cs_y + cs_z * cs_z) * 0.5;
+
+    // Restrict iteration to the shape's bounding box transformed into grid space, expanded by the proximity
+    // band. The band is `proximity_threshold` WORLD units wide, which is a different number of cells along each
+    // axis when the grid is anisotropic/skewed, so pad per-axis by ceil(threshold / cell_size). A fixed +1 cell
+    // under-covers the band along thin axes and would miss grazing features there.
+    shape.compute_bounding_box(_scratch_aabb_world);
+    aabb3_matrix4_project(_scratch_aabb_grid, _scratch_aabb_world, world_to_grid);
+
+    const pad_i = Math.ceil(proximity_threshold / cs_x);
+    const pad_j = Math.ceil(proximity_threshold / cs_y);
+    const pad_k = Math.ceil(proximity_threshold / cs_z);
+
+    const i_min = Math.max(0, Math.floor(_scratch_aabb_grid[0]) - pad_i);
+    const j_min = Math.max(0, Math.floor(_scratch_aabb_grid[1]) - pad_j);
+    const k_min = Math.max(0, Math.floor(_scratch_aabb_grid[2]) - pad_k);
+    const i_max = Math.min(rx - 1, Math.ceil(_scratch_aabb_grid[3]) + pad_i);
+    const j_max = Math.min(ry - 1, Math.ceil(_scratch_aabb_grid[4]) + pad_j);
+    const k_max = Math.min(rz - 1, Math.ceil(_scratch_aabb_grid[5]) + pad_k);
+
+    // Bounding box lies entirely outside the grid → nothing to do.
+    if (i_min > i_max || j_min > j_max || k_min > k_max) {
+        return;
+    }
+
+    const rx_ry = rx * ry;
+    const grid_pt = _scratch_grid_pt;
+    const world_pt = _scratch_world_pt;
+
+    for (let k = k_min; k <= k_max; k++) {
+        grid_pt[2] = k;
+        const k_offset = k * rx_ry;
+        for (let j = j_min; j <= j_max; j++) {
+            grid_pt[1] = j;
+            const j_offset = k_offset + j * rx;
+            for (let i = i_min; i <= i_max; i++) {
+                grid_pt[0] = i;
+                v3_matrix4_multiply(world_pt, 0, grid_pt, 0, grid_to_world);
+
+                // contains_point is the cheap fast path (no sqrt for most
+                // shapes). Only fall through to signed_distance for cells whose
+                // centre is outside the shape, where we still might mark them
+                // for the proximity rule.
+                if (shape.contains_point(world_pt)
+                    || shape.signed_distance_at_point(world_pt) < proximity_threshold) {
+                    grid[j_offset + i] = 1;
+                }
+            }
+        }
+    }
+}

package/src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.d.ts

@@ -1,61 +1,7 @@
 /**
- * Rasterize an {@link AbstractShape3D} into a cell-centered Uint8 grid mask.
- *
- * For each integer cell `(i, j, k)` in `[0, rx) × [0, ry) × [0, rz)`, the cell's
- * center is recovered as the world-space point `grid_to_world * (i, j, k)`. If
- * that point lies inside the shape — or close enough to its surface (see below)
- * — the corresponding cell in `grid` is written as `1`.
- *
- * The grid is **not** cleared first. Cells outside the shape (and outside its
- * proximity band) are left exactly as they were, which lets the caller compose
- * multiple shapes into the same buffer by calling this function repeatedly. The
- * caller is responsible for `grid.fill(0)` if a fresh mask is desired.
- *
- * **Proximity test.** A cell whose centre is outside the shape is still marked
- * solid if `signed_distance_at_point(centre) < half_cell_diagonal`. This catches
- * features that pass through a cell without containing its centre — e.g. a thin
- * sheet bisecting a cubic cell at 45°. The threshold is the largest possible
- * distance from a cell's centre to any point inside the cell, so any shape that
- * intersects the cell at all is captured. Cheap fast path: `contains_point` is
- * tested first (no sqrt for most shapes); the more expensive signed-distance
- * call only runs for cells whose centre is outside.
- *
- * **Volume guard.** If the shape's total volume is less than half the volume of
- * a single cell, the function returns immediately without writing anything. A
- * shape that small can't be meaningfully represented as a unit-cell solid — the
- * obstacle would end up perceptibly larger than the shape itself. Callers with
- * sub-cell shapes should either refine the grid or use a different
- * representation (e.g. a point-velocity effector).
- *
- * **Coord space.** `shape.contains_point` / `signed_distance_at_point` are
- * called with **world** coordinates. For shapes that have their own local frame
- * (e.g. `UnitSphereShape3D` centred at the origin), wrap them in a
- * {@link TransformedShape3D} so they sit at the right world position before
- * passing in. The voxelizer is otherwise agnostic to how the shape interprets
- * its inputs.
- *
- * **Grid orientation.** `world_to_grid` and `grid_to_world` are full 4×4
- * column-major affines, so the grid can be translated, scaled, or rotated in
- * world space; the algorithm makes no axis-aligned assumption. Cell size per
- * axis is recovered from the column lengths of `grid_to_world`, which is exact
- * for orthogonal grids and an overestimate of cell volume for skewed ones — the
- * latter only widens the volume-guard threshold, which is conservative.
- *
- * Designed to feed e.g. a fluid simulator's solid mask, but lives outside any
- * specific package: anything that needs "rasterize a shape into a cell-centered
- * boolean grid" can use it.
- *
- * @param {AbstractShape3D} shape  shape to voxelize; `contains_point` and
- *     `signed_distance_at_point` are invoked with world-space points.
- * @param {Float32Array|number[]} world_to_grid  column-major 4×4 affine;
- *     world point → grid (cell-index) coords.
- * @param {Float32Array|number[]} grid_to_world  column-major 4×4 affine;
- *     grid (cell-index) coords → world cell center.
- * @param {Uint8Array} grid  output mask, length must be ≥ `rx * ry * rz`.
- *     Cells that don't pass the test are left untouched.
- * @param {number} rx  positive integer.
- * @param {number} ry  positive integer.
- * @param {number} rz  positive integer.
+ * @deprecated Renamed to {@link shape3_voxelize_to_grid}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function shape3d_voxelize_to_grid(shape: AbstractShape3D, world_to_grid: Float32Array | number[], grid_to_world: Float32Array | number[], grid: Uint8Array, rx: number, ry: number, rz: number): void;
+export const shape3d_voxelize_to_grid: typeof shape3_voxelize_to_grid;
+import { shape3_voxelize_to_grid } from "./shape3_voxelize_to_grid.js";
 //# sourceMappingURL=shape3d_voxelize_to_grid.d.ts.map

package/src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shape3d_voxelize_to_grid.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,gFAVW,YAAY,GAAC,MAAM,EAAE,iBAErB,YAAY,GAAC,MAAM,EAAE,QAErB,UAAU,MAEV,MAAM,MACN,MAAM,MACN,MAAM,QAkFhB"}
+{"version":3,"file":"shape3d_voxelize_to_grid.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,sEAAgE;wCANxB,8BAA8B"}

package/src/core/geom/3d/shape/util/shape3d_voxelize_to_grid.js

@@ -1,153 +1,7 @@
-import { assert } from "../../../../assert.js";
-import { v3_length } from "../../../vec3/v3_length.js";
-import { v3_matrix4_multiply } from "../../../vec3/v3_matrix4_multiply.js";
-import { aabb3_matrix4_project } from "../../aabb/aabb3_matrix4_project.js";
-
-// Reusable per-call scratch — keeps the function allocation-free under repeat
-// invocations (which is the expected pattern: re-voxelize the scene every frame
-// before stepping a simulation).
-const _scratch_aabb_world = new Float32Array(6);
-const _scratch_aabb_grid = new Float32Array(6);
-const _scratch_grid_pt = new Float32Array(3);
-const _scratch_world_pt = new Float32Array(3);
-
-/**
- * Rasterize an {@link AbstractShape3D} into a cell-centered Uint8 grid mask.
- *
- * For each integer cell `(i, j, k)` in `[0, rx) × [0, ry) × [0, rz)`, the cell's
- * center is recovered as the world-space point `grid_to_world * (i, j, k)`. If
- * that point lies inside the shape — or close enough to its surface (see below)
- * — the corresponding cell in `grid` is written as `1`.
- *
- * The grid is **not** cleared first. Cells outside the shape (and outside its
- * proximity band) are left exactly as they were, which lets the caller compose
- * multiple shapes into the same buffer by calling this function repeatedly. The
- * caller is responsible for `grid.fill(0)` if a fresh mask is desired.
- *
- * **Proximity test.** A cell whose centre is outside the shape is still marked
- * solid if `signed_distance_at_point(centre) < half_cell_diagonal`. This catches
- * features that pass through a cell without containing its centre — e.g. a thin
- * sheet bisecting a cubic cell at 45°. The threshold is the largest possible
- * distance from a cell's centre to any point inside the cell, so any shape that
- * intersects the cell at all is captured. Cheap fast path: `contains_point` is
- * tested first (no sqrt for most shapes); the more expensive signed-distance
- * call only runs for cells whose centre is outside.
- *
- * **Volume guard.** If the shape's total volume is less than half the volume of
- * a single cell, the function returns immediately without writing anything. A
- * shape that small can't be meaningfully represented as a unit-cell solid — the
- * obstacle would end up perceptibly larger than the shape itself. Callers with
- * sub-cell shapes should either refine the grid or use a different
- * representation (e.g. a point-velocity effector).
- *
- * **Coord space.** `shape.contains_point` / `signed_distance_at_point` are
- * called with **world** coordinates. For shapes that have their own local frame
- * (e.g. `UnitSphereShape3D` centred at the origin), wrap them in a
- * {@link TransformedShape3D} so they sit at the right world position before
- * passing in. The voxelizer is otherwise agnostic to how the shape interprets
- * its inputs.
- *
- * **Grid orientation.** `world_to_grid` and `grid_to_world` are full 4×4
- * column-major affines, so the grid can be translated, scaled, or rotated in
- * world space; the algorithm makes no axis-aligned assumption. Cell size per
- * axis is recovered from the column lengths of `grid_to_world`, which is exact
- * for orthogonal grids and an overestimate of cell volume for skewed ones — the
- * latter only widens the volume-guard threshold, which is conservative.
- *
- * Designed to feed e.g. a fluid simulator's solid mask, but lives outside any
- * specific package: anything that needs "rasterize a shape into a cell-centered
- * boolean grid" can use it.
- *
- * @param {AbstractShape3D} shape  shape to voxelize; `contains_point` and
- *     `signed_distance_at_point` are invoked with world-space points.
- * @param {Float32Array|number[]} world_to_grid  column-major 4×4 affine;
- *     world point → grid (cell-index) coords.
- * @param {Float32Array|number[]} grid_to_world  column-major 4×4 affine;
- *     grid (cell-index) coords → world cell center.
- * @param {Uint8Array} grid  output mask, length must be ≥ `rx * ry * rz`.
- *     Cells that don't pass the test are left untouched.
- * @param {number} rx  positive integer.
- * @param {number} ry  positive integer.
- * @param {number} rz  positive integer.
- */
-export function shape3d_voxelize_to_grid(shape, world_to_grid, grid_to_world, grid, rx, ry, rz) {
-    assert.defined(shape, "shape");
-    assert.isArrayLike(world_to_grid, "world_to_grid");
-    assert.greaterThanOrEqual(world_to_grid.length, 16, "world_to_grid.length");
-    assert.isArrayLike(grid_to_world, "grid_to_world");
-    assert.greaterThanOrEqual(grid_to_world.length, 16, "grid_to_world.length");
-    assert.defined(grid, "grid");
-    assert.isPositiveInteger(rx, "rx");
-    assert.isPositiveInteger(ry, "ry");
-    assert.isPositiveInteger(rz, "rz");
-    assert.greaterThanOrEqual(grid.length, rx * ry * rz, "grid.length");
-
-    // Recover per-axis cell size from the column lengths of grid_to_world. For
-    // an axis-aligned uniform grid these are just the cell spacings; for an
-    // oriented grid they're the post-rotation lengths, which still bound the
-    // cell extent correctly.
-    const cs_x = v3_length(grid_to_world[0], grid_to_world[1], grid_to_world[2]);
-    const cs_y = v3_length(grid_to_world[4], grid_to_world[5], grid_to_world[6]);
-    const cs_z = v3_length(grid_to_world[8], grid_to_world[9], grid_to_world[10]);
-    const cell_volume = cs_x * cs_y * cs_z;
-
-    // Volume guard. See docstring — sub-cell shapes are skipped wholesale.
-    if (shape.volume < cell_volume * 0.5) {
-        return;
-    }
-
-    // Proximity threshold = half the cell diagonal in world units. Any shape
-    // whose surface comes within this radius of a cell centre might intersect
-    // the cell; this is the tightest threshold that won't miss grazing
-    // features.
-    const proximity_threshold = Math.sqrt(cs_x * cs_x + cs_y * cs_y + cs_z * cs_z) * 0.5;
-
-    // Restrict iteration to the shape's bounding box transformed into grid space, expanded by the proximity
-    // band. The band is `proximity_threshold` WORLD units wide, which is a different number of cells along each
-    // axis when the grid is anisotropic/skewed, so pad per-axis by ceil(threshold / cell_size). A fixed +1 cell
-    // under-covers the band along thin axes and would miss grazing features there.
-    shape.compute_bounding_box(_scratch_aabb_world);
-    aabb3_matrix4_project(_scratch_aabb_grid, _scratch_aabb_world, world_to_grid);
-
-    const pad_i = Math.ceil(proximity_threshold / cs_x);
-    const pad_j = Math.ceil(proximity_threshold / cs_y);
-    const pad_k = Math.ceil(proximity_threshold / cs_z);
-
-    const i_min = Math.max(0, Math.floor(_scratch_aabb_grid[0]) - pad_i);
-    const j_min = Math.max(0, Math.floor(_scratch_aabb_grid[1]) - pad_j);
-    const k_min = Math.max(0, Math.floor(_scratch_aabb_grid[2]) - pad_k);
-    const i_max = Math.min(rx - 1, Math.ceil(_scratch_aabb_grid[3]) + pad_i);
-    const j_max = Math.min(ry - 1, Math.ceil(_scratch_aabb_grid[4]) + pad_j);
-    const k_max = Math.min(rz - 1, Math.ceil(_scratch_aabb_grid[5]) + pad_k);
-
-    // Bounding box lies entirely outside the grid → nothing to do.
-    if (i_min > i_max || j_min > j_max || k_min > k_max) {
-        return;
-    }
-
-    const rx_ry = rx * ry;
-    const grid_pt = _scratch_grid_pt;
-    const world_pt = _scratch_world_pt;
-
-    for (let k = k_min; k <= k_max; k++) {
-        grid_pt[2] = k;
-        const k_offset = k * rx_ry;
-        for (let j = j_min; j <= j_max; j++) {
-            grid_pt[1] = j;
-            const j_offset = k_offset + j * rx;
-            for (let i = i_min; i <= i_max; i++) {
-                grid_pt[0] = i;
-                v3_matrix4_multiply(world_pt, 0, grid_pt, 0, grid_to_world);
-
-                // contains_point is the cheap fast path (no sqrt for most
-                // shapes). Only fall through to signed_distance for cells whose
-                // centre is outside the shape, where we still might mark them
-                // for the proximity rule.
-                if (shape.contains_point(world_pt)
-                    || shape.signed_distance_at_point(world_pt) < proximity_threshold) {
-                    grid[j_offset + i] = 1;
-                }
-            }
-        }
-    }
-}
+import { shape3_voxelize_to_grid } from "./shape3_voxelize_to_grid.js";
+
+/**
+ * @deprecated Renamed to {@link shape3_voxelize_to_grid}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const shape3d_voxelize_to_grid = shape3_voxelize_to_grid;

package/src/core/geom/3d/sphere/compute_bounding_sphere_of_2_spheres.d.ts

@@ -1,8 +1,7 @@
 /**
- *
- * @param {Float32Array|vec4|number[]} result
- * @param {Float32Array|vec4|number[]} a
- * @param {Float32Array|vec4|number[]} b
+ * @deprecated Renamed to {@link sphere_compute_bounding_of_2_spheres}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function compute_bounding_sphere_of_2_spheres(result: Float32Array | vec4 | number[], a: Float32Array | vec4 | number[], b: Float32Array | vec4 | number[]): void;
+export const compute_bounding_sphere_of_2_spheres: typeof sphere_compute_bounding_of_2_spheres;
+import { sphere_compute_bounding_of_2_spheres } from "./sphere_compute_bounding_of_2_spheres.js";
 //# sourceMappingURL=compute_bounding_sphere_of_2_spheres.d.ts.map

package/src/core/geom/3d/sphere/compute_bounding_sphere_of_2_spheres.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_bounding_sphere_of_2_spheres.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/compute_bounding_sphere_of_2_spheres.js"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,6DAJW,YAAY,UAAM,MAAM,EAAE,KAC1B,YAAY,UAAM,MAAM,EAAE,KAC1B,YAAY,UAAM,MAAM,EAAE,QAoDpC"}
+{"version":3,"file":"compute_bounding_sphere_of_2_spheres.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/compute_bounding_sphere_of_2_spheres.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,+FAAyF;qDANpC,2CAA2C"}

package/src/core/geom/3d/sphere/compute_bounding_sphere_of_2_spheres.js

@@ -1,74 +1,7 @@
-//
-
-
-import { vec3 } from "gl-matrix";
-import { max2 } from "../../../math/max2.js";
-import { Miniball } from "../../packing/miniball/Miniball.js";
-import { PointSet } from "../../packing/miniball/PointSet.js";
-
-/**
- *
- * @type {vec3}
- */
-const delta_direction = [];
-
-
-const outer_points = new Float32Array(12);
-
-/**
- *
- * @param {Float32Array|vec4|number[]} result
- * @param {Float32Array|vec4|number[]} a
- * @param {Float32Array|vec4|number[]} b
- */
-export function compute_bounding_sphere_of_2_spheres(result, a, b) {
-    // compute distance between the spheres
-    vec3.sub(delta_direction, a, b);
-
-    if (delta_direction[0] === 0 && delta_direction[1] === 0 && delta_direction[2] === 0) {
-        // sphere centers overlap
-        result[0] = a[0];
-        result[1] = a[1];
-        result[2] = a[2];
-        result[3] = max2(a[3], b[3]);
-        return;
-    }
-
-    vec3.normalize(delta_direction, delta_direction);
-
-    // compute outer points on the spheres along the line between their centers
-    const a_radius = a[3];
-
-    const delta_x = delta_direction[0];
-    const delta_y = delta_direction[1];
-    const delta_z = delta_direction[2]
-
-
-    outer_points[0] = delta_x * a_radius + a[0];
-    outer_points[1] = delta_y * a_radius + a[1];
-    outer_points[2] = delta_z * a_radius + a[2];
-
-    outer_points[3] = -delta_x * a_radius + a[0];
-    outer_points[4] = -delta_y * a_radius + a[1];
-    outer_points[5] = -delta_z * a_radius + a[2];
-
-    const b_radius = b[3];
-
-    outer_points[6] = delta_x * b_radius + b[0];
-    outer_points[7] = delta_y * b_radius + b[1];
-    outer_points[8] = delta_z * b_radius + b[2];
-
-    outer_points[9] = -delta_x * b_radius + b[0];
-    outer_points[10] = -delta_y * b_radius + b[1];
-    outer_points[11] = -delta_z * b_radius + b[2];
-
-    // run standard miniball  to get new bounding sphere
-    const miniball = new Miniball(new PointSet(4, 3, outer_points));
-
-    const center = miniball.center();
-
-    result[0] = center[0];
-    result[1] = center[1];
-    result[2] = center[2];
-    result[3] = miniball.radius();
-}
+import { sphere_compute_bounding_of_2_spheres } from "./sphere_compute_bounding_of_2_spheres.js";
+
+/**
+ * @deprecated Renamed to {@link sphere_compute_bounding_of_2_spheres}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
+ */
+export const compute_bounding_sphere_of_2_spheres = sphere_compute_bounding_of_2_spheres;

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -4,7 +4,7 @@ import { array_copy } from "../../../../collection/array/array_copy.js";
 import { min2 } from "../../../../math/min2.js";
 import { sinc } from "../../../../math/sinc.js";
 import { SH3_COEFFICIENTS } from "./SH3_COEFFICIENTS.js";
-import { sh3_rotate_bl } from "./sh3_rotate_bl.js";
+import { sh3_rotate } from "./sh3_rotate.js";
 import { sh_index } from "./sh_index.js";
 
 /*
@@ -77,7 +77,7 @@ function sh3_min(input_sh3) {
 
     const f = new Float32Array(9);
 
-    sh3_rotate_bl(f, input_sh3, M);
+    sh3_rotate(f, input_sh3, M);
     // here we're guaranteed to have normalize(float3{ -f[3], -f[1], f[2] }) == { 0, 0, 1 }
 
 

package/src/core/geom/3d/sphere/harmonics/sh3_rotate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rotate spherical harmonics
+ * @param {number[]|Float32Array} result sh3
+ * @param {number[]} sh input
+ * @param {number[]} rotation 3x3 rotation matrix
+ */
+export function sh3_rotate(result: number[] | Float32Array, sh: number[], rotation: number[]): number[] | Float32Array;
+//# sourceMappingURL=sh3_rotate.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh3_rotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh3_rotate.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_rotate.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,mCAJW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,EAAE,YACR,MAAM,EAAE,2BAuFlB"}

package/src/core/geom/3d/sphere/harmonics/sh3_rotate.js

@@ -0,0 +1,94 @@
+const scratch_mat_5x5 = new Float64Array(25);
+
+/**
+ * Rotate spherical harmonics
+ * @param {number[]|Float32Array} result sh3
+ * @param {number[]} sh input
+ * @param {number[]} rotation 3x3 rotation matrix
+ */
+export function sh3_rotate(result, sh, rotation) {
+    // Implementation adapted from BakerLab by https://github.com/TheRealMJP
+
+    const r00 = rotation[0];
+    const r10 = rotation[1];
+    const r20 = rotation[2];
+
+    const r01 = rotation[3];
+    const r11 = rotation[4];
+    const r21 = rotation[5];
+
+    const r02 = rotation[6];
+    const r12 = rotation[7];
+    const r22 = rotation[8];
+
+
+    // band-0 : Constant
+    result[0] = sh[0];
+
+    // band-1: Linear
+    result[1] = r11 * sh[1] - r12 * sh[2] + r10 * sh[3];
+    result[2] = -r21 * sh[1] + r22 * sh[2] - r20 * sh[3];
+    result[3] = r01 * sh[1] - r02 * sh[2] + r00 * sh[3];
+
+    // band-2: Quadratic
+    const t41 = r01 * r00;
+    const t43 = r11 * r10;
+    const t48 = r11 * r12;
+    const t50 = r01 * r02;
+    const t55 = r02 * r02;
+    const t57 = r22 * r22;
+    const t58 = r12 * r12;
+    const t61 = r00 * r02;
+    const t63 = r10 * r12;
+    const t68 = r10 * r10;
+    const t70 = r01 * r01;
+    const t72 = r11 * r11;
+    const t74 = r00 * r00;
+    const t76 = r21 * r21;
+    const t78 = r20 * r20;
+
+    const v173 = 0.1732050808e1;
+    const v577 = 0.5773502693e0;
+    const v115 = 0.1154700539e1;
+    const v288 = 0.2886751347e0;
+    const v866 = 0.8660254040e0;
+
+    scratch_mat_5x5[0] = r11 * r00 + r01 * r10;
+    scratch_mat_5x5[1] = -r01 * r12 - r11 * r02;
+    scratch_mat_5x5[2] = v173 * r02 * r12;
+    scratch_mat_5x5[3] = -r10 * r02 - r00 * r12;
+    scratch_mat_5x5[4] = r00 * r10 - r01 * r11;
+    scratch_mat_5x5[5] = -r11 * r20 - r21 * r10;
+    scratch_mat_5x5[6] = r11 * r22 + r21 * r12;
+    scratch_mat_5x5[7] = -v173 * r22 * r12;
+    scratch_mat_5x5[8] = r20 * r12 + r10 * r22;
+    scratch_mat_5x5[9] = -r10 * r20 + r11 * r21;
+    scratch_mat_5x5[10] = -v577 * (t41 + t43) + v115 * r21 * r20;
+    scratch_mat_5x5[11] = v577 * (t48 + t50) - v115 * r21 * r22;
+    scratch_mat_5x5[12] = -0.5 * (t55 + t58) + t57;
+    scratch_mat_5x5[13] = v577 * (t61 + t63) - v115 * r20 * r22;
+    scratch_mat_5x5[14] = v288 * (t70 - t68 + t72 - t74) - v577 * (t76 - t78);
+    scratch_mat_5x5[15] = -r01 * r20 - r21 * r00;
+    scratch_mat_5x5[16] = r01 * r22 + r21 * r02;
+    scratch_mat_5x5[17] = -v173 * r22 * r02;
+    scratch_mat_5x5[18] = r00 * r22 + r20 * r02;
+    scratch_mat_5x5[19] = -r00 * r20 + r01 * r21;
+    scratch_mat_5x5[20] = t41 - t43;
+    scratch_mat_5x5[21] = -t50 + t48;
+    scratch_mat_5x5[22] = v866 * (t55 - t58);
+    scratch_mat_5x5[23] = t63 - t61;
+    scratch_mat_5x5[24] = 0.5 * (t74 - t68 - t70 + t72);
+
+    for (let i = 0; i < 5; ++i) {
+        const base = i * 5;
+
+        result[4 + i] = scratch_mat_5x5[base + 0] * sh[4]
+            + scratch_mat_5x5[base + 1] * sh[5]
+            + scratch_mat_5x5[base + 2] * sh[6]
+            + scratch_mat_5x5[base + 3] * sh[7]
+            + scratch_mat_5x5[base + 4] * sh[8]
+        ;
+    }
+
+    return result;
+}

package/src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.d.ts

@@ -1,8 +1,7 @@
 /**
- * Rotate spherical harmonics
- * @param {number[]|Float32Array} result sh3
- * @param {number[]} sh input
- * @param {number[]} rotation 3x3 rotation matrix
+ * @deprecated Renamed to {@link sh3_rotate}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function sh3_rotate_bl(result: number[] | Float32Array, sh: number[], rotation: number[]): number[] | Float32Array;
+export const sh3_rotate_bl: typeof sh3_rotate;
+import { sh3_rotate } from "./sh3_rotate.js";
 //# sourceMappingURL=sh3_rotate_bl.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sh3_rotate_bl.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,sCAJW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,EAAE,YACR,MAAM,EAAE,2BAuFlB"}
+{"version":3,"file":"sh3_rotate_bl.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh3_rotate_bl.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,8CAAwC;2BANb,iBAAiB"}