@woosh/meep-engine 2.134.4 → 2.135.0

package/src/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -1,160 +1,160 @@
-import { v3_dot } from "../../vec3/v3_dot.js";
-import { assert } from "../../../assert.js";
-
-/**
- * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
- * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
- * @param {SurfacePoint3} result
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @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
- * @returns {boolean}
- */
-export function computeTriangleRayIntersection(
-    result,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    ax, ay, az,
-    bx, by, bz,
-    cx, cy, cz
-) {
-    assert.isNumber(ax, 'ax');
-    assert.isNumber(ay, 'ay');
-    assert.isNumber(az, 'az');
-
-    assert.isNumber(bx, 'bx');
-    assert.isNumber(by, 'by');
-    assert.isNumber(bz, 'bz');
-
-    assert.isNumber(cx, 'cx');
-    assert.isNumber(cy, 'cy');
-    assert.isNumber(cz, 'cz');
-
-    // nan checks
-    assert.notNaN(ax, 'ax');
-    assert.notNaN(ay, 'ay');
-    assert.notNaN(az, 'az');
-
-    assert.notNaN(bx, 'bx');
-    assert.notNaN(by, 'by');
-    assert.notNaN(bz, 'bz');
-
-    assert.notNaN(cx, 'cx');
-    assert.notNaN(cy, 'cy');
-    assert.notNaN(cz, 'cz');
-
-    // finate number check
-    assert.isFiniteNumber(ax, 'ax');
-    assert.isFiniteNumber(ay, 'ay');
-    assert.isFiniteNumber(az, 'az');
-
-    assert.isFiniteNumber(bx, 'bx');
-    assert.isFiniteNumber(by, 'by');
-    assert.isFiniteNumber(bz, 'bz');
-
-    assert.isFiniteNumber(cx, 'cx');
-    assert.isFiniteNumber(cy, 'cy');
-    assert.isFiniteNumber(cz, 'cz');
-
-
-    // edge1 = a - b
-    const edge1_x = bx - ax;
-    const edge1_y = by - ay;
-    const edge1_z = bz - az;
-
-    // edge2 = c - a
-    const edge2_x = cx - ax;
-    const edge2_y = cy - ay;
-    const edge2_z = cz - az;
-
-    // Compute triangle normal
-
-    // normal = edge1 x edge2
-    const normal_x = edge1_y * edge2_z - edge1_z * edge2_y;
-    const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
-    const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
-
-    let DdN = v3_dot(direction_x, direction_y, direction_z, normal_x, normal_y, normal_z);
-    let sign = 1;
-
-    if (DdN === 0) {
-        // ray and the triangle normal are orthogonal, means that the ray can not pass penetrate triangle
-        return false;
-    } else if (DdN < 0) {
-        sign = -1;
-        DdN = -DdN;
-    }
-
-    // diff = origin - a
-    const diff_x = origin_x - ax;
-    const diff_y = origin_y - ay;
-    const diff_z = origin_z - az;
-
-    // edge3 = diff x edge2
-    const edge3_x = diff_y * edge2_z - diff_z * edge2_y;
-    const edge3_y = diff_z * edge2_x - diff_x * edge2_z;
-    const edge3_z = diff_x * edge2_y - diff_y * edge2_x;
-
-    // DdQxE2 = sign * ( direction . edge3)
-    const DdQxE2 = sign * v3_dot(direction_x, direction_y, direction_z, edge3_x, edge3_y, edge3_z);
-
-    if (DdQxE2 < 0) {
-        // b1 < 0, no intersection
-        return false;
-    }
-
-    const edge4_x = edge1_y * diff_z - edge1_z * diff_y;
-    const edge4_y = edge1_z * diff_x - edge1_x * diff_z;
-    const edge4_z = edge1_x * diff_y - edge1_y * diff_x;
-
-    const DdE1xQ = sign * v3_dot(direction_x, direction_y, direction_z, edge4_x, edge4_y, edge4_z);
-
-    if (DdE1xQ < 0) {
-        // b2 < 0, no intersection
-        return false;
-    }
-
-    if (DdQxE2 + DdE1xQ > DdN) {
-        // b1+b2 > 1, no intersection
-        return false;
-    }
-
-    // Line intersects triangle, check if ray does.
-    const QdN = -sign * v3_dot(diff_x, diff_y, diff_z, normal_x, normal_y, normal_z);
-
-    if (QdN < 0) {
-        // t < 0, no intersection
-        return false;
-
-    }
-
-    // Ray intersects triangle.
-    const t = QdN / DdN;
-
-    result.normal.set(
-        normal_x,
-        normal_y,
-        normal_z
-    );
-
-    result.position.set(
-        direction_x * t + origin_x,
-        direction_y * t + origin_y,
-        direction_z * t + origin_z,
-    );
-
-    return true;
-}
-
+import { v3_dot } from "../../vec3/v3_dot.js";
+import { assert } from "../../../assert.js";
+
+/**
+ * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {SurfacePoint3} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @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
+ * @returns {boolean}
+ */
+export function computeTriangleRayIntersection(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
+
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
+
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
+
+    // nan checks
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
+
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
+
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
+
+    // finate number check
+    assert.isFinite(ax, 'ax');
+    assert.isFinite(ay, 'ay');
+    assert.isFinite(az, 'az');
+
+    assert.isFinite(bx, 'bx');
+    assert.isFinite(by, 'by');
+    assert.isFinite(bz, 'bz');
+
+    assert.isFinite(cx, 'cx');
+    assert.isFinite(cy, 'cy');
+    assert.isFinite(cz, 'cz');
+
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    // Compute triangle normal
+
+    // normal = edge1 x edge2
+    const normal_x = edge1_y * edge2_z - edge1_z * edge2_y;
+    const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
+    const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
+
+    let DdN = v3_dot(direction_x, direction_y, direction_z, normal_x, normal_y, normal_z);
+    let sign = 1;
+
+    if (DdN === 0) {
+        // ray and the triangle normal are orthogonal, means that the ray can not pass penetrate triangle
+        return false;
+    } else if (DdN < 0) {
+        sign = -1;
+        DdN = -DdN;
+    }
+
+    // diff = origin - a
+    const diff_x = origin_x - ax;
+    const diff_y = origin_y - ay;
+    const diff_z = origin_z - az;
+
+    // edge3 = diff x edge2
+    const edge3_x = diff_y * edge2_z - diff_z * edge2_y;
+    const edge3_y = diff_z * edge2_x - diff_x * edge2_z;
+    const edge3_z = diff_x * edge2_y - diff_y * edge2_x;
+
+    // DdQxE2 = sign * ( direction . edge3)
+    const DdQxE2 = sign * v3_dot(direction_x, direction_y, direction_z, edge3_x, edge3_y, edge3_z);
+
+    if (DdQxE2 < 0) {
+        // b1 < 0, no intersection
+        return false;
+    }
+
+    const edge4_x = edge1_y * diff_z - edge1_z * diff_y;
+    const edge4_y = edge1_z * diff_x - edge1_x * diff_z;
+    const edge4_z = edge1_x * diff_y - edge1_y * diff_x;
+
+    const DdE1xQ = sign * v3_dot(direction_x, direction_y, direction_z, edge4_x, edge4_y, edge4_z);
+
+    if (DdE1xQ < 0) {
+        // b2 < 0, no intersection
+        return false;
+    }
+
+    if (DdQxE2 + DdE1xQ > DdN) {
+        // b1+b2 > 1, no intersection
+        return false;
+    }
+
+    // Line intersects triangle, check if ray does.
+    const QdN = -sign * v3_dot(diff_x, diff_y, diff_z, normal_x, normal_y, normal_z);
+
+    if (QdN < 0) {
+        // t < 0, no intersection
+        return false;
+
+    }
+
+    // Ray intersects triangle.
+    const t = QdN / DdN;
+
+    result.normal.set(
+        normal_x,
+        normal_y,
+        normal_z
+    );
+
+    result.position.set(
+        direction_x * t + origin_x,
+        direction_y * t + origin_y,
+        direction_z * t + origin_z,
+    );
+
+    return true;
+}
+

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentric.js

@@ -1,96 +1,96 @@
-import { assert } from "../../../assert.js";
-import { computeTriangleRayIntersectionBarycentricEdge } from "./computeTriangleRayIntersectionBarycentricEdge.js";
-
-/**
- * Compute barycentric coordinates for triangle intersection
- * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
- * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
- * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
- * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @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
- * @returns {boolean}
- */
-export function computeTriangleRayIntersectionBarycentric(
-    result,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    ax, ay, az,
-    bx, by, bz,
-    cx, cy, cz
-) {
-    assert.isNumber(ax, 'ax');
-    assert.isNumber(ay, 'ay');
-    assert.isNumber(az, 'az');
-
-    assert.isNumber(bx, 'bx');
-    assert.isNumber(by, 'by');
-    assert.isNumber(bz, 'bz');
-
-    assert.isNumber(cx, 'cx');
-    assert.isNumber(cy, 'cy');
-    assert.isNumber(cz, 'cz');
-
-    // nan checks
-    assert.notNaN(ax, 'ax');
-    assert.notNaN(ay, 'ay');
-    assert.notNaN(az, 'az');
-
-    assert.notNaN(bx, 'bx');
-    assert.notNaN(by, 'by');
-    assert.notNaN(bz, 'bz');
-
-    assert.notNaN(cx, 'cx');
-    assert.notNaN(cy, 'cy');
-    assert.notNaN(cz, 'cz');
-
-    // finate number check
-    assert.isFiniteNumber(ax, 'ax');
-    assert.isFiniteNumber(ay, 'ay');
-    assert.isFiniteNumber(az, 'az');
-
-    assert.isFiniteNumber(bx, 'bx');
-    assert.isFiniteNumber(by, 'by');
-    assert.isFiniteNumber(bz, 'bz');
-
-    assert.isFiniteNumber(cx, 'cx');
-    assert.isFiniteNumber(cy, 'cy');
-    assert.isFiniteNumber(cz, 'cz');
-
-
-    // find vectors for two edges sharing vert
-
-    // edge1 = a - b
-    const edge1_x = bx - ax;
-    const edge1_y = by - ay;
-    const edge1_z = bz - az;
-
-    // edge2 = c - a
-    const edge2_x = cx - ax;
-    const edge2_y = cy - ay;
-    const edge2_z = cz - az;
-
-    return computeTriangleRayIntersectionBarycentricEdge(
-        result,
-        origin_x, origin_y, origin_z,
-        direction_x, direction_y, direction_z,
-        ax, ay, az,
-        edge1_x, edge1_y, edge1_z,
-        edge2_x, edge2_y, edge2_z
-    );
-}
-
-
+import { assert } from "../../../assert.js";
+import { computeTriangleRayIntersectionBarycentricEdge } from "./computeTriangleRayIntersectionBarycentricEdge.js";
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @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
+ * @returns {boolean}
+ */
+export function computeTriangleRayIntersectionBarycentric(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
+
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
+
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
+
+    // nan checks
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
+
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
+
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
+
+    // finate number check
+    assert.isFinite(ax, 'ax');
+    assert.isFinite(ay, 'ay');
+    assert.isFinite(az, 'az');
+
+    assert.isFinite(bx, 'bx');
+    assert.isFinite(by, 'by');
+    assert.isFinite(bz, 'bz');
+
+    assert.isFinite(cx, 'cx');
+    assert.isFinite(cy, 'cy');
+    assert.isFinite(cz, 'cz');
+
+
+    // find vectors for two edges sharing vert
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    return computeTriangleRayIntersectionBarycentricEdge(
+        result,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        ax, ay, az,
+        edge1_x, edge1_y, edge1_z,
+        edge2_x, edge2_y, edge2_z
+    );
+}
+
+

package/src/core/geom/packing/max-rect/MaxRectanglesPacker.js

@@ -140,7 +140,7 @@ export class MaxRectanglesPacker {
          */
         function scoreBoxByMinSide(boxIndex) {
             const box = boxes[boxIndex];
-            return -Math.min(box.getWidth(), box.getHeight());
+            return -Math.min(box.width, box.height);
         }
 
         const heap = new BinaryHeap(scoreBoxByMinSide);

package/src/core/geom/packing/max-rect/findBestContainer.js

@@ -30,12 +30,12 @@ export function findBestContainer(
      */
     function visitor(node){
 
-        if (node.getWidth() < width) {
+        if (node.width < width) {
             //too small, don't traverse deeper
             return false;
         }
 
-        if (node.getHeight() < height) {
+        if (node.height < height) {
             //too small, don't traverse deeper
             return false;
         }
@@ -46,14 +46,14 @@ export function findBestContainer(
         for (let i = 0; i < box_count; i++) {
             const box = data[i];
 
-            const bW = box.getWidth();
+            const bW = box.width;
 
             if (bW < width) {
                 //too small
                 continue;
             }
 
-            const bH = box.getHeight();
+            const bH = box.height;
 
             if (bH < height) {
                 //too small

package/src/core/geom/packing/max-rect/packOneBox.js

@@ -10,8 +10,8 @@ import { findBestContainer } from "./findBestContainer.js";
  * @returns {boolean}
  */
 export function packOneBox(box, free) {
-    const w = box.getWidth();
-    const h = box.getHeight();
+    const w = box.width;
+    const h = box.height;
 
     const container = findBestContainer(w, h, free, costByRemainingArea);
 

package/src/core/geom/vec3/v3_rigid_align_paired_unit_vectors.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Closed-form solution for the rotation that best aligns two sets of unit
+ * vectors, via Horn (1987) "Closed-form solution of absolute orientation using
+ * unit quaternions".
+ *
+ * Given paired unit vectors {a_i} and {b_i}, finds the unit quaternion q such
+ * that rotating each b_i by q minimizes Σ |a_i − R(q)·b_i|².
+ *
+ * The matrix N is built so that the eigenvector of its largest eigenvalue
+ * IS the optimal rotation quaternion (in scalar-last form, matching meep's
+ * `Quaternion`).
+ *
+ * Inputs are unit vectors so no centroid subtraction is needed — the rotation
+ * is recovered from the cross-correlations alone.
+ *
+ * @param {Float32Array|number[]} a_xyz Source vectors — Length: count*3, unit length per triple
+ * @param {Float32Array|number[]} b_xyz Target vectors — Length: count*3, unit length per triple
+ * @param {number} count
+ * @param {Float32Array|number[]} out_quaternion Length 4 (x, y, z, w)
+ * @returns {number} The maximum eigenvalue ≈ Σ a_i · R·b_i. For a perfect alignment this equals `count`.
+ */
+export function v3_rigid_align_paired_unit_vectors(a_xyz: Float32Array | number[], b_xyz: Float32Array | number[], count: number, out_quaternion: Float32Array | number[]): number;
+//# sourceMappingURL=v3_rigid_align_paired_unit_vectors.d.ts.map

package/src/core/geom/vec3/v3_rigid_align_paired_unit_vectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_rigid_align_paired_unit_vectors.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_rigid_align_paired_unit_vectors.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,0DANW,YAAY,GAAC,MAAM,EAAE,SACrB,YAAY,GAAC,MAAM,EAAE,SACrB,MAAM,kBACN,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAsElB"}