@woosh/meep-engine 3.56.0 → 3.57.0

package/src/core/debug/matchers/DescribeAs.js

@@ -1,64 +1,62 @@
-import { BaseMatcher } from "../BaseMatcher.js";
-import { NullDescription } from "../NullDescription.js";
-
-
-const RX = /%([0-9]+)/gi;
-
-export class DescribeAs extends BaseMatcher {
-    /**
-     * @type {string}
-     */
-    template
-    /**
-     * @type {Matcher}
-     */
-    matcher
-    /**
-     * @type {Array}
-     */
-    values
-
-    /**
-     *
-     * @param {string} template
-     * @param {Matcher} matcher
-     * @param {Array} values
-     */
-    constructor(template, matcher, values) {
-        super();
-
-        this.template = template;
-        this.matcher = matcher;
-        this.values = values;
-    }
-
-    matches(item, mismatch_description = NullDescription.INSTANCE) {
-        return this.matcher.matches(item, mismatch_description);
-    }
-
-    describeTo(description) {
-
-        let textStart = 0;
-
-        const matches = this.template.matchAll(RX);
-
-        for (let i = 0; i < matches.length; i++) {
-            const match = matches[i];
-
-            description.appendText(this.template.substring(textStart, match.index));
-
-            const group_index = parseInt(match.groups[1]);
-
-            description.appendValue(this.values[group_index]);
-
-            textStart = match[0].length;
-        }
-        if (textStart < this.template.length) {
-            description.appendText(this.template.slice(textStart));
-        }
-    }
-
-    describeMismatch(item, mismatch_description) {
-        this.matcher.describeMismatch(item, mismatch_description);
-    }
-}
+import { BaseMatcher } from "../BaseMatcher.js";
+import { NullDescription } from "../NullDescription.js";
+
+
+const RX = /%([0-9]+)/gi;
+
+export class DescribeAs extends BaseMatcher {
+    /**
+     * @type {string}
+     */
+    template
+    /**
+     * @type {Matcher}
+     */
+    matcher
+    /**
+     * @type {Array}
+     */
+    values
+
+    /**
+     *
+     * @param {string} template
+     * @param {Matcher} matcher
+     * @param {Array} values
+     */
+    constructor(template, matcher, values) {
+        super();
+
+        this.template = template;
+        this.matcher = matcher;
+        this.values = values;
+    }
+
+    matches(item, mismatch_description = NullDescription.INSTANCE) {
+        return this.matcher.matches(item, mismatch_description);
+    }
+
+    describeTo(description) {
+
+        let textStart = 0;
+
+        const matches = this.template.matchAll(RX);
+
+        for (const match of matches) {
+            description.appendText(this.template.substring(textStart, match.index));
+
+            const group_index = parseInt(match[1]);
+
+            description.appendValue(this.values[group_index]);
+
+            textStart = match.index + match[0].length;
+        }
+        if (textStart < this.template.length) {
+            description.appendText(this.template.slice(textStart));
+        }
+    }
+
+    describeMismatch(item, mismatch_description) {
+        this.matcher.describeMismatch(item, mismatch_description);
+    }
+}

package/src/core/function/FunctionCompiler.js

@@ -6,7 +6,7 @@ import { isArrayEqualStrict } from "../collection/array/isArrayEqualStrict.js";
 import { invokeObjectEquals } from "../model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../model/object/invokeObjectHash.js";
 import { computeStringHash } from "../primitives/strings/computeStringHash.js";
-import { string_compute_byte_size } from "../primitives/strings/string_compute_byte_size.js";
+import { utf8_encoded_length } from "../binary/utf8/utf8_encoded_length.js";
 
 /**
  * Hash is an integer value, so this is an invalid value for a computed hash
@@ -63,17 +63,17 @@ class FunctionDefinition {
      */
     computeByteSize() {
 
-        let result = string_compute_byte_size(this.body);
+        let result = utf8_encoded_length(this.body);
 
         if (this.name !== undefined) {
-            result += string_compute_byte_size(this.name);
+            result += utf8_encoded_length(this.name);
         }
 
         const n = this.args.length;
         for (let i = 0; i < n; i++) {
             const arg = this.args[i];
 
-            result += string_compute_byte_size(arg);
+            result += utf8_encoded_length(arg);
         }
 
         return result;

package/src/core/function/objectsEqual.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"objectsEqual.d.ts","sourceRoot":"","sources":["../../../../src/core/function/objectsEqual.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,8CAFa,OAAO,CAWnB"}
+{"version":3,"file":"objectsEqual.d.ts","sourceRoot":"","sources":["../../../../src/core/function/objectsEqual.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,8CAFa,OAAO,CAYnB"}

package/src/core/function/objectsEqual.js

@@ -9,8 +9,9 @@ export function objectsEqual(a, b) {
         || (
             typeof a === "object" // guard against undefined values
             && a !== null // typeof null === "object", so null must be excluded explicitly
-            && b !== null && b !== undefined
+            && typeof b === "object"
+            && b !== null
             && typeof a.equals === "function" // check for equals method
             && a.equals(b)
         );
-}
+}

package/src/core/geom/2d/bvh/BVH2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BVH2D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/bvh/BVH2D.js"],"names":[],"mappings":"AAUA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAE/B;;;;;GAKG;AACH,+BAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEoB;AAgBpC;;;;GAIG;AACH;IAEI;;;;OAIG;IACH,sBAA2E;IAE3E;;;;OAIG;IACH,uBAAsD;IAEtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAEnB;;;OAGG;IACH,mBAEC;IAUD;;;OAGG;IACH,6BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBAqBC;IAED;;OAEG;IACH,aAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAmDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAa/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAkBpC;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAWlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MAEN,MAAM,MACN,MAAM,QAkBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAkBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CA6BlB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAgBhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CAgHhB;IAED;;;;;OAKG;IACH,wBAuBC;IAED;;;;OAIG;IACH,yBA4BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;OAMG;IACH,gBAuMC;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,mBAHW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,KAAK,KAAK,IAAI,mBAiC3C;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;CACJ"}
+{"version":3,"file":"BVH2D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/bvh/BVH2D.js"],"names":[],"mappings":"AAUA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAE/B;;;;;GAKG;AACH,+BAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEoB;AAgBpC;;;;GAIG;AACH;IAEI;;;;OAIG;IACH,sBAA2E;IAE3E;;;;OAIG;IACH,uBAAsD;IAEtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAEnB;;;OAGG;IACH,mBAEC;IAUD;;;OAGG;IACH,6BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBAqBC;IAED;;OAEG;IACH,aAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAmDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAa/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAkBpC;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAWlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MAEN,MAAM,MACN,MAAM,QAkBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAkBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CA6BlB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAgBhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CAgHhB;IAED;;;;;OAKG;IACH,wBAuBC;IAED;;;;OAIG;IACH,yBA6BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;OAMG;IACH,gBAuMC;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,mBAHW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,KAAK,KAAK,IAAI,mBAiC3C;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;CACJ"}

package/src/core/geom/2d/bvh/BVH2D.js

@@ -678,7 +678,7 @@ export class BVH2D {
         const uint32 = this.__data_uint32;
 
         do {
-            index = this.balance(index);
+
 
             const address = index * ELEMENT_WORD_COUNT;
 
@@ -707,9 +707,10 @@ export class BVH2D {
 
         const uint32 = this.__data_uint32;
 
-        while (index !== NULL_NODE) {
+        while (index !== NULL_NODE) {
             index = this.balance(index);
 
+
             const node_address = index * ELEMENT_WORD_COUNT;
 
             const child1 = uint32[node_address + COLUMN_CHILD_1];
@@ -806,7 +807,7 @@ export class BVH2D {
         const iC = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
         assert.notEqual(iA, iB, 'child1 equal to parent');
-        assert.notEqual(iA, iB, 'child2 equal to parent');
+        assert.notEqual(iA, iC, 'child2 equal to parent');
 
         assert.greaterThanOrEqual(iB, 0);
         assert.lessThan(iB, this.__capacity);

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.d.ts

@@ -11,7 +11,10 @@
  * @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. Winding is not significant - both orders give the same result
  * @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
+ * @param {ArrayLike<number>|null} [bounds] `[x0, y0, x1, y1]` box the bounding polygon must stay inside; an edge
+ *        whose removal would put a vertex outside it is never removed. The input must lie inside it.
+ * @returns {number} actual number of points, this can be lower because input polygon has too few points, or higher
+ *          when `bounds` is given and leaves no edge that can be removed, in which case nothing is written
  */
-export function convex_hull_fixed_count_2d_relaxation(output: number[] | Float32Array, output_offset: number, output_point_count: number, input_points: number[], input_point_count: number): number;
+export function convex_hull_fixed_count_2d_relaxation(output: number[] | Float32Array, output_offset: number, output_point_count: number, input_points: number[], input_point_count: number, bounds?: ArrayLike<number> | null): number;
 //# sourceMappingURL=convex_hull_fixed_count_2d_relaxation.d.ts.map

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex_hull_fixed_count_2d_relaxation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.js"],"names":[],"mappings":"AAkLA;;;;;;;;;;;;;;GAcG;AACH,8DAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,GACJ,MAAM,CA+FlB"}
+{"version":3,"file":"convex_hull_fixed_count_2d_relaxation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.js"],"names":[],"mappings":"AA4MA;;;;;;;;;;;;;;;;;GAiBG;AACH,8DAVW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,sBACN,MAAM,gBACN,MAAM,EAAE,qBACR,MAAM,WACN,UAAU,MAAM,CAAC,GAAC,IAAI,GAEpB,MAAM,CAyGlB"}

package/src/core/geom/2d/convex-hull/convex_hull_fixed_count_2d_relaxation.js

@@ -108,19 +108,44 @@ function build_edges(point_offset, point_count) {
     return edges;
 }
 
+/**
+ * Whether the point lies inside `bounds` (`[x0, y0, x1, y1]`), or there are no bounds. Collapse targets are computed
+ * in single precision, so a target that belongs exactly on the box's edge, between two input points on it, is let
+ * through at float32 resolution of the box's size.
+ * @param {ArrayLike<number>|null} bounds
+ * @param {number} x
+ * @param {number} y
+ * @returns {boolean}
+ */
+function within_bounds(bounds, x, y) {
+    if (bounds === null) {
+        return true;
+    }
+    const tolerance = (bounds[2] - bounds[0] + bounds[3] - bounds[1]) * FLOAT32_RESOLUTION;
+    return x >= bounds[0] - tolerance && y >= bounds[1] - tolerance
+        && x <= bounds[2] + tolerance && y <= bounds[3] + tolerance;
+}
+
+/**
+ * Relative spacing of float32 values near 1, a few ulps of the point buffer's precision.
+ * @type {number}
+ */
+const FLOAT32_RESOLUTION = 4 * 2 ** -23;
+
 /**
  *
  * @param {Edge} edge
  * @param {number[]|Float32Array|Float64Array} vertex_buffer
  * @param {number} new_vertex_index
+ * @param {ArrayLike<number>|null} bounds
  */
-function collapse_edge(edge, vertex_buffer, new_vertex_index) {
+function collapse_edge(edge, vertex_buffer, new_vertex_index, bounds) {
     // this edge will be removed, previous and next edges will receive a new vertex where they connected to this edge
     // adjacent edges will become neighbours
 
     const valid = compute_collapse_target(v2_temp, 0, edge, vertex_buffer);
 
-    if (!valid) {
+    if (!valid || !within_bounds(bounds, v2_temp[0], v2_temp[1])) {
         return false;
     }
 
@@ -146,9 +171,10 @@ function collapse_edge(edge, vertex_buffer, new_vertex_index) {
  *
  * @param {Edge} edge
  * @param {number[]|Float64Array|Float32Array} vertex_buffer
+ * @param {ArrayLike<number>|null} bounds
  */
-function compute_collapse_cost(edge, vertex_buffer) {
-    if (!compute_collapse_target(v2_temp, 0, edge, vertex_buffer)) {
+function compute_collapse_cost(edge, vertex_buffer, bounds) {
+    if (!compute_collapse_target(v2_temp, 0, edge, vertex_buffer) || !within_bounds(bounds, v2_temp[0], v2_temp[1])) {
         return Infinity;
     }
 
@@ -189,11 +215,15 @@ const RETRY_MAX_COUNT = 1000;
  * @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. Winding is not significant - both orders give the same result
  * @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
+ * @param {ArrayLike<number>|null} [bounds] `[x0, y0, x1, y1]` box the bounding polygon must stay inside; an edge
+ *        whose removal would put a vertex outside it is never removed. The input must lie inside it.
+ * @returns {number} actual number of points, this can be lower because input polygon has too few points, or higher
+ *          when `bounds` is given and leaves no edge that can be removed, in which case nothing is written
  */
 export function convex_hull_fixed_count_2d_relaxation(
     output, output_offset, output_point_count,
-    input_points, input_point_count
+    input_points, input_point_count,
+    bounds = null
 ) {
 
     if (output_point_count >= input_point_count) {
@@ -226,7 +256,7 @@ export function convex_hull_fixed_count_2d_relaxation(
 
     // build costs for edges
     for (let i = 0; i < input_point_count; i++) {
-        const cost = compute_collapse_cost(edges[i], point_buffer);
+        const cost = compute_collapse_cost(edges[i], point_buffer, bounds);
         edge_heap.insert(i, cost);
     }
 
@@ -237,14 +267,17 @@ export function convex_hull_fixed_count_2d_relaxation(
 
         const edge = edges[victim];
 
-        if (!collapse_edge(edge, point_buffer, point_buffer_cursor)) {
+        if (!collapse_edge(edge, point_buffer, point_buffer_cursor, bounds)) {
             // couldn't collapse, re-insert with very high score so other edges are tried first
             edge_heap.insert(victim, Infinity);
 
             retry++;
 
             if (retry >= RETRY_MAX_COUNT) {
-                console.warn('Failed to collapse an edge after maximum number of retries has been reached');
+                if (bounds === null) {
+                    // bounded, being stuck is an answer the caller gets back as the vertex count
+                    console.warn('Failed to collapse an edge after maximum number of retries has been reached');
+                }
                 break;
             }
 
@@ -262,8 +295,13 @@ export function convex_hull_fixed_count_2d_relaxation(
         // update costs for surviving neighbours
         const next_index = edge.next.index;
         const prev_index = edge.prev.index;
-        edge_heap.update_score(next_index, compute_collapse_cost(edges[next_index], point_buffer));
-        edge_heap.update_score(prev_index, compute_collapse_cost(edges[prev_index], point_buffer));
+        edge_heap.update_score(next_index, compute_collapse_cost(edges[next_index], point_buffer, bounds));
+        edge_heap.update_score(prev_index, compute_collapse_cost(edges[prev_index], point_buffer, bounds));
+    }
+
+    if (bounds !== null && live_edge_set.size > output_point_count) {
+        // stuck: every remaining collapse leaves the bounds or diverges, and the output has no room for the rest
+        return live_edge_set.size;
     }
 
     // pick first edge to start walking

package/src/core/geom/2d/hash-grid/shg_query_elements_circle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shg_query_elements_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/shg_query_elements_circle.js"],"names":[],"mappings":"AA2CA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,mCAEN,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAyGlB"}
+{"version":3,"file":"shg_query_elements_circle.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/shg_query_elements_circle.js"],"names":[],"mappings":"AAWA;;;;;;;;;GASG;AACH,kDARW,MAAM,EAAE,iBACR,MAAM,mCAEN,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAoGlB"}

package/src/core/geom/2d/hash-grid/shg_query_elements_circle.js

@@ -1,159 +1,122 @@
-import { max2 } from "../../../math/max2.js";
-import { min2 } from "../../../math/min2.js";
-import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
-import {
-    COLUMN_ELEMENT_X0,
-    COLUMN_ELEMENT_X1,
-    COLUMN_ELEMENT_Y0,
-    COLUMN_ELEMENT_Y1,
-    NULL_POINTER
-} from "./SpatialHashGrid.js";
-
-/**
- * @see https://stackoverflow.com/questions/47639413/algorithm-for-accurate-detection-of-overlap-between-a-square-and-a-circle
- * @param square_center_x
- * @param square_center_y
- * @param circle_center_x
- * @param circle_center_y
- * @param circle_radius
- * @return {boolean}
- */
-function unit_square_intersects_circle(
-    square_center_x,
-    square_center_y,
-    circle_center_x,
-    circle_center_y,
-    circle_radius
-) {
-
-    const x = Math.abs(circle_center_x - square_center_x) - 0.5;
-    const y = Math.abs(circle_center_y - square_center_y) - 0.5;
-
-    if (x > 0) {
-        if (y > 0) {
-            return x * x + y * y < circle_radius * circle_radius;
-        } else {
-            return x < circle_radius;
-        }
-    } else {
-        return y < circle_radius;
-    }
-
-}
-
-/**
- *
- * @param {number[]} result
- * @param {number} result_offset
- * @param {SpatialHashGrid} grid
- * @param {number} center_x
- * @param {number} center_y
- * @param {number} radius
- * @returns {number}
- */
-export function shg_query_elements_circle(
-    result, result_offset,
-    grid,
-    center_x, center_y,
-    radius
-) {
-
-    // shg_query_elements_circle.visited.splice(0, shg_query_elements_circle.visited.length); // DEBUG
-
-    const scale_inverse = grid.scale_inverse;
-    const grid_size_x = grid.size_x;
-    const grid_size_y = grid.size_y;
-
-    // rasterize circle aabb
-
-    const grid_center_x = center_x * scale_inverse;
-    const grid_center_y = center_y * scale_inverse;
-
-    const grid_radius = radius * scale_inverse;
-
-    const aabb_x0 = max2(
-        Math.floor(grid_center_x - grid_radius),
-        0
-    );
-    const aabb_y0 = max2(
-        Math.floor(grid_center_y - grid_radius),
-        0
-    );
-
-    const aabb_x1 = min2(
-        Math.floor(grid_center_x + grid_radius),
-        grid_size_x - 1
-    );
-    const aabb_y1 = min2(
-        Math.floor(grid_center_y + grid_radius),
-        grid_size_y - 1
-    );
-
-    let result_count = 0;
-
-    const radius2 = radius * radius;
-
-    const element_pool = grid.element_pool;
-    const element_float32 = element_pool.data_float32;
-
-    for (let y = aabb_y0; y <= aabb_y1; y++) {
-        for (let x = aabb_x0; x <= aabb_x1; x++) {
-
-            if (unit_square_intersects_circle(
-                x + 0.5,
-                y + 0.5,
-                grid_center_x,
-                grid_center_y,
-                grid_radius
-            )) {
-
-                // cell is inside the circle
-
-                // shg_query_elements_circle.visited.push(x, y); // DEBUG
-
-
-                const cell_index = grid.cell_position_to_index(x, y);
-
-
-                let node = grid.cell_get_first_node(cell_index);
-
-                while (node !== NULL_POINTER) {
-
-                    const element = grid.node_get_element(node);
-
-                    // check element bounds
-                    const element_address = element_pool.element_word(element);
-
-                    const element_x0 = element_float32[element_address + COLUMN_ELEMENT_X0];
-                    const element_y0 = element_float32[element_address + COLUMN_ELEMENT_Y0];
-                    const element_x1 = element_float32[element_address + COLUMN_ELEMENT_X1];
-                    const element_y1 = element_float32[element_address + COLUMN_ELEMENT_Y1];
-
-                    const distance_to_center = aabb2_distance_sqr_to_point(
-                        element_x0, element_y0,
-                        element_x1, element_y1,
-                        center_x, center_y
-                    );
-
-                    if (distance_to_center <= radius2) {
-                        //  intersection with the element
-                        result[result_offset + result_count] = element;
-
-                        result_count++;
-                    }
-
-
-                    // read out next element in the linked list
-                    node = grid.node_get_same_cell_next_node(node);
-
-                }
-
-            }
-
-        }
-    }
-
-    return result_count;
-}
-
-// shg_query_elements_circle.visited = []; // DEBUG
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
+import {
+    COLUMN_ELEMENT_X0,
+    COLUMN_ELEMENT_X1,
+    COLUMN_ELEMENT_Y0,
+    COLUMN_ELEMENT_Y1,
+    NULL_POINTER
+} from "./SpatialHashGrid.js";
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {SpatialHashGrid} grid
+ * @param {number} center_x
+ * @param {number} center_y
+ * @param {number} radius
+ * @returns {number}
+ */
+export function shg_query_elements_circle(
+    result, result_offset,
+    grid,
+    center_x, center_y,
+    radius
+) {
+
+    // shg_query_elements_circle.visited.splice(0, shg_query_elements_circle.visited.length); // DEBUG
+
+    const scale_inverse = grid.scale_inverse;
+    const grid_size_x = grid.size_x;
+    const grid_size_y = grid.size_y;
+
+    // rasterize circle aabb
+
+    const grid_center_x = center_x * scale_inverse;
+    const grid_center_y = center_y * scale_inverse;
+
+    const grid_radius = radius * scale_inverse;
+    const grid_radius2 = grid_radius * grid_radius;
+
+    const aabb_x0 = max2(
+        Math.floor(grid_center_x - grid_radius),
+        0
+    );
+    const aabb_y0 = max2(
+        Math.floor(grid_center_y - grid_radius),
+        0
+    );
+
+    const aabb_x1 = min2(
+        Math.floor(grid_center_x + grid_radius),
+        grid_size_x - 1
+    );
+    const aabb_y1 = min2(
+        Math.floor(grid_center_y + grid_radius),
+        grid_size_y - 1
+    );
+
+    let result_count = 0;
+
+    const radius2 = radius * radius;
+
+    const element_pool = grid.element_pool;
+    const element_float32 = element_pool.data_float32;
+
+    for (let y = aabb_y0; y <= aabb_y1; y++) {
+        for (let x = aabb_x0; x <= aabb_x1; x++) {
+
+            if (aabb2_distance_sqr_to_point(x, y, x + 1, y + 1, grid_center_x, grid_center_y) < grid_radius2) {
+
+                // cell is inside the circle
+
+                // shg_query_elements_circle.visited.push(x, y); // DEBUG
+
+
+                const cell_index = grid.cell_position_to_index(x, y);
+
+
+                let node = grid.cell_get_first_node(cell_index);
+
+                while (node !== NULL_POINTER) {
+
+                    const element = grid.node_get_element(node);
+
+                    // check element bounds
+                    const element_address = element_pool.element_word(element);
+
+                    const element_x0 = element_float32[element_address + COLUMN_ELEMENT_X0];
+                    const element_y0 = element_float32[element_address + COLUMN_ELEMENT_Y0];
+                    const element_x1 = element_float32[element_address + COLUMN_ELEMENT_X1];
+                    const element_y1 = element_float32[element_address + COLUMN_ELEMENT_Y1];
+
+                    const distance_to_center = aabb2_distance_sqr_to_point(
+                        element_x0, element_y0,
+                        element_x1, element_y1,
+                        center_x, center_y
+                    );
+
+                    if (distance_to_center <= radius2) {
+                        //  intersection with the element
+                        result[result_offset + result_count] = element;
+
+                        result_count++;
+                    }
+
+
+                    // read out next element in the linked list
+                    node = grid.node_get_same_cell_next_node(node);
+
+                }
+
+            }
+
+        }
+    }
+
+    return result_count;
+}
+
+// shg_query_elements_circle.visited = []; // DEBUG

package/src/core/geom/2d/hash-grid/shg_query_elements_line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shg_query_elements_line.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/shg_query_elements_line.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH,gDATW,MAAM,EAAE,iBACR,MAAM,6BAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CA+GlB"}
+{"version":3,"file":"shg_query_elements_line.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/hash-grid/shg_query_elements_line.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;GAWG;AACH,gDATW,MAAM,EAAE,iBACR,MAAM,6BAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAiHlB"}