@woosh/meep-engine 2.134.5 → 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.js

@@ -1,5 +1,5 @@
 import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
-import { matrix_top_eigenvector_power_iteration } from "../../graph/eigen/matrix_top_eigenvector_power_iteration.js";
+import { matrix_top_eigenvector_power_iteration } from "../../math/linalg/eigen/matrix_top_eigenvector_power_iteration.js";
 import { SquareMatrix } from "../../math/matrix/SquareMatrix.js"
 
 const scratch_horn_n = new SquareMatrix(4, BinaryDataType.Float64);

package/src/core/graph/layout/box/BoxLayouter.js

@@ -22,11 +22,11 @@ function evaluateEdgeCost(edge) {
     const second = edge.target;
 
     //compute center points
-    const x0 = first.midX();
-    const y0 = first.midY();
+    const x0 = first.centerX;
+    const y0 = first.centerY;
 
-    const x1 = second.midX();
-    const y1 = second.midY();
+    const x1 = second.centerX;
+    const y1 = second.centerY;
 
     return Vector2._distance(x0, y0, x1, y1);
 }
@@ -63,7 +63,7 @@ function evaluateLayout(boxes, edges) {
     const footprint = computeBoundingBox(boxes);
 
     //overall size of the layout plays a role
-    const totalArea = footprint.getHeight() * footprint.getWidth();
+    const totalArea = footprint.height * footprint.width;
 
     const totalConnectionLength = edges.reduce(function (sum, edge) {
         return sum + evaluateEdgeCost(edge);
@@ -177,8 +177,8 @@ function applyPull(edges, strength) {
         const first = edge.source;
         const second = edge.target;
 
-        d.set(second.midX(), second.midY());
-        d._sub(first.midX(), first.midY());
+        d.set(second.centerX, second.centerY);
+        d._sub(first.centerX, first.centerY);
 
         d.multiplyScalar(strength);
 

package/src/core/graph/layout/box/position_box_next_to_box.js

@@ -31,13 +31,13 @@ function compute_initial_placement(
 
     const targetCenter = target.getCenter();
 
-    const targetH = target.getHeight();
-    const targetW = target.getWidth();
+    const targetH = target.height;
+    const targetW = target.width;
 
     const targetDiagonal = Math.sqrt(targetH * targetH + targetW * targetW);
 
-    const boxWidth = box.getWidth();
-    const boxHeight = box.getHeight();
+    const boxWidth = box.width;
+    const boxHeight = box.height;
 
     const boxWidth_2 = boxWidth / 2;
     const boxHeight_2 = boxHeight / 2;
@@ -120,8 +120,8 @@ function compute_initial_placement(
 
         let score = 0;
 
-        const availableWidth = availableSpace.getWidth();
-        const availableHeight = availableSpace.getHeight();
+        const availableWidth = availableSpace.width;
+        const availableHeight = availableSpace.height;
 
         const spareWidth = availableWidth - boxWidth;
         const spareHeight = availableHeight - boxHeight;