@woosh/meep-engine 2.42.8 → 2.43.1

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

@@ -0,0 +1,282 @@
+import { array_copy } from "../../../collection/array/copyArray.js";
+import { Uint32Heap } from "../../../collection/heap/Uint32Heap.js";
+import { intersect_ray_2d } from "../intersect_ray_2d.js";
+import { compute_triangle_area_2d } from "../compute_triangle_area_2d.js";
+
+
+const v2_temp = new Float32Array(2);
+
+class Edge {
+    /**
+     * Unique index of this edge
+     * @type {number}
+     */
+    index;
+    /**
+     * Index into position buffer
+     * @type {number}
+     */
+    v0;
+    /**
+     * Index into position buffer
+     * @type {number}
+     */
+    v1;
+
+    /**
+     * @type {Edge}
+     */
+    next;
+    /**
+     * @type {Edge}
+     */
+    prev;
+}
+
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {Edge} edge
+ * @param {number[]} vertex_buffer
+ * @returns {boolean}
+ */
+function compute_collapse_target(output, output_offset, edge, vertex_buffer) {
+    const a0 = edge.prev.v0;
+    const a1 = edge.prev.v1;
+
+    const b0 = edge.next.v0;
+    const b1 = edge.next.v1;
+
+    const a0x = vertex_buffer[a0 * 2];
+    const a0y = vertex_buffer[a0 * 2 + 1];
+
+    const a1x = vertex_buffer[a1 * 2];
+    const a1y = vertex_buffer[a1 * 2 + 1];
+
+    const b0x = vertex_buffer[b0 * 2];
+    const b0y = vertex_buffer[b0 * 2 + 1];
+
+    const b1x = vertex_buffer[b1 * 2];
+    const b1y = vertex_buffer[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;
+
+    return intersect_ray_2d(
+        output, output_offset,
+        a0x, a0y, a_dir_x, a_dir_y,
+        b0x, b0y, b_dir_x, b_dir_y
+    );
+}
+
+/**
+ *
+ * @param {number} point_offset
+ * @param {number} point_count
+ * @returns {Edge[]}
+ */
+function build_edges(point_offset, point_count) {
+    /**
+     *
+     * @type {Edge[]}
+     */
+    const edges = [];
+
+    for (let i = 0; i < point_count; i++) {
+        const edge = new Edge();
+
+        edge.index = i;
+
+        edge.v0 = i + point_offset;
+        edge.v1 = (i + 1) % point_count + point_offset;
+
+        edges[i] = edge;
+    }
+
+    // connect edges
+    for (let i = 0; i < point_count; i++) {
+        const edge = edges[i];
+
+        edge.next = edges[(i + 1) % point_count];
+        edge.prev = edges[(point_count + i - 1) % point_count];
+    }
+
+    return edges;
+}
+
+/**
+ *
+ * @param {Edge} edge
+ * @param {number[]|Float32Array|Float64Array} vertex_buffer
+ * @param {number} new_vertex_index
+ */
+function collapse_edge(edge, vertex_buffer, new_vertex_index) {
+    // 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) {
+        return false;
+    }
+
+    const next = edge.next;
+    const prev = edge.prev;
+
+    // connect edges together
+    next.prev = prev;
+    prev.next = next;
+
+    // inject new vertex
+
+    next.v0 = new_vertex_index;
+    prev.v1 = new_vertex_index;
+
+    //write out new vertex
+    array_copy(v2_temp, 0, vertex_buffer, new_vertex_index * 2, 2);
+
+    return true;
+}
+
+/**
+ *
+ * @param {Edge} edge
+ * @param {number[]|Float64Array|Float32Array} vertex_buffer
+ */
+function compute_collapse_cost(edge, vertex_buffer) {
+    if (!compute_collapse_target(v2_temp, 0, edge, vertex_buffer)) {
+        return Infinity;
+    }
+
+    const v0x = vertex_buffer[edge.v0 * 2];
+    const v0y = vertex_buffer[edge.v0 * 2 + 1];
+
+    const v1x = vertex_buffer[edge.v1 * 2];
+    const v1y = vertex_buffer[edge.v1 * 2 + 1];
+
+    const area = compute_triangle_area_2d(
+        v0x, v0y, v2_temp[0], v2_temp[1], v1x, v1y
+    );
+
+    //
+    // if (area < 0 || Number.isNaN(area)) {
+    //     debugger;
+    // }
+
+    return area;
+}
+
+/**
+ * Will throw an error after not being able to collapse an edge for this many cycles
+ * @readonly
+ * @type {number}
+ */
+const RETRY_MAX_COUNT = 1000;
+
+/**
+ * Relaxes existing convex hull by removing edges until desired cardinality of the hull is reached
+ * The algorithm reaches the similar solution as the one proposed by humus, but arrives at a solution much faster as it doesn't need to consider every combination of edges
+ * The algorithm is greedy, and thus it can lead to suboptimal cuts, especially on lower number of output vertices
+ *
+ * @copyright Alex Goldring 2022
+ *
+ * @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
+ */
+export function fixed_convex_hull_relaxation(
+    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;
+    }
+
+
+    /**
+     * Point buffer will be twice as large as the input to have enough space for collapsing all the edges and recording
+     * new unique vertices produced
+     * @type {Float64Array}
+     */
+    const point_buffer = new Float32Array(input_point_count * 4);
+
+    array_copy(input_points, 0, point_buffer, 0, input_point_count * 2);
+
+    /**
+     * Offset into point buffer
+     * @type {number}
+     */
+    let point_buffer_cursor = input_point_count;
+
+    const edges = build_edges(0, input_point_count);
+    const live_edge_set = new Set(edges);
+
+    const edge_heap = new Uint32Heap(input_point_count);
+
+
+    // build costs for edges
+    for (let i = 0; i < input_point_count; i++) {
+        const cost = compute_collapse_cost(edges[i], point_buffer);
+        edge_heap.insert(i, cost);
+    }
+
+    let retry = 0;
+
+    while (live_edge_set.size > output_point_count) {
+        const victim = edge_heap.pop_min();
+
+        const edge = edges[victim];
+
+        if (!collapse_edge(edge, point_buffer, point_buffer_cursor)) {
+            // couldn't collapse, re-insert with very high score
+            edge_heap.insert(victim, Infinity);
+
+            if (retry >= RETRY_MAX_COUNT) {
+                console.warn('Failed to collapse an edge after maximum number of retries has been reached');
+                break;
+            }
+
+            retry++;
+        }
+
+        retry = 0;
+
+        point_buffer_cursor++;
+
+        live_edge_set.delete(edge);
+
+        // 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));
+    }
+
+    // pick first edge to start walking
+    const first_live_edge = live_edge_set.values().next().value;
+    let e = first_live_edge;
+
+    let output_cursor = output_offset;
+
+    do {
+        // walk the loop, recording first vertex of each edge we visit
+
+        array_copy(point_buffer, e.v0 * 2, output, output_cursor, 2);
+        e = e.next;
+
+        output_cursor += 2;
+
+    } while (e !== first_live_edge);
+
+    // number of output vertices is derived from how many we recorded
+    return (output_cursor - output_offset) / 2;
+}

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

@@ -0,0 +1,444 @@
+var EPSILON = 1.1102230246251565e-16
+var ERRBOUND3 = (3.0 + 16.0 * EPSILON) * EPSILON
+const sum = linearExpansionSum;
+const prod = robustProduct;
+const sub = robustSubtract;
+
+function robustSubtract(e, f) {
+    var ne = e.length;
+    var nf = f.length;
+
+    var n = ne + nf
+    var g = new Array(n)
+    var count = 0
+    var eptr = 0
+    var fptr = 0
+    var abs = Math.abs
+    var ei = e[eptr]
+    var ea = abs(ei)
+    var fi = -f[fptr]
+    var fa = abs(fi)
+    var a, b
+    if (ea < fa) {
+        b = ei
+        eptr += 1
+        if (eptr < ne) {
+            ei = e[eptr]
+            ea = abs(ei)
+        }
+    } else {
+        b = fi
+        fptr += 1
+        if (fptr < nf) {
+            fi = -f[fptr]
+            fa = abs(fi)
+        }
+    }
+    if ((eptr < ne && ea < fa) || (fptr >= nf)) {
+        a = ei
+        eptr += 1
+        if (eptr < ne) {
+            ei = e[eptr]
+            ea = abs(ei)
+        }
+    } else {
+        a = fi
+        fptr += 1
+        if (fptr < nf) {
+            fi = -f[fptr]
+            fa = abs(fi)
+        }
+    }
+    var x = a + b
+    var bv = x - a
+    var y = b - bv
+    var q0 = y
+    var q1 = x
+    var _x, _bv, _av, _br, _ar
+    while (eptr < ne && fptr < nf) {
+        if (ea < fa) {
+            a = ei
+            eptr += 1
+            if (eptr < ne) {
+                ei = e[eptr]
+                ea = abs(ei)
+            }
+        } else {
+            a = fi
+            fptr += 1
+            if (fptr < nf) {
+                fi = -f[fptr]
+                fa = abs(fi)
+            }
+        }
+        b = q0
+        x = a + b
+        bv = x - a
+        y = b - bv
+        if (y) {
+            g[count++] = y
+        }
+        _x = q1 + x
+        _bv = _x - q1
+        _av = _x - _bv
+        _br = x - _bv
+        _ar = q1 - _av
+        q0 = _ar + _br
+        q1 = _x
+    }
+    while (eptr < ne) {
+        a = ei
+        b = q0
+        x = a + b
+        bv = x - a
+        y = b - bv
+        if (y) {
+            g[count++] = y
+        }
+        _x = q1 + x
+        _bv = _x - q1
+        _av = _x - _bv
+        _br = x - _bv
+        _ar = q1 - _av
+        q0 = _ar + _br
+        q1 = _x
+        eptr += 1
+        if (eptr < ne) {
+            ei = e[eptr]
+        }
+    }
+    while (fptr < nf) {
+        a = fi
+        b = q0
+        x = a + b
+        bv = x - a
+        y = b - bv
+        if (y) {
+            g[count++] = y
+        }
+        _x = q1 + x
+        _bv = _x - q1
+        _av = _x - _bv
+        _br = x - _bv
+        _ar = q1 - _av
+        q0 = _ar + _br
+        q1 = _x
+        fptr += 1
+        if (fptr < nf) {
+            fi = -f[fptr]
+        }
+    }
+    if (q0) {
+        g[count++] = q0
+    }
+    if (q1) {
+        g[count++] = q1
+    }
+    if (!count) {
+        g[count++] = 0.0
+    }
+    g.length = count
+    return g
+}
+
+function robustProduct(a, b) {
+    let r = [0]
+    if (a.length < b.length) {
+        for (var i = 0; i < a.length; ++i) {
+            r = linearExpansionSum(r, scaleLinearExpansion(b, a[i]))
+        }
+    } else {
+        for (var i = 0; i < b.length; ++i) {
+            r = linearExpansionSum(r, scaleLinearExpansion(a, b[i]))
+        }
+    }
+    return r
+}
+
+var SPLITTER = +(Math.pow(2, 27) + 1.0)
+
+function twoProduct(a, b, result) {
+    var x = a * b
+
+    var c = SPLITTER * a
+    var abig = c - a
+    var ahi = c - abig
+    var alo = a - ahi
+
+    var d = SPLITTER * b
+    var bbig = d - b
+    var bhi = d - bbig
+    var blo = b - bhi
+
+    var err1 = x - (ahi * bhi)
+    var err2 = err1 - (alo * bhi)
+    var err3 = err2 - (ahi * blo)
+
+    var y = alo * blo - err3
+
+    if (result) {
+        result[0] = y
+        result[1] = x
+        return result
+    }
+
+    return [y, x]
+}
+
+function twoSum(a, b, result) {
+    var x = a + b
+    var bv = x - a
+    var av = x - bv
+    var br = b - bv
+    var ar = a - av
+    if (result) {
+        result[0] = ar + br
+        result[1] = x
+        return result
+    }
+    return [ar + br, x]
+}
+
+function scaleLinearExpansion(e, scale) {
+    var n = e.length
+    if (n === 1) {
+        var ts = twoProduct(e[0], scale)
+        if (ts[0]) {
+            return ts
+        }
+        return [ts[1]]
+    }
+    var g = new Array(2 * n)
+    var q = [0.1, 0.1]
+    var t = [0.1, 0.1]
+    var count = 0
+    twoProduct(e[0], scale, q)
+    if (q[0]) {
+        g[count++] = q[0]
+    }
+    for (var i = 1; i < n; ++i) {
+        twoProduct(e[i], scale, t)
+        var pq = q[1]
+        twoSum(pq, t[0], q)
+        if (q[0]) {
+            g[count++] = q[0]
+        }
+        var a = t[1]
+        var b = q[1]
+        var x = a + b
+        var bv = x - a
+        var y = b - bv
+        q[1] = x
+        if (y) {
+            g[count++] = y
+        }
+    }
+    if (q[1]) {
+        g[count++] = q[1]
+    }
+    if (count === 0) {
+        g[count++] = 0.0
+    }
+    g.length = count
+    return g
+}
+
+/**
+ * Adapted from https://github.com/mikolalysenko/robust-sum/blob/master/robust-sum.js
+ * @param {number[]} e
+ * @param {number[]} f
+ * @returns {number[]}
+ */
+function linearExpansionSum(e, f) {
+    var ne = e.length;
+    var nf = f.length;
+
+    var n = ne + nf
+    var g = new Array(n)
+    var count = 0
+    var eptr = 0
+    var fptr = 0
+    var abs = Math.abs
+    var ei = e[eptr]
+    var ea = abs(ei)
+    var fi = f[fptr]
+    var fa = abs(fi)
+    var a, b
+    if (ea < fa) {
+        b = ei
+        eptr += 1
+        if (eptr < ne) {
+            ei = e[eptr]
+            ea = abs(ei)
+        }
+    } else {
+        b = fi
+        fptr += 1
+        if (fptr < nf) {
+            fi = f[fptr]
+            fa = abs(fi)
+        }
+    }
+    if ((eptr < ne && ea < fa) || (fptr >= nf)) {
+        a = ei
+        eptr += 1
+        if (eptr < ne) {
+            ei = e[eptr]
+            ea = abs(ei)
+        }
+    } else {
+        a = fi
+        fptr += 1
+        if (fptr < nf) {
+            fi = f[fptr]
+            fa = abs(fi)
+        }
+    }
+    var x = a + b
+    var bv = x - a
+    var y = b - bv
+    var q0 = y
+    var q1 = x
+    var _x, _bv, _av, _br, _ar
+    while (eptr < ne && fptr < nf) {
+        if (ea < fa) {
+            a = ei
+            eptr += 1
+            if (eptr < ne) {
+                ei = e[eptr]
+                ea = abs(ei)
+            }
+        } else {
+            a = fi
+            fptr += 1
+            if (fptr < nf) {
+                fi = f[fptr]
+                fa = abs(fi)
+            }
+        }
+        b = q0
+        x = a + b
+        bv = x - a
+        y = b - bv
+        if (y) {
+            g[count++] = y
+        }
+        _x = q1 + x
+        _bv = _x - q1
+        _av = _x - _bv
+        _br = x - _bv
+        _ar = q1 - _av
+        q0 = _ar + _br
+        q1 = _x
+    }
+    while (eptr < ne) {
+        a = ei
+        b = q0
+        x = a + b
+        bv = x - a
+        y = b - bv
+        if (y) {
+            g[count++] = y
+        }
+        _x = q1 + x
+        _bv = _x - q1
+        _av = _x - _bv
+        _br = x - _bv
+        _ar = q1 - _av
+        q0 = _ar + _br
+        q1 = _x
+        eptr += 1
+        if (eptr < ne) {
+            ei = e[eptr]
+        }
+    }
+    while (fptr < nf) {
+        a = fi
+        b = q0
+        x = a + b
+        bv = x - a
+        y = b - bv
+        if (y) {
+            g[count++] = y
+        }
+        _x = q1 + x
+        _bv = _x - q1
+        _av = _x - _bv
+        _br = x - _bv
+        _ar = q1 - _av
+        q0 = _ar + _br
+        q1 = _x
+        fptr += 1
+        if (fptr < nf) {
+            fi = f[fptr]
+        }
+    }
+    if (q0) {
+        g[count++] = q0
+    }
+    if (q1) {
+        g[count++] = q1
+    }
+    if (!count) {
+        g[count++] = 0.0
+    }
+    g.length = count
+    return g
+}
+
+/**
+ *
+ * @param {number[]} m0
+ * @param {number[]} m1
+ * @param {number[]} m2
+ * @returns {number}
+ */
+function orientation3Exact(m0, m1, m2) {
+    const p = sum(sum(prod(m1[1], m2[0]), prod(-m2[1], m1[0])), sum(prod(m0[1], m1[0]), prod(-m1[1], m0[0])))
+    const n = sum(prod(m0[1], m2[0]), prod(-m2[1], m0[0]))
+    const d = sub(p, n)
+    return d[d.length - 1]
+}
+
+/**
+ *
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} cx
+ * @param {number} cy
+ * @returns {number}
+ */
+export function orientation3(ax, ay, bx, by, cx, cy) {
+
+    const l = (ay - cy) * (bx - cx);
+    const r = (ax - cx) * (by - cy);
+
+
+    const det = l - r;
+    let s;
+
+    if (l > 0) {
+        if (r <= 0) {
+            return det
+        } else {
+            s = l + r
+        }
+    } else if (l < 0) {
+        if (r >= 0) {
+            return det
+        } else {
+            s = -(l + r)
+        }
+    } else {
+        return det
+    }
+    var tol = ERRBOUND3 * s
+
+    if (det >= tol || det <= -tol) {
+        return det
+    }
+
+    return orientation3Exact([ax, ay], [bx, by], [cx, cy]);
+}