@woosh/meep-engine 2.42.8 → 2.43.1

package/core/binary/BitSet.js

@@ -5,9 +5,9 @@ import { min2 } from "../math/min2.js";
 /**
  * de Bruijn sequence
  * @see https://graphics.stanford.edu/~seander/bithacks.html
- * @type {Uint16Array}
+ * @type {Uint8Array}
  */
-const msb_lut = new Uint16Array([
+const msb_lut = new Uint8Array([
     0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
     31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
 ]);
@@ -29,7 +29,8 @@ function msb_32(v) {
 }
 
 /**
- * get least significant set bit
+ * Get index of the least significant set bit
+ * Also known as ctz32 or "count trailing zeroes"
  * @see https://graphics.stanford.edu/~seander/bithacks.html
  * @param {number} v
  * @returns {number}
@@ -38,7 +39,6 @@ function lsb_32(v) {
     return msb_lut[((v & -v) * 0x077CB531) >>> 27];
 }
 
-
 /**
  * Used for overallocating space when bit set needs to grow
  * @constant

package/core/binary/ctz32.js

@@ -0,0 +1,40 @@
+/**
+ * Count trailing zeroes
+ * adapted from https://github.com/git/git/blob/bcd6bc478adc4951d57ec597c44b12ee74bc88fb/ewah/ewok.h#L44
+ * @param {number} x expected to be an integer
+ * @return {number}
+ */
+function ctz32(x) {
+    let n = 0;
+
+    if ((x & 0xffff) === 0) {
+        x >>= 16;
+        n += 16;
+    }
+
+    if ((x & 0xff) === 0) {
+        x >>= 8;
+        n += 8;
+    }
+
+    if ((x & 0xf) === 0) {
+        x >>= 4;
+        n += 4;
+    }
+
+    if ((x & 0x3) === 0) {
+        x >>= 2;
+        n += 2;
+    }
+
+    if ((x & 0x1) === 0) {
+        x >>= 1;
+        n += 1;
+    }
+
+    if (x === 0) {
+        n += 1;
+    }
+
+    return n;
+}

package/core/collection/ObservedMap.js

@@ -1,71 +1,75 @@
 import Signal from "../events/signal/Signal.js";
 
-/**
- * @template K,V
- * @constructor
- * @property {number} size
- */
-function ObservedMap(source = new Map()) {
-    this.on = {
-        set: new Signal(),
-        deleted: new Signal()
-    };
+export class ObservedMap {
+    /**
+     * @template K,V
+     * @constructor
+     * @property {number} size
+     */
+    constructor(source = new Map()) {
+        this.on = {
+            set: new Signal(),
+            deleted: new Signal()
+        };
+
+        /**
+         *
+         * @type {Map<K, V>}
+         */
+        this.data = source;
+    }
 
     /**
      *
-     * @type {Map<K, V>}
+     * @param {K} key
+     * @returns {V|undefined}
      */
-    this.data = source;
-}
+    get(key) {
+        return this.data.get(key);
+    }
 
-Object.defineProperty(ObservedMap.prototype, "size", {
-    get() {
-        return this.data.size;
-    },
-    configurable: false
-});
+    /**
+     *
+     * @param {K} key
+     * @param {V} value
+     * @returns {ObservedMap}
+     */
+    set(key, value) {
+        this.data.set(key, value);
+        this.on.set.send2(key, value);
 
-/**
- *
- * @param {K} key
- * @returns {V|undefined}
- */
-ObservedMap.prototype.get = function (key) {
-    return this.data.get(key);
-};
-/**
- *
- * @param {K} key
- * @param {V} value
- * @returns {ObservedMap}
- */
-ObservedMap.prototype.set = function (key, value) {
-    this.data.set(key, value);
-    this.on.set.dispatch(key, value);
+        return this;
+    }
 
-    return this;
-};
+    /**
+     *
+     * @param {K} key
+     * @returns {boolean}
+     */
+    delete(key) {
+        const result = this.data.delete(key);
 
-/**
- *
- * @param {K} key
- * @returns {boolean}
- */
-ObservedMap.prototype.delete = function (key) {
-    const result = this.data.delete(key);
+        if (result) {
+            this.on.deleted.send1(key);
+        }
 
-    if (result) {
-        this.on.deleted.dispatch(key);
+        return result;
     }
 
-    return result;
-};
-
-ObservedMap.prototype.forEach = function (callback, thisArg) {
-    this.data.forEach(callback, thisArg);
-};
-
+    /**
+     * Implements {@link Map#forEach} interface
+     * @param {function} callback
+     * @param {*} [thisArg]
+     */
+    forEach(callback, thisArg) {
+        this.data.forEach(callback, thisArg);
+    }
 
-export {
-    ObservedMap
-};
+    /**
+     *
+     * @return {number}
+     */
+    get size() {
+        return this.data.size;
+    }
+}

package/core/collection/heap/FastBinaryHeap.js

@@ -242,11 +242,17 @@ class BinaryHeap {
     /**
      *
      * @param {T} node
+     * @returns {boolean} false if element is not found, true otherwise
      */
-    rescoreElement(node) {
+    updateElementScore(node) {
         const index = this.data.indexOf(node);
 
+        if (index === -1) {
+            return false;
+        }
+
         this.bubbleDown(index);
+        return true;
     }
 
     /**

package/core/collection/heap/Uint32Heap.js

@@ -229,6 +229,10 @@ export class Uint32Heap {
         return this.__size === 0;
     }
 
+    peek_min() {
+        return this.top_id;
+    }
+
     pop_min() {
         assert.greaterThan(this.__size, 0, 'heap is empty');
 
@@ -337,6 +341,21 @@ export class Uint32Heap {
         }
     }
 
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    get_score(id) {
+        const index = this.find_index_by_id(id);
+
+        if (index === -1) {
+            return Number.NaN;
+        }
+
+        return this.__data_float32[index * 2];
+    }
+
 
     /**
      *

package/core/collection/map/AsyncLoadingCache.js

@@ -39,7 +39,9 @@ export class AsyncLoadingCache extends AbstractAsyncMap {
         const value = await promise;
 
         if (original_loader) {
-            this.__cache.get(key, value);
+            this.__cache.set(key, value);
+            // remove from pending
+            this.__pending.delete(key);
         }
 
         return value;

package/core/geom/2d/compute_polygon_area_2d.js

@@ -0,0 +1,32 @@
+/**
+ * Uses Green's Theorem to compute area of a 2d polygon
+ * @param {number[]|Float32Array|Float64Array} points
+ * @param {number} point_count
+ * @returns {number}
+ */
+export function compute_polygon_area_2d(points, point_count) {
+    let sum = 0;
+
+    for (let i = 0; i < point_count - 1; i++) {
+        const x0 = points[(i) * 2];
+        const y0 = points[(i) * 2 + 1];
+
+        const x1 = points[(i + 1) * 2];
+        const y1 = points[(i + 1) * 2 + 1];
+
+        sum += x0 * y1 - y0 * x1;
+    }
+
+    const first_x = points[0];
+    const first_y = points[1];
+
+    const last_x = points[point_count * 2 - 2];
+    const last_y = points[point_count * 2 - 1];
+
+    if (first_x !== last_x || first_y !== last_y) {
+        // doesn't wrap around, let's close the loop ourselves
+        sum += last_x * first_y - last_y * first_x;
+    }
+
+    return sum * 0.5;
+}

package/core/geom/2d/compute_polygon_area_2d.spec.js

@@ -0,0 +1,10 @@
+import { compute_polygon_area_2d } from "./compute_polygon_area_2d.js";
+
+test("square", () => {
+    expect(compute_polygon_area_2d([
+        0, 0,
+        1, 0,
+        1, 1,
+        0, 1
+    ], 4)).toBeCloseTo(1);
+});

package/core/geom/2d/compute_triangle_area_2d.js

@@ -0,0 +1,15 @@
+/**
+ * Uses Green's Theorem to compute area of a 2d triangle
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ * @returns {number}
+ */
+export function compute_triangle_area_2d(x0, y0, x1, y1, x2, y2) {
+    return 0.5 * (
+        (x0 * y1 - y0 * x1) + (x1 * y2 - y1 * x2) + (x2 * y0 - y2 * x0)
+    );
+}

package/core/geom/2d/compute_triangle_area_2d.spec.js

@@ -0,0 +1,9 @@
+import { compute_triangle_area_2d } from "./compute_triangle_area_2d.js";
+
+test("half-square", () => {
+    expect(compute_triangle_area_2d(
+        0, 0,
+        1, 0,
+        1, 1
+    )).toBeCloseTo(0.5);
+});

package/core/geom/2d/convex-hull/convex_hull_jarvis_2d.js

@@ -0,0 +1,64 @@
+import { assert } from "../../../assert.js";
+import { orientation3_array } from "./orientation3_array.js";
+
+/**
+ * Simple algorithm for computing convex hull, not the fastest, but it does the job and has very small implementation
+ * Please note that the result does not repeat the first vertex, meaning that the last point is not the same as the first point
+ * NOTE: complexity is O(nh) where h is the number of point on the hull and n is number of input points
+ * @see https://en.wikipedia.org/wiki/Gift_wrapping_algorithm
+ * @param {number[]|Float32Array|Float64Array} input 2d point set, of form [x0,y0,x1,y1, ... xn,yn]
+ * @param {number} point_count number of points in the input set
+ * @returns {number[]} indices of vertices from input that make up the hull, this result is ordered to form a closed loop around the hull if followed
+ */
+export function convex_hull_jarvis_2d(input, point_count = input.length * 0.5) {
+    assert.isNumber(point_count, 'point_count');
+    assert.isNonNegativeInteger(point_count, 'point_count');
+
+    const jarvis_vertices = [];
+
+    if (point_count <= 2) {
+        // special case, very small input
+        for (let i = 0; i < point_count; i++) {
+            jarvis_vertices.push(i);
+        }
+
+        return jarvis_vertices;
+    }
+
+    // find left-most point
+    let l = 0;
+
+    for (let i = 0; i < point_count; i++) {
+        const i2 = i * 2;
+        const l2 = l * 2;
+
+        const x_i = input[i2];
+        const x_l = input[l2];
+
+        if (x_i < x_l) {
+            l = i;
+        }
+    }
+
+    let p = l, q;
+
+    do {
+        jarvis_vertices.push(p);
+
+        q = (p + 1) % point_count;
+
+        for (let i = 0; i < point_count; i++) {
+            if (orientation3_array(input, p, q, i) > 0) {
+                q = i;
+            }
+        }
+
+        p = q;
+
+    } while (
+        input[p * 2] !== input[l * 2]
+        || input[p * 2 + 1] !== input[l * 2 + 1]
+        );
+
+    return jarvis_vertices;
+}

package/core/geom/2d/convex-hull/convex_hull_jarvis_2d.spec.js

@@ -0,0 +1,33 @@
+import { convex_hull_jarvis_2d } from "./convex_hull_jarvis_2d.js";
+
+test("box with extra points", () => {
+    const hull = convex_hull_jarvis_2d([
+        0, 1,
+        -1, 0,
+        1, 0,
+        0, -1,
+        // extra points inside
+        0.3, 0.3,
+        -0.3, -0.3,
+        0.3, -0.3,
+        -0.3, 0.3
+    ]);
+
+    expect(hull.length).toBe(4);
+
+    expect(hull).toContain(0);
+    expect(hull).toContain(1);
+    expect(hull).toContain(2);
+    expect(hull).toContain(3);
+});
+
+
+test("exact triangle", () => {
+    const hull = convex_hull_jarvis_2d([
+        0, 0,
+        1, 0,
+        1, 1,
+    ]);
+
+    expect(hull.length).toBe(3);
+});

package/core/geom/2d/convex-hull/convex_hull_monotone_2d.js

@@ -0,0 +1,82 @@
+import { orientation3_v2 } from "./orientation3_v2.js";
+
+/**
+ * Ported from https://github.com/mikolalysenko/monotone-convex-hull-2d
+ * @param {number[][]} points
+ * @returns {number}
+ */
+export function convex_hull_monotone_2d(points) {
+    var n = points.length
+
+    if (n < 3) {
+        var result = new Array(n)
+        for (var i = 0; i < n; ++i) {
+            result[i] = i
+        }
+
+        if (n === 2 &&
+            points[0][0] === points[1][0] &&
+            points[0][1] === points[1][1]) {
+            return [0]
+        }
+
+        return result
+    }
+
+    //Sort point indices along x-axis
+    var sorted = new Array(n)
+    for (var i = 0; i < n; ++i) {
+        sorted[i] = i
+    }
+    sorted.sort(function (a, b) {
+        var d = points[a][0] - points[b][0]
+        if (d) {
+            return d
+        }
+        return points[a][1] - points[b][1]
+    })
+
+    //Construct upper and lower hulls
+    var lower = [sorted[0], sorted[1]]
+    var upper = [sorted[0], sorted[1]]
+
+    for (var i = 2; i < n; ++i) {
+        var idx = sorted[i]
+        var p = points[idx]
+
+        //Insert into lower list
+        var m = lower.length
+        while (m > 1 && orientation3_v2(
+            points[lower[m - 2]],
+            points[lower[m - 1]],
+            p) <= 0) {
+            m -= 1
+            lower.pop()
+        }
+        lower.push(idx)
+
+        //Insert into upper list
+        m = upper.length
+        while (m > 1 && orient(
+            points[upper[m - 2]],
+            points[upper[m - 1]],
+            p) >= 0) {
+            m -= 1
+            upper.pop()
+        }
+        upper.push(idx)
+    }
+
+    //Merge lists together
+    var result = new Array(upper.length + lower.length - 2)
+    var ptr = 0
+    for (var i = 0, nl = lower.length; i < nl; ++i) {
+        result[ptr++] = lower[i]
+    }
+    for (var j = upper.length - 2; j > 0; --j) {
+        result[ptr++] = upper[j]
+    }
+
+    //Return result
+    return result
+}

package/core/geom/2d/convex-hull/fixed_convex_hull_humus.js

@@ -0,0 +1,135 @@
+//
+
+import { array_copy } from "../../../collection/array/copyArray.js";
+import { compute_polygon_area_2d } from "../compute_polygon_area_2d.js";
+import { intersect_ray_2d } from "../intersect_ray_2d.js";
+import { UintArrayForCount } from "../../../collection/array/typed/uint_array_for_count.js";
+
+/**
+ * Compute a bounding polygon with a fixed given number of vertices such that the area would be minimal
+ * Uses combinatorial sets of edges to find the subset, which when extending those edges produces poly with minimum area
+ * NOTE: very very slow as it's O(n^k) where n is number of edges and k is number of points on the desired bounding polygon
+ *
+ * @param {number[]|Float32Array} output result will be written here
+ * @param {number} output_offset offset into output array where to write the result
+ * @param {number} output_point_count number of points to comprise bounding polygon
+ * @param {number[]} input_points Points to be bounded, must be an ordered loop
+ * @param {number} input_point_count number of points in the input to consider
+ * @returns {number} actual number of points, this can be lower because input polygon has too few points
+ *
+ * @see 2014 "Implementation of linear minimum area enclosing triangle algorithm" Ovidiu Pârvu & David Gilbert
+ * @see https://github.com/MagnusTiberius/humus3/blob/9d43412d6e6be869e224817f0a966fe48a1af40f/Util/ConvexHull.cpp#L281
+ */
+export function fixed_convex_hull_humus(
+    output, output_offset, output_point_count,
+    input_points, input_point_count
+) {
+    if (output_point_count >= input_point_count) {
+        // special case, input polygon is smaller or equal to in cardinality to what's desired
+        array_copy(input_points, 0, output, output_offset, input_point_count * 2);
+        return input_point_count;
+    }
+
+    /*
+    The following code iterated k-size sets of elements in the set of edges
+    @see https://stackoverflow.com/questions/29910312/algorithm-to-get-all-the-combinations-of-size-n-from-an-array-java
+    @see https://en.wikipedia.org/wiki/Combination
+     */
+
+    const edge_count = input_point_count;
+    const k = output_point_count;
+
+    const ArrayConstructor = UintArrayForCount(k);
+
+    const s = new ArrayConstructor(k);
+
+    let combos = 0;
+    let combos_valid = 0;
+
+    const intersections = new Float64Array(k * 2);
+    let best_area = Infinity;
+
+    /**
+     *
+     * @param {number[]|Uint16Array} subset
+     */
+    function process_combination(subset) {
+        combos++;
+
+        for (let i = 0; i < k; i++) {
+            const i0 = subset[i];
+            const i1 = subset[(i + 1) % k];
+
+            const a0x = input_points[i0 * 2];
+            const a0y = input_points[i0 * 2 + 1];
+
+            const a1 = (i0 + 1) % input_point_count;
+
+            const a1x = input_points[a1 * 2];
+            const a1y = input_points[a1 * 2 + 1];
+
+            const b0x = input_points[i1 * 2];
+            const b0y = input_points[i1 * 2 + 1];
+            const b1 = (i1 + 1) % input_point_count;
+            const b1x = input_points[b1 * 2];
+            const b1y = input_points[b1 * 2 + 1];
+
+            const a_dir_x = a1x - a0x;
+            const a_dir_y = a1y - a0y;
+
+            const b_dir_x = b1x - b0x;
+            const b_dir_y = b1y - b0y;
+
+            if (!intersect_ray_2d(
+                intersections, i * 2,
+                a0x, a0y, a_dir_x, a_dir_y,
+                b0x, b0y, b_dir_x, b_dir_y
+            )) {
+                // invalid combination, edges do not meet
+                return;
+            }
+        }
+
+        // we got intersection points, lets compute area
+        const area = compute_polygon_area_2d(intersections, k);
+
+        if (area < best_area) {
+            array_copy(intersections, 0, output, output_offset, k * 2);
+            best_area = area;
+        }
+
+        combos_valid++;
+    }
+
+
+    for (let i = 0; (s[i] = i) < k - 1; i++) {
+        // populate initial set
+    }
+
+    process_combination(s);
+
+    for (; ;) {
+        let i;
+
+        for (i = k - 1; i >= 0 && s[i] === edge_count - k + i; i--) {
+            // find position of item that can be incremented
+        }
+
+        if (i < 0) {
+            break;
+        }
+
+        s[i]++; // increment this item
+
+        for (++i; i < k; i++) {
+            // fill up remaining items
+            s[i] = s[i - 1] + 1;
+        }
+
+        process_combination(s);
+    }
+
+    console.log(`combinations:  ${combos}, valid: ${combos_valid} (${(combos_valid * 100 / combos).toFixed(2)}%)`);
+
+    return output_point_count;
+}