@woosh/meep-engine 2.33.23 → 2.33.27

package/core/geom/3d/morton/v3_morton_encode_transformed.js

@@ -0,0 +1,33 @@
+import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
+
+/**
+ * Assumes that coordinates will be mapped to -1..1 range after transform
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]} matrix matrix to transform supplied coordinates to Normalized Device Coordinates
+ * @returns {number}
+ */
+export function v3_morton_encode_transformed(x, y, z, matrix) {
+
+    // apply matrix transform
+    const _x = matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12];
+    const _y = matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13];
+    const _z = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14];
+    const _w = matrix[3] * x + matrix[7] * y + matrix[11] * z + matrix[15];
+
+    const d = 1 / _w;
+
+    // apply perspective divide, values are now in Normalized Coordinate system (-1,1)
+    const px = _x * d;
+    const py = _y * d;
+    const pz = _z * d;
+
+    // scale each value up to 10 bits (for 10 bits, the multiplier = 1024. As we have -1,1 range, we do (v+1)/2. 1024/2 = 512)
+
+    const cx = ((px + 1) * 512) | 0;
+    const cy = ((py + 1) * 512) | 0;
+    const cz = ((pz + 1) * 512) | 0;
+
+    return mortonEncode_magicbits(cx, cy, cz);
+}

package/core/geom/3d/normal/hemioct/unit_hemioct.spec.js

@@ -1,5 +1,5 @@
 import { decode_hemioct_to_unit, encode_unit_to_hemioct } from "./encode_unit3_hemioct.js";
-import { v3_length } from "../../../Vector3.d.ts";
+import { v3_length } from "../../../v3_length.js";
 
 test('encode-decode', () => {
     const v0 = [];

package/core/geom/3d/ray/ray_computeNearestPointToPoint.js

@@ -0,0 +1,37 @@
+import { v3_dot } from "../../v3_dot.js";
+
+/**
+ *
+ * @param {Vector3} 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} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number} distance from origin, negative means that the point lies behind the origin in the direction opposite to the ray's own
+ */
+export function ray_computeNearestPointToPoint(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, px, py, pz) {
+    // find closest point
+    const sp0_x = px - origin_x;
+    const sp0_y = py - origin_y;
+    const sp0_z = pz - origin_z;
+
+    //
+    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
+    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
+
+    const t = d3 / d2;
+
+    // compute point on the ray
+    const lp_x = direction_x * t + origin_x;
+    const lp_y = direction_y * t + origin_y;
+    const lp_z = direction_z * t + origin_z;
+
+    result.set(lp_x, lp_y, lp_z);
+
+    return t;
+}

package/core/geom/3d/shape/AbstractShape3D.js

@@ -0,0 +1,65 @@
+export class AbstractShape3D {
+    /**
+     * Signed distance to boundary of the shape from the given point
+     * @param {number[]} point
+     * @returns {number}
+     */
+    signed_distance_at_point(point) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * Samples both distances as well as the gradient
+     * @param {number[]} result resulting gradient is written here
+     * @param {number[]} point sampling point
+     * @returns {number}
+     */
+    signed_distance_gradient_at_point(result, point) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {number[]} result where the resulting point is stored
+     * @param {number[]} reference reference point from which to go
+     * @returns {void}
+     */
+    nearest_point_on_surface(result, reference) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {number[]} result
+     * @param {number} result_offset
+     * @param {function} random
+     * @returns {void}
+     */
+    sample_random_point_in_volume(result, result_offset, random) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * Whether or not given point is inside the shape
+     * @param {number[]} point
+     * @returns {boolean}
+     */
+    contains_point(point) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * Total volume of the shape
+     * @returns {number}
+     */
+    get volume() {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     * @returns {number}
+     */
+    get surface_area() {
+        throw new Error('Not Implemented');
+    }
+}

package/core/geom/3d/shape/TransformedShape3D.js

@@ -0,0 +1,181 @@
+import { mat4, vec3 } from "gl-matrix";
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { sign } from "../../../math/sign.js";
+
+/**
+ *
+ * @type {number[]|Float32Array|vec3}
+ */
+const scratch_v3_0 = [];
+
+export class TransformedShape3D extends AbstractShape3D {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {number[]|Float32Array|mat4}
+         * @private
+         */
+        this.__matrix = new Float32Array(16);
+
+        /**
+         *
+         * @type {Float32Array|mat4}
+         * @private
+         */
+        this.__inverse_matrix = new Float32Array(16);
+
+        /**
+         *
+         * @type {AbstractShape3D|null}
+         * @private
+         */
+        this.__subject = null;
+    }
+
+    /**
+     *
+     * @returns {AbstractShape3D|null}
+     */
+    get subject() {
+        return this.__subject;
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array|mat4} m4
+     * @param {AbstractShape3D} subject
+     * @returns {TransformedShape3D}
+     */
+    static from_m4(subject, m4) {
+        const r = new TransformedShape3D();
+
+        r.__subject = subject;
+        r.transform = m4;
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {AbstractShape3D} subject
+     * @param {number[]} translation
+     * @param {number[]} scale
+     */
+    static from_translation_scale(subject, translation, scale) {
+
+        const mat = mat4.create();
+        mat4.fromRotationTranslationScale(mat, [0, 0, 0, 1], translation, scale);
+
+        return TransformedShape3D.from_m4(subject, mat);
+    }
+
+    /**
+     *
+     * @returns {TransformedShape3D}
+     * @param {AbstractShape3D} subject
+     * @param {number[]|Float32Array|vec3} scale
+     */
+    static from_scale(subject, scale) {
+        const mat = mat4.create();
+        mat4.fromScaling(mat, scale);
+
+        return TransformedShape3D.from_m4(subject, mat);
+    }
+
+    /**
+     *
+     * @param {number[]|Float32Array} m
+     */
+    set transform(m) {
+        this.__matrix.set(m);
+
+        mat4.invert(this.__inverse_matrix, this.__matrix);
+    }
+
+    get transform() {
+        return this.__matrix;
+    }
+
+    get volume() {
+        mat4.getScaling(scratch_v3_0, this.__matrix);
+
+        const scale_modifier = scratch_v3_0[0] * scratch_v3_0[1] * scratch_v3_0[2];
+
+        return this.__subject.volume * scale_modifier;
+    }
+
+    signed_distance_gradient_at_point(result, point) {
+        // transform point to subject's local space
+        vec3.transformMat4(scratch_v3_0, point, this.__inverse_matrix);
+
+        const subject = this.__subject;
+
+        // sample gradient at the point
+        const distance = subject.signed_distance_gradient_at_point(scratch_v3_0, scratch_v3_0);
+
+        const m = this.__matrix;
+
+        const m11 = m[0];
+        const m12 = m[1];
+        const m13 = m[2];
+
+        const m21 = m[4];
+        const m22 = m[5];
+        const m23 = m[6];
+
+        const m31 = m[8];
+        const m32 = m[9];
+        const m33 = m[10];
+
+        const scale_x = Math.hypot(m11, m12, m13);
+        const scale_y = Math.hypot(m21, m22, m23);
+        const scale_z = Math.hypot(m31, m32, m33);
+
+        const scaled_gx = scratch_v3_0[0] * scale_x;
+        const scaled_gy = scratch_v3_0[1] * scale_y;
+        const scaled_gz = scratch_v3_0[2] * scale_z;
+
+        // normalize gradient
+        const gd = distance / Math.hypot(scratch_v3_0[0], scratch_v3_0[1], scratch_v3_0[2]);
+
+        const scaled_dx = scaled_gx * gd ;
+        const scaled_dy = scaled_gy * gd ;
+        const scaled_dz = scaled_gz * gd ;
+
+        // determine sign
+        const result_sign = sign(distance);
+
+        const scaled_distance = result_sign * Math.sqrt(scaled_dx * scaled_dx + scaled_dy * scaled_dy + scaled_dz * scaled_dz);
+
+        result[0] = scaled_gx;
+        result[1] = scaled_gy;
+        result[2] = scaled_gz;
+
+        return scaled_distance;
+    }
+
+    signed_distance_at_point(point) {
+        return this.signed_distance_gradient_at_point(scratch_v3_0, point);
+    }
+
+    contains_point(point) {
+        // transform point to subject's local space
+        vec3.transformMat4(scratch_v3_0, point, this.__inverse_matrix);
+
+        return this.__subject.contains_point(scratch_v3_0);
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        this.__subject.sample_random_point_in_volume(scratch_v3_0, 0, random);
+
+        // apply transform
+        vec3.transformMat4(scratch_v3_0, scratch_v3_0, this.__matrix);
+
+        // write out
+        result[0] = scratch_v3_0[0];
+        result[1] = scratch_v3_0[1];
+        result[2] = scratch_v3_0[2];
+    }
+}

package/core/geom/3d/shape/TransformedShape3D.spec.js

@@ -0,0 +1,33 @@
+import { UnitCubeShape3D } from "./UnitCubeShape3D.js";
+import { TransformedShape3D } from "./TransformedShape3D.js";
+
+test('signed distance identity transform', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [1, 1, 1]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(-0.5);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(0.5);
+});
+
+test('signed distance translation', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [1, 0, 0], [1, 1, 1]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(0.5);
+
+    expect(s.signed_distance_at_point([-1, 0, 0])).toBeCloseTo(1.5);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(-0.5);
+});
+
+test('signed distance scale', () => {
+
+    const s = TransformedShape3D.from_translation_scale(new UnitCubeShape3D(), [0, 0, 0], [2, 2, 2]);
+
+    expect(s.signed_distance_at_point([0, 0, 0])).toBeCloseTo(-1);
+
+    expect(s.signed_distance_at_point([1, 0, 0])).toBeCloseTo(0);
+
+    expect(s.signed_distance_at_point([2, 0, 0])).toBeCloseTo(1);
+});

package/core/geom/3d/shape/UnionShape3D.js

@@ -0,0 +1,255 @@
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { seededRandom } from "../../../math/random/seededRandom.js";
+import { binarySearchHighIndex } from "../../../collection/array/binarySearchHighIndex.js";
+import { compareNumbers } from "../../../primitives/numbers/compareNumbers.js";
+import { min2 } from "../../../math/min2.js";
+import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+
+/**
+ * To avoid severe performance overhead, we limit number of possible rejections
+ * @type {number}
+ */
+const SAMPLE_REJECTION_ATTEMPT_MAX = 4;
+
+/**
+ * Number of samples taken to estimate overlap level
+ * @type {number}
+ */
+const VOLUME_OVERLAP_ESTIMATION_TAPS = 1024;
+const VOLUME_OVERLAP_ESTIMATION_SUB_TAPS = 4;
+
+const scratch_array = [];
+
+export class UnionShape3D extends AbstractShape3D {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {AbstractShape3D[]}
+         */
+        this.children = [];
+
+        /**
+         * Estimator of how much volume is in overlap,
+         * expressed as fraction of volume occupied by overlapping region of 2 shapes over the sum of volume occupied by each child
+         * @type {number}
+         * @private
+         */
+        this.__volume_overlap_fraction = -1;
+
+        this.__volume_sum = -1;
+        this.__volume_sums = [];
+        this.__child_volumes = [];
+    }
+
+    /**
+     *
+     * @private
+     */
+    __compute_volume_variables() {
+        this.__volume_sum = 0;
+
+        const children = this.children;
+        const child_count = children.length;
+
+        const child_volumes = this.__child_volumes = new Float32Array(child_count);
+        const child_volume_sums = this.__volume_sums = new Float32Array(child_count);
+
+        for (let i = 0; i < child_count; i++) {
+            const child_volume = children[i].volume;
+
+            child_volumes[i] = child_volume;
+            this.__volume_sum += child_volume;
+
+            child_volume_sums[i] = this.__volume_sum;
+        }
+
+    }
+
+    /**
+     * Monte-carlo-style volume overlap estimation
+     * @private
+     */
+    __estimate_volume_overlap_fraction() {
+
+        if (this.__volume_sum === -1) {
+            this.__compute_volume_variables();
+        }
+
+        const children = this.children;
+        const child_count = children.length;
+
+        const random = seededRandom(1);
+
+        const child_volume_sums = this.__volume_sums;
+        const child_volume_sum = this.__volume_sum;
+
+        let i = 0, j = 0, k = 0, tap_overlaps = 0;
+
+        for (i = 0; i < VOLUME_OVERLAP_ESTIMATION_TAPS; i++) {
+
+            const target_weight = random() * child_volume_sum;
+
+            // weighted search for a sample candidate, preferring larger volumes, resulting in more uniform sample distribution
+            const target_child_index = binarySearchHighIndex(child_volume_sums, target_weight, compareNumbers, 0, child_count - 1);
+
+            const child_0 = children[target_child_index];
+
+            for (j = 0; j < VOLUME_OVERLAP_ESTIMATION_SUB_TAPS; j++, i++) {
+
+                child_0.sample_random_point_in_volume(scratch_array, 0, random);
+
+                for (k = 0; k < child_count; k++) {
+                    if (target_child_index === k) {
+                        // skip self
+                        continue;
+                    }
+
+                    const child_1 = children[k];
+
+                    if (child_1.contains_point(scratch_array)) {
+                        tap_overlaps++;
+                    }
+                }
+
+            }
+        }
+
+        this.__volume_overlap_fraction = tap_overlaps / (VOLUME_OVERLAP_ESTIMATION_TAPS);
+    }
+
+    static from(children) {
+        const r = new UnionShape3D();
+
+        r.children = children;
+
+        return r;
+    }
+
+    get volume() {
+        if (this.__volume_overlap_fraction < 0) {
+            this.__estimate_volume_overlap_fraction();
+        }
+
+        let volume_sum = 0;
+
+        const children = this.children;
+        const child_count = children.length;
+
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            volume_sum += child.volume;
+        }
+
+        /**
+         * Unbias the volume by taking overlap into account
+         * @type {number}
+         */
+        const unbiased_volume = volume_sum / (this.__volume_overlap_fraction + 1);
+
+        return unbiased_volume;
+    }
+
+    get surface_area() {
+        let r = 0;
+
+        const children = this.children;
+        const child_count = children.length;
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            r += child.surface_area;
+        }
+
+        return r;
+    }
+
+    signed_distance_gradient_at_point(result, point) {
+        return compute_signed_distance_gradient_by_sampling(result, this, point);
+    }
+
+    signed_distance_at_point(point) {
+        let r = Infinity;
+
+        const children = this.children;
+        const child_count = children.length;
+
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            r = min2(child.signed_distance_at_point(point), r);
+        }
+
+        return r;
+    }
+
+    contains_point(point) {
+        const children = this.children;
+        const n = children.length;
+        for (let i = 0; i < n; i++) {
+            const child = children[i];
+
+            if (child.contains_point(point)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        const children = this.children;
+        const child_count = children.length;
+
+
+        const target_weight = random() * this.__volume_sum;
+
+        // weighted search for a sample candidate, preferring larger volumes, resulting in more uniform sample distribution
+        const target_child_index = binarySearchHighIndex(this.__volume_sums, target_weight, compareNumbers, 0, child_count - 1);
+
+        const child = children[target_child_index];
+
+        let collision_count, i, j;
+
+        for (i = 0; i < SAMPLE_REJECTION_ATTEMPT_MAX; i++) {
+
+            // sample shape
+            child.sample_random_point_in_volume(result, result_offset, random);
+
+            /*
+            because underlying shapes can overlap and we wish to offer a union, just returning the sample would result in over-sampling in areas where shapes overlap
+            to avoid this oversampling, we reject samples in such areas with probability proportional to number of overlapping shapes at the sampled point
+             */
+            collision_count = 0;
+
+            for (j = 0; j < child_count; j++) {
+                const child_1 = children[j];
+
+                if (child_1 === child) {
+                    // exclude sampled child itself
+                    continue;
+                }
+
+                if (child_1.contains_point(result)) {
+                    collision_count++;
+                }
+            }
+
+            if (collision_count > 0) {
+                const rejection_chance = collision_count / (collision_count + 1);
+
+                const rejection_roll = random();
+
+                if (rejection_roll < rejection_chance) {
+                    //reject
+                    continue;
+                }
+            }
+
+            // no collisions, or survived rejection
+            break;
+        }
+    }
+}