@woosh/meep-engine 2.42.8 → 2.43.1

package/core/geom/packing/{MaxRectangles.js → max-rect/MaxRectangles.js}

@@ -1,122 +1,13 @@
-import BinaryHeap from "../../collection/heap/FastBinaryHeap.js";
-import { assert } from "../../assert.js";
-import { max2 } from "../../math/max2.js";
-import { min2 } from "../../math/min2.js";
-import { QuadTreeDatum } from "../2d/quad-tree/QuadTreeDatum.js";
-import { QuadTreeNode } from "../2d/quad-tree/QuadTreeNode.js";
-import AABB2 from "../AABB2.js";
-import Vector2 from "../Vector2.js";
-
-/**
- * Remove all rectangles that are fully contained within others
- * @param {AABB2[]} boxes
- */
-function removeRedundantBoxesArray(boxes) {
-    let i, j;
-    let numBoxes = boxes.length;
-
-    loop_a: for (i = 0; i < numBoxes; i++) {
-        const a = boxes[i];
-
-        const ax0 = a.x0;
-        const ay0 = a.y0;
-        const ax1 = a.x1;
-        const ay1 = a.y1;
-
-        for (j = i + 1; j < numBoxes; j++) {
-            const b = boxes[j];
-
-            const bx0 = b.x0;
-            const by0 = b.y0;
-            const bx1 = b.x1;
-            const by1 = b.y1;
-
-            //question is now whether it is containment
-            if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
-                //b contains a
-                boxes.splice(i, 1);
-                i--;
-                numBoxes--;
-                continue loop_a;
-            } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
-                //a contains b
-                boxes.splice(j, 1);
-                j--;
-                numBoxes--;
-            }
-        }
-    }
-}
-
-
-/**
- * Remove all rectangles that are fully contained within others
- * @param {QuadTreeNode} boxes
- */
-function removeRedundantBoxes(boxes) {
-    const removals = [];
-
-
-    let datum;
-
-    /**
-     *
-     * @param {QuadTreeDatum} intersection
-     */
-    function visitDatumIntersection(intersection) {
-        if (datum === intersection) {
-            //skip self
-            return;
-        }
-
-        const ax0 = intersection.x0;
-        const ay0 = intersection.y0;
-        const ax1 = intersection.x1;
-        const ay1 = intersection.y1;
-
-        const bx0 = datum.x0;
-        const by0 = datum.y0;
-        const bx1 = datum.x1;
-        const by1 = datum.y1;
-
-        //question is now whether it is containment
-        if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
-            //b contains a
-            removals.push(intersection);
-        } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
-            //a contains b
-            removals.push(datum);
-
-            //scheduled removal of the datum, prevent further traversal
-            return false;
-        }
-    }
-
-    /**
-     *
-     * @param {QuadTreeNode} node
-     */
-    function visitTreeNode(node) {
-        const data = node.data;
-        const dataCount = data.length;
-
-        for (let i = 0; i < dataCount; i++) {
-            /**
-             *
-             * @type {QuadTreeDatum}
-             */
-            datum = data[i];
-
-            node.traverseRectangleIntersections(datum.x0, datum.y0, datum.x1, datum.y1, visitDatumIntersection);
-        }
-    }
-
-    boxes.traversePreOrder(visitTreeNode);
-
-    for (const removal of removals) {
-        removal.disconnect();
-    }
-}
+import BinaryHeap from "../../../collection/heap/FastBinaryHeap.js";
+import { assert } from "../../../assert.js";
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
+import { QuadTreeNode } from "../../2d/quad-tree/QuadTreeNode.js";
+import AABB2 from "../../AABB2.js";
+import Vector2 from "../../Vector2.js";
+import { removeRedundantBoxesArray } from "./removeRedundantBoxesArray.js";
+import { removeRedundantBoxes } from "./removeRedundantBoxes.js";
 
 
 /**
@@ -301,7 +192,7 @@ function packOneBox(box, free) {
     container.disconnect();
 
     //place box at bottom left of the container
-    const y0 = container.y1 - h;
+    const y0 = container.y0;
     const x0 = container.x0;
 
     box.set(x0, y0, x0 + w, y0 + h);
@@ -310,8 +201,8 @@ function packOneBox(box, free) {
     cutArea(box, free);
 
     //split remaining space
-    if (container.y0 !== y0) {
-        const splitA = new QuadTreeDatum(container.x0, container.y0, container.x1, y0);
+    if (box.y1 !== container.y1) {
+        const splitA = new QuadTreeDatum(container.x0, box.y1, container.x1, container.y1);
 
         free.insertDatum(splitA);
     }
@@ -321,7 +212,6 @@ function packOneBox(box, free) {
         free.insertDatum(splitB);
     }
 
-    removeRedundantBoxes(free);
 
     return true;
 }
@@ -405,6 +295,7 @@ export class MaxRectanglesPacker {
 
         if (success) {
             this.boxes.push(box);
+            removeRedundantBoxes(this.free);
         }
 
         // assert.ok(this.validate());
@@ -412,6 +303,16 @@ export class MaxRectanglesPacker {
         return success;
     }
 
+    /**
+     *
+     * @param {number} w
+     * @param {number} h
+     * @return {boolean}
+     */
+    canAdd(w, h) {
+        return findBestContainer(w, h, this.free, costByRemainingArea) !== null;
+    }
+
     /**
      * Method is transactional, if one box fails to be packed, all fail and packer is reverted to original state
      * @param {AABB2[]} boxes
@@ -444,7 +345,7 @@ export class MaxRectanglesPacker {
             const boxIndex = heap.pop();
             const box = boxes[boxIndex];
 
-            if (!this.add(box)) {
+            if (!packOneBox(box, this.free)) {
                 //remove whatever has been packed
                 const removeFailCount = this.removeMany(packed);
 
@@ -452,11 +353,14 @@ export class MaxRectanglesPacker {
 
                 return false;
             } else {
+                this.boxes.push(box);
                 //box packed successfully
                 packed.push(box);
             }
         }
 
+        removeRedundantBoxes(this.free);
+
         return true;
     }
 

package/core/geom/packing/max-rect/removeRedundantBoxes.js

@@ -0,0 +1,69 @@
+/**
+ * Remove all rectangles that are fully contained within others
+ * @param {QuadTreeNode} boxes
+ */
+export function removeRedundantBoxes(boxes) {
+    const removals = [];
+
+
+    let datum;
+
+    /**
+     *
+     * @param {QuadTreeDatum} intersection
+     */
+    function visitDatumIntersection(intersection) {
+        if (datum === intersection) {
+            //skip self
+            return;
+        }
+
+        const ax0 = intersection.x0;
+        const ay0 = intersection.y0;
+        const ax1 = intersection.x1;
+        const ay1 = intersection.y1;
+
+        const bx0 = datum.x0;
+        const by0 = datum.y0;
+        const bx1 = datum.x1;
+        const by1 = datum.y1;
+
+        //question is now whether it is containment
+        if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
+            //b contains a
+            removals.push(intersection);
+        } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
+            //a contains b
+            removals.push(datum);
+
+            //scheduled removal of the datum, prevent further traversal
+            return false;
+        }
+    }
+
+    /**
+     *
+     * @param {QuadTreeNode} node
+     */
+    function visitTreeNode(node) {
+        const data = node.data;
+        const dataCount = data.length;
+
+        for (let i = 0; i < dataCount; i++) {
+            /**
+             *
+             * @type {QuadTreeDatum}
+             */
+            datum = data[i];
+
+            node.traverseRectangleIntersections(datum.x0, datum.y0, datum.x1, datum.y1, visitDatumIntersection);
+        }
+    }
+
+    boxes.traversePreOrder(visitTreeNode);
+
+    for (let i = 0; i < removals.length; i++) {
+        const removal = removals[i];
+        removal.disconnect();
+    }
+}

package/core/geom/packing/max-rect/removeRedundantBoxesArray.js

@@ -0,0 +1,40 @@
+/**
+ * Remove all rectangles that are fully contained within others
+ * @param {AABB2[]} boxes
+ */
+export function removeRedundantBoxesArray(boxes) {
+    let i, j;
+    let numBoxes = boxes.length;
+
+    loop_a: for (i = 0; i < numBoxes; i++) {
+        const a = boxes[i];
+
+        const ax0 = a.x0;
+        const ay0 = a.y0;
+        const ax1 = a.x1;
+        const ay1 = a.y1;
+
+        for (j = i + 1; j < numBoxes; j++) {
+            const b = boxes[j];
+
+            const bx0 = b.x0;
+            const by0 = b.y0;
+            const bx1 = b.x1;
+            const by1 = b.y1;
+
+            //question is now whether it is containment
+            if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
+                //b contains a
+                boxes.splice(i, 1);
+                i--;
+                numBoxes--;
+                continue loop_a;
+            } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
+                //a contains b
+                boxes.splice(j, 1);
+                j--;
+                numBoxes--;
+            }
+        }
+    }
+}

package/core/geom/v3_distance_above_plane.js

@@ -15,6 +15,6 @@ export function v3_distance_above_plane(
     x, y, z,
     normalX, normalY, normalZ, planeConstant
 ) {
-    // this is is the same v4_dot(v4(x,y,z,1.0), v4(plane.normal, plane.constant));
+    // this is the same as v4_dot(v4(x,y,z,1.0), v4(plane.normal, plane.constant));
     return v3_dot(normalX, normalY, normalZ, x, y, z) + planeConstant;
 }

package/core/graph/layout/BoxLayouter.js

@@ -6,31 +6,11 @@
 
 import AABB2 from "../../geom/AABB2.js";
 import Vector2 from "../../geom/Vector2.js";
-import { resolveBoxOverlapUsingForce } from "./box/resolveBoxOverlapUsingForce.js";
 import { computeDisconnectedSubGraphs } from "./computeDisconnectedSubGraphs.js";
 import { Connection } from "./Connection.js";
+import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
 
 
-/**
- *
- * @param {AABB2[]} boxes
- * @param {number} maxSteps
- */
-export function resolveAABB2Overlap(boxes, maxSteps) {
-    const forces = [];
-
-    const n = boxes.length;
-    for (let i = 0; i < n; i++) {
-        forces.push(new Vector2(0, 0));
-    }
-
-    let overlapMoves = -1;
-    while (maxSteps > 0 && overlapMoves !== 0) {
-        maxSteps--;
-        overlapMoves = resolveBoxOverlapUsingForce(forces, boxes);
-    }
-}
-
 /**
  *
  * @param {Connection} edge
@@ -201,27 +181,6 @@ function applyPull(edges, strength) {
     }
 }
 
-/**
- *
- * @param {AABB2} box
- * @param {number} targetX target point X coordinate
- * @param {number} targetY target point Y coordinate
- * @param {number} strength
- */
-export function pullBoxTowardsPoint(box, targetX, targetY, strength) {
-    const midX = box.midX();
-    const midY = box.midY();
-
-    const deltaX = targetX - midX;
-    const deltaY = targetY - midY;
-
-    //multiply by strength
-    const displacementX = deltaX * strength;
-    const displacementY = deltaY * strength;
-
-    box.move(displacementX, displacementY);
-}
-
 /**
  *
  * @param {Array.<AABB2>} boxes
@@ -502,50 +461,6 @@ function doLayerLayout(boxes) {
     }
 }
 
-/**
- * Note: assumes that boxes to be contained are strictly smaller than the container in both dimensions
- * @param {AABB2} container
- * @param {Array.<AABB2>} boxes
- */
-function forceIntoBox(container, boxes) {
-    for (let i = 0, l = boxes.length; i < l; i++) {
-        const box = boxes[i];
-
-        if (box.locked === true) {
-            continue;
-        }
-
-        let dX = 0;
-        let dY = 0;
-
-        const bx0 = box.x0;
-        const bx1 = box.x1;
-
-        const by0 = box.y0;
-        const by1 = box.y1;
-
-        const cx0 = container.x0;
-        const cx1 = container.x1;
-
-        const cy0 = container.y0;
-        const cy1 = container.y1;
-
-        if (bx0 < cx0) {
-            dX = cx0 - bx0;
-        } else if (bx1 > cx1) {
-            dX = cx1 - bx1;
-        }
-
-        if (by0 < cy0) {
-            dY = cy0 - by0;
-        } else if (by1 > cy1) {
-            dY = cy1 - by1;
-        }
-
-        box.move(dX, dY);
-    }
-}
-
 /**
  *
  * @param {AABB2[]} boxes
@@ -665,6 +580,5 @@ function forceLayout(input, graph, center = null) {
 
 export {
     forceLayout,
-    alignOnOrigin,
-    forceIntoBox
+    alignOnOrigin
 };

package/core/graph/layout/CircleLayout.js

@@ -10,9 +10,10 @@ import { line2SegmentsIntersect } from "../../geom/LineSegment2.js";
 import Vector2, { v2_distance } from "../../geom/Vector2.js";
 import { max2 } from "../../math/max2.js";
 import { min2 } from "../../math/min2.js";
-import { applyCentralGravityAABB2, resolveAABB2Overlap } from "./BoxLayouter.js";
+import { applyCentralGravityAABB2 } from "./BoxLayouter.js";
 import { computeDisconnectedSubGraphs } from "./computeDisconnectedSubGraphs.js";
 import { Connection } from "./Connection.js";
+import { resolveAABB2Overlap } from "./box/resolveAABB2Overlap.js";
 
 
 /**

package/core/graph/layout/box/forceIntoBox.js

@@ -0,0 +1,45 @@
+/**
+ * Note: assumes that boxes to be contained are strictly smaller than the container in both dimensions
+ * @param {AABB2} container
+ * @param {Array.<AABB2>} boxes
+ */
+function forceIntoBox(container, boxes) {
+    for (let i = 0, l = boxes.length; i < l; i++) {
+        const box = boxes[i];
+
+        if (box.locked === true) {
+            continue;
+        }
+
+        let dX = 0;
+        let dY = 0;
+
+        const bx0 = box.x0;
+        const bx1 = box.x1;
+
+        const by0 = box.y0;
+        const by1 = box.y1;
+
+        const cx0 = container.x0;
+        const cx1 = container.x1;
+
+        const cy0 = container.y0;
+        const cy1 = container.y1;
+
+        if (bx0 < cx0) {
+            dX = cx0 - bx0;
+        } else if (bx1 > cx1) {
+            dX = cx1 - bx1;
+        }
+
+        if (by0 < cy0) {
+            dY = cy0 - by0;
+        } else if (by1 > cy1) {
+            dY = cy1 - by1;
+        }
+
+        box.move(dX, dY);
+    }
+}
+
+export { forceIntoBox };

package/core/graph/layout/box/pullBoxTowardsPoint.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param {AABB2} box
+ * @param {number} targetX target point X coordinate
+ * @param {number} targetY target point Y coordinate
+ * @param {number} strength
+ */
+export function pullBoxTowardsPoint(box, targetX, targetY, strength) {
+    const midX = box.midX();
+    const midY = box.midY();
+
+    const deltaX = targetX - midX;
+    const deltaY = targetY - midY;
+
+    //multiply by strength
+    const displacementX = deltaX * strength;
+    const displacementY = deltaY * strength;
+
+    box.move(displacementX, displacementY);
+}

package/core/graph/layout/box/resolveAABB2Overlap.js

@@ -0,0 +1,22 @@
+import Vector2 from "../../../geom/Vector2.js";
+import { resolveBoxOverlapUsingForce } from "./resolveBoxOverlapUsingForce.js";
+
+/**
+ *
+ * @param {AABB2[]} boxes
+ * @param {number} maxSteps
+ */
+export function resolveAABB2Overlap(boxes, maxSteps) {
+    const forces = [];
+
+    const n = boxes.length;
+    for (let i = 0; i < n; i++) {
+        forces.push(new Vector2(0, 0));
+    }
+
+    let overlapMoves = -1;
+    while (maxSteps > 0 && overlapMoves !== 0) {
+        maxSteps--;
+        overlapMoves = resolveBoxOverlapUsingForce(forces, boxes);
+    }
+}

package/core/math/bessel_3.js

@@ -0,0 +1,11 @@
+/**
+ * Kaiser Bessel Function of third kind
+ * @see https://www.shadertoy.com/view/wlf3RH
+ * @returns {number}
+ * @param {number} x
+ */
+export function bessel_3(x) {
+    const y = 0.5 * x;
+    const y2 = (y * y);
+    return (y2 * y * (1.0 / 6.0 + y2 * (1.0 / 24.0 + y2 * (1.0 / 240.0 + y2 * (1.0 / 4320.0 + y2 / 120960.0)))));
+}

package/core/math/bessel_i0.js

@@ -0,0 +1,26 @@
+import { assert } from "../assert.js";
+
+/**
+ * Modified bessel function of the first kind
+ * @see https://mathworld.wolfram.com/ModifiedBesselFunctionoftheFirstKind.html
+ * @see https://computergraphics.stackexchange.com/questions/6393/kaiser-windowed-sinc-filter-for-mip-mapping
+ * @see https://github.com/terifan/ImageResampler/blob/dbc212ce6aaa769bf3c9623cb6ead58ffd51d76c/src/org/terifan/image_resampler/FilterFactory.java
+ * @param {number} x
+ * @returns {number}
+ */
+export function bessel_i0(x) {
+    assert.notNaN(x, 'x');
+
+    let sum = 1.0;
+
+    const y = x * x * 0.25;
+
+    let t = y;
+
+    for (let i = 2; t > 1e-7; i++) {
+        sum += t;
+        t *= y / (i * i);
+    }
+
+    return sum;
+}

package/core/process/executor/ConcurrentExecutor.spec.js

@@ -3,8 +3,9 @@ import Task from "../task/Task.js"
 import TaskGroup from "../task/TaskGroup.js";
 import { TaskSignal } from "../task/TaskSignal.js";
 import TaskState from "../task/TaskState.js";
-import { emptyTask, failingTask } from "../task/TaskUtils.js";
 import ConcurrentExecutor from "./ConcurrentExecutor.js";
+import { emptyTask } from "../task/util/emptyTask.js";
+import { failingTask } from "../task/util/failingTask.js";
 
 /**
  *

package/core/process/task/util/actionTask.js

@@ -0,0 +1,19 @@
+import Task from "../Task.js";
+import { TaskSignal } from "../TaskSignal.js";
+
+/**
+ *
+ * @param {function} action
+ * @param {string} name
+ * @return {Task}
+ */
+export function actionTask(action, name = "unnamed") {
+    return new Task({
+        name,
+        cycleFunction() {
+            action();
+
+            return TaskSignal.EndSuccess;
+        }
+    });
+}

package/core/process/task/util/countTask.js

@@ -0,0 +1,62 @@
+import { TaskSignal } from "../TaskSignal.js";
+import Task from "../Task.js";
+
+/**
+ *
+ * @param {number|function(*):number} initial
+ * @param {number|function(*):number} limit
+ * @param {function(index:int)} callback
+ * @returns {Task}
+ */
+export function countTask(initial, limit, callback) {
+    let initialValue = 0;
+    let limitValue = 0;
+
+    let i = initialValue;
+
+    function cycle() {
+        if (i >= limitValue) {
+            return TaskSignal.EndSuccess;
+        }
+        callback(i);
+        i++;
+
+        return TaskSignal.Continue;
+    }
+
+    const initialType = typeof initial;
+    const limitType = typeof limit;
+
+    const name = "count (from " + ((initialType === 'number') ? initial : 'variable') + " to " + ((limitType === 'number') ? limit : 'variable') + ")";
+
+    return new Task({
+        name: name,
+        initializer() {
+
+            if (initialType === "number") {
+                initialValue = initial;
+            } else if (initialType === "function") {
+                initialValue = initial();
+            }
+
+            if (limitType === "number") {
+                limitValue = limit;
+            } else if (limitType === "function") {
+                limitValue = limit();
+            }
+
+            i = initialValue;
+
+        },
+        cycleFunction: cycle,
+        computeProgress: function () {
+            const span = limitValue - initialValue;
+
+            if (span === 0) {
+                return 0;
+            }
+
+            return (i - initialValue) / span;
+        }
+    });
+}