@woosh/meep-engine 2.49.8 → 2.50.0

package/src/engine/graphics/texture/sampler/differenceSampler.js

@@ -1,5 +1,6 @@
-import Vector4 from "../../../../core/geom/Vector4.js";
 import { Sampler2D } from "./Sampler2D.js";
+import { vector_nd_normalize } from "../../../../core/math/vector_nd_normalize.js";
+import { vector_nd_dot } from "../../../../core/math/vector_nd_dot.js";
 
 /**
  *
@@ -8,8 +9,10 @@ import { Sampler2D } from "./Sampler2D.js";
  * @returns {Sampler2D}
  */
 export function differenceSampler(sampler0, sampler1) {
-    let v0 = new Vector4();
-    let v1 = new Vector4();
+    const dimension_count = sampler0.itemSize;
+
+    const v0 = new Float64Array(dimension_count);
+    const v1 = new Float64Array(dimension_count);
     //
     const width = sampler0.width;
     const height = sampler0.height;
@@ -17,12 +20,14 @@ export function differenceSampler(sampler0, sampler1) {
     const difference = new Float32Array(width * height);
     for (let y = 0; y < height; y++) {
         for (let x = 0; x < width; x++) {
-            v0 = sampler0.get(x, y, v0);
-            v1 = sampler1.get(x, y, v1);
-            v0.normalize();
-            v1.normalize();
+            sampler0.sampleBilinear(x, y, v0);
+            sampler1.sampleBilinear(x, y, v1);
+
+            vector_nd_normalize(v0, v0, dimension_count);
+            vector_nd_normalize(v1, v1, dimension_count);
+
             //check distance
-            difference[x + y * width] = 1 - v0.dot(v1);
+            difference[x + y * width] = 1 - vector_nd_dot(v0, v1, dimension_count);
         }
     }
     //

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_Chamfer.js

@@ -0,0 +1,140 @@
+import { clamp } from "../../../../../core/math/clamp.js";
+import { min2 } from "../../../../../core/math/min2.js";
+
+/**
+ * algorithm proposed by Borgefors, Chamfer distance [J. ACM 15 (1968) 600, Comput. Vis. Graph. Image Process. 34 (1986) 344], h
+ * @param {Sampler2D} source
+ * @param {Sampler2D} distanceField
+ * @param {number} emptyValue
+ * @param {number} d1 distance between two adjacent pixels in either x or y direction
+ * @param {number} d2 distance between two diagonally adjacent pixels
+ * @param maxD
+ */
+export function computeSignedDistanceField_Chamfer(source, distanceField, emptyValue, d1, d2, maxD) {
+    const sourceData = source.data;
+    const distanceFieldData = distanceField.data;
+
+    const width = source.width;
+    const height = source.height;
+
+    const maxX = width - 1;
+    const maxY = height - 1;
+
+    function getS(x, y) {
+        x = clamp(x, 0, maxX);
+        y = clamp(y, 0, maxY);
+
+        const index = x + y * width;
+
+        return sourceData[index];
+    }
+
+    function getD(x, y) {
+        x = clamp(x, 0, maxX);
+        y = clamp(y, 0, maxY);
+
+        const index = x + y * width;
+
+        return distanceFieldData[index];
+    }
+
+    function setD(x, y, v) {
+        x = clamp(x, 0, maxX);
+        y = clamp(y, 0, maxY);
+
+        const index = x + y * width;
+
+        distanceFieldData[index] = min2(v, maxD);
+    }
+
+    let x, y;
+
+    //initialize distance field
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            if (
+                getS(x - 1, y) !== getS(x, y)
+                || getS(x + 1, y) !== getS(x, y)
+                || getS(x, y - 1) !== getS(x, y)
+                || getS(x, y + 1) !== getS(x, y)
+            ) {
+                setD(x, y, 0);
+            } else {
+                setD(x, y, 255);
+            }
+        }
+    }
+
+    //first pass (forward)
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+
+            const v = getD(x, y);
+
+            const v0 = getD(x - 1, y - 1) + d2;
+
+            if (v0 < v) {
+                setD(x, y, v0);
+            }
+
+            const v1 = getD(x, y - 1) + d1;
+
+            if (v1 < v) {
+                setD(x, y, v1);
+            }
+
+            const v2 = getD(x + 1, y - 1) + d2;
+
+            if (v2 < v) {
+                setD(x, y, v2);
+            }
+
+            const v3 = getD(x - 1, y) + d1;
+
+            if (v3 < v) {
+                setD(x, y, v3);
+            }
+        }
+    }
+
+    //second pass (backward)
+    for (y = maxY; y >= 0; y--) {
+        for (x = maxX; x >= 0; x--) {
+            const v = getD(x, y);
+
+            const v0 = getD(x + 1, y) + d1;
+
+            if (v0 < v) {
+                setD(x, y, v0);
+            }
+
+            const v1 = getD(x - 1, y + 1) + d2;
+
+            if (v1 < v) {
+                setD(x, y, v1);
+            }
+
+            const v2 = getD(x, y + 1) + d1;
+
+            if (v2 < v) {
+                setD(x, y, v2);
+            }
+
+            const v3 = getD(x + 1, y + 1) + d2;
+
+            if (v3 < v) {
+                setD(x, y, v3);
+            }
+        }
+    }
+
+    //indicate inside & outside
+    for (y = 0; y < height; y++) {
+        for (x = 0; x < width; x++) {
+            if (getS(x, y) !== emptyValue) {
+                //inside
+                setD(x, y, -getD(x, y));
+            }
+        }
+    }
+}

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_NaiveFlood.js

@@ -0,0 +1,130 @@
+import { assert } from "../../../../../core/assert.js";
+import { BitSet } from "../../../../../core/binary/BitSet.js";
+
+/**
+ * Naive flood implementation of a distance field computation algorithm
+ * @author Alex Goldring Dec 2018
+ * @param {Sampler2D} source
+ * @param {Sampler2D} destination
+ * @param {number} emptyValue
+ */
+export function computeSignedDistanceField_NaiveFlood(source, destination, emptyValue) {
+    assert.equal(source.itemSize, 1, `unsupported source.itemSize, expected 1, got '${source.itemSize}'`);
+    assert.typeOf(emptyValue, 'number', 'emptyValue');
+
+    let i, j;
+
+    const distanceData = destination.data;
+
+    const visited = new BitSet();
+
+    const openSet = new BitSet();
+
+    //use "flood" algorithm
+
+    //mark all visible tiles as visited
+    const samplerData = source.data;
+    const totalCellCount = samplerData.length;
+
+    function traverseNeighbours(index, visitor) {
+        let i = index - (width + 1);
+
+        const top = index > width;
+        const bottom = index < (totalCellCount - width);
+
+        const x = index % width;
+
+        const left = x > 0;
+        const right = x < width - 1;
+
+        if (top) {
+            if (left) {
+                visitor(i);
+            }
+
+            visitor(i + 1);
+
+            if (right) {
+                visitor(i + 2);
+            }
+        }
+
+        i += width;
+
+        if (left) {
+            visitor(i);
+        }
+
+        if (right) {
+            visitor(i + 2);
+        }
+
+        i += width;
+
+        if (bottom) {
+            if (left) {
+                visitor(i);
+            }
+
+            visitor(i + 1);
+
+            if (right) {
+                visitor(i + 2);
+            }
+        }
+
+    }
+
+    const width = destination.width;
+
+    for (i = 0; i < totalCellCount; i++) {
+        const sampleValue = samplerData[i];
+        if (sampleValue !== emptyValue) {
+            visited.set(i, true);
+            //write distance data
+            distanceData[i] = 0;
+        } else {
+            distanceData[i] = 255;
+        }
+    }
+
+    //populate initial open set
+    for (i = visited.nextSetBit(0); i !== -1; i = visited.nextSetBit(i + 1)) {
+        j = 0;
+        traverseNeighbours(i, function (neighbourIndex) {
+            if (!visited.get(neighbourIndex)) {
+                //increment number of not visited
+                j++;
+            }
+        });
+
+        if (j === 0) {
+            //all neighbours are visited, we can safely ignore this cell
+        } else {
+            openSet.set(i, true);
+        }
+    }
+
+    for (i = openSet.nextSetBit(0); i !== -1; i = openSet.nextSetBit(0)) {
+        //remove from open set
+        openSet.set(i, false);
+
+        const value = distanceData[i];
+
+        traverseNeighbours(i, function (neighbourIndex) {
+            const neighbourValue = value + 1;
+
+            if (visited.get(neighbourIndex)) {
+                if (distanceData[neighbourIndex] <= neighbourValue) {
+                    return;
+                }
+            } else {
+                visited.set(neighbourIndex, true);
+            }
+
+            distanceData[neighbourIndex] = neighbourValue;
+            //add neighbour to open set
+            openSet.set(neighbourIndex, true);
+        });
+    }
+}

package/src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField.js

@@ -0,0 +1,10 @@
+import { computeUnsignedDistanceField_Chamfer } from "./computeUnsignedDistanceField_Chamfer.js";
+
+/**
+ * @param {Sampler2D} source
+ * @param {Sampler2D} distanceField
+ * @param {number} emptyValue
+ */
+export function computeUnsignedDistanceField(source, distanceField, emptyValue) {
+    computeUnsignedDistanceField_Chamfer(source, distanceField, emptyValue, 1, 1, 255);
+}

package/src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField.spec.js

@@ -0,0 +1,183 @@
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import { Sampler2D } from "../Sampler2D.js";
+import { randomIntegerBetween } from "../../../../../core/math/random/randomIntegerBetween.js";
+import { computeUnsignedDistanceField } from "./computeUnsignedDistanceField.js";
+
+test('empty', () => {
+    const source = Sampler2D.uint8(1, 0, 0);
+    const target = Sampler2D.uint8(1, 0, 0);
+
+    computeUnsignedDistanceField(source, target, 0);
+});
+
+test('1 pixel empty source', () => {
+    const source = Sampler2D.uint8(1, 1, 1);
+    const target = Sampler2D.uint8(1, 1, 1);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(255);
+});
+
+test('1 pixel filled source', () => {
+    const source = Sampler2D.uint8(1, 1, 1);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 1, 1);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+});
+
+test('3x3 pixel source with filled middle', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.set(1, 1, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(1);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(1);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(0);
+    expect(target.readChannel(2, 1, 0)).toBe(1);
+
+    expect(target.readChannel(0, 2, 0)).toBe(1);
+    expect(target.readChannel(1, 2, 0)).toBe(1);
+    expect(target.readChannel(2, 2, 0)).toBe(1);
+});
+
+test('3x3 pixel source with empty middle', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(255);
+    source.set(1, 1, [0]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(0);
+    expect(target.readChannel(2, 0, 0)).toBe(0);
+
+    expect(target.readChannel(0, 1, 0)).toBe(0);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(0);
+
+    expect(target.readChannel(0, 2, 0)).toBe(0);
+    expect(target.readChannel(1, 2, 0)).toBe(0);
+    expect(target.readChannel(2, 2, 0)).toBe(0);
+});
+
+test('3x3 pixel source with empty corners', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(255);
+    source.set(0, 0, [0]);
+    source.set(2, 0, [0]);
+    source.set(0, 2, [0]);
+    source.set(2, 2, [0]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(1);
+    expect(target.readChannel(1, 0, 0)).toBe(0);
+    expect(target.readChannel(2, 0, 0)).toBe(1);
+
+    expect(target.readChannel(0, 1, 0)).toBe(0);
+    expect(target.readChannel(1, 1, 0)).toBe(0);
+    expect(target.readChannel(2, 1, 0)).toBe(0);
+
+    expect(target.readChannel(0, 2, 0)).toBe(1);
+    expect(target.readChannel(1, 2, 0)).toBe(0);
+    expect(target.readChannel(2, 2, 0)).toBe(1);
+});
+
+test('3x3 pixel source with filled corners', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+    source.set(2, 0, [255]);
+    source.set(0, 2, [255]);
+    source.set(2, 2, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(0);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(1);
+
+    expect(target.readChannel(0, 2, 0)).toBe(0);
+    expect(target.readChannel(1, 2, 0)).toBe(1);
+    expect(target.readChannel(2, 2, 0)).toBe(0);
+});
+
+test('3x1 pixel source with 1 filled corner', () => {
+    const source = Sampler2D.uint8(1, 3, 1);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 1);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(2);
+});
+
+test('3x3 pixel source with 1 filled corner', () => {
+    const source = Sampler2D.uint8(1, 3, 3);
+    source.data.fill(0);
+    source.set(0, 0, [255]);
+
+    const target = Sampler2D.uint8(1, 3, 3);
+
+    computeUnsignedDistanceField(source, target, 0);
+
+    expect(target.readChannel(0, 0, 0)).toBe(0);
+    expect(target.readChannel(1, 0, 0)).toBe(1);
+    expect(target.readChannel(2, 0, 0)).toBe(2);
+
+    expect(target.readChannel(0, 1, 0)).toBe(1);
+    expect(target.readChannel(1, 1, 0)).toBe(1);
+    expect(target.readChannel(2, 1, 0)).toBe(2);
+
+    expect(target.readChannel(0, 2, 0)).toBe(2);
+    expect(target.readChannel(1, 2, 0)).toBe(2);
+    expect(target.readChannel(2, 2, 0)).toBe(2);
+});
+
+test.skip('performance', () => {
+
+    const sizeX = 100;
+    const sizeY = 100;
+
+    const source = Sampler2D.uint8(1, sizeX, sizeY);
+
+    const random = seededRandom(42);
+    source.data.fill(0);
+    for (let i = 0; i < source.data.length * 0.1; i++) {
+        const x = randomIntegerBetween(random, 0, sizeX);
+        const y = randomIntegerBetween(random, 0, sizeY);
+        source.set(x, y, [255]);
+    }
+
+    const target = Sampler2D.uint8(1, sizeX, sizeY);
+
+    console.time('p');
+    computeUnsignedDistanceField(source, target, 0);
+    console.timeEnd('p');
+
+});

package/src/engine/graphics/texture/sampler/distance/computeUnsignedDistanceField_Chamfer.js

@@ -0,0 +1,133 @@
+import { max2 } from "../../../../../core/math/max2.js";
+import { min2 } from "../../../../../core/math/min2.js";
+
+/**
+ * algorithm proposed by Borgefors, Chamfer distance [J. ACM 15 (1968) 600, Comput. Vis. Graph. Image Process. 34 (1986) 344], h
+ * @param {Sampler2D} source
+ * @param {Sampler2D} distanceField
+ * @param {number} emptyValue
+ * @param {number} d1 distance between two adjacent pixels in either x or y direction
+ * @param {number} d2 distance between two diagonally adjacent pixels
+ * @param {number} maxD highest value that distance field can hold
+ */
+export function computeUnsignedDistanceField_Chamfer(source, distanceField, emptyValue, d1, d2, maxD) {
+    const sourceData = source.data;
+    const distanceFieldData = distanceField.data;
+
+    const width = source.width;
+    const height = source.height;
+
+    const maxX = width - 1;
+    const maxY = height - 1;
+
+    let x, y, i, v;
+
+    //initialize distance field
+    const dataSize = height * width;
+    for (i = 0; i < dataSize; i++) {
+        if (sourceData[i] !== emptyValue) {
+            distanceFieldData[i] = 0;
+        } else {
+            distanceFieldData[i] = maxD;
+        }
+    }
+
+    //first pass (forward)
+    for (y = 0; y < height; y++) {
+
+        const y_m1 = max2(y - 1, 0);
+
+        const y_w = y * width;
+
+        const y_m1_w = y_m1 * width;
+
+        for (x = 0; x < width; x++) {
+
+            i = y_w + x;
+
+            v = distanceFieldData[i];
+
+            const x_m1 = max2(x - 1, 0);
+            const x_p1 = min2(x + 1, maxX);
+
+            const v0_i = x_m1 + y_m1_w;
+            const v0 = distanceFieldData[v0_i] + d2;
+
+            if (v0 < v) {
+                distanceFieldData[i] = v0;
+                v = v0;
+            }
+
+            const v1_i = x + y_m1_w;
+            const v1 = distanceFieldData[v1_i] + d1;
+
+            if (v1 < v) {
+                distanceFieldData[i] = v1;
+                v = v1;
+            }
+
+            const v2_i = x_p1 + y_m1_w;
+            const v2 = distanceFieldData[v2_i] + d2;
+
+            if (v2 < v) {
+                distanceFieldData[i] = v2;
+                v = v2;
+            }
+
+            const v3_i = x_m1 + y_w;
+            const v3 = distanceFieldData[v3_i] + d1;
+
+            if (v3 < v) {
+                distanceFieldData[i] = v3;
+            }
+        }
+    }
+
+    //second pass (backward)
+    for (y = maxY; y >= 0; y--) {
+        const y_w = y * width;
+
+        const y_p1 = min2(y + 1, maxY);
+        const y_p1_w = y_p1 * width;
+
+        for (x = maxX; x >= 0; x--) {
+            const x_p1 = min2(x + 1, maxX);
+            const x_m1 = max2(x - 1, 0);
+
+            i = y_w + x;
+
+            v = distanceFieldData[i];
+
+            const v0_i = x_p1 + y_w;
+            const v0 = distanceFieldData[v0_i] + d1;
+
+            if (v0 < v) {
+                distanceFieldData[i] = v0;
+                v = v0;
+            }
+
+            const v1_i = x_m1 + y_p1_w;
+            const v1 = distanceFieldData[v1_i] + d2;
+
+            if (v1 < v) {
+                distanceFieldData[i] = v1;
+                v = v1;
+            }
+
+            const v2_i = x + y_p1_w;
+            const v2 = distanceFieldData[v2_i] + d1;
+
+            if (v2 < v) {
+                distanceFieldData[i] = v2;
+                v = v2;
+            }
+
+            const v3_i = x_p1 + y_p1_w;
+            const v3 = distanceFieldData[v3_i] + d2;
+
+            if (v3 < v) {
+                distanceFieldData[i] = v3;
+            }
+        }
+    }
+}

package/src/engine/graphics/texture/sampler/filter/kaiser_1.js

@@ -1,7 +1,10 @@
-import { bessel_i0 } from "../../../../../core/math/bessel_i0.js";
+import { modified_bessel_i0 } from "../../../../../core/math/modified_bessel_i0.js";
 import { clamp } from "../../../../../core/math/clamp.js";
 
-const BASE_I0 = bessel_i0(6.5);
+const PI2 = 2 * Math.PI;
+
+const BASE_I0 = modified_bessel_i0(PI2);
+const INV_BESSEL_I0 = 1 / BASE_I0;
 
 /**
  * Support kernel size is 1
@@ -11,9 +14,10 @@ const BASE_I0 = bessel_i0(6.5);
  */
 export function kaiser_1(x) {
     const i = clamp(x * 0.6666666666666666, -1.0, 1.0);
-    const i0a = 1 / BASE_I0;
 
-    return bessel_i0(6.5 * Math.sqrt(1 - i * i)) * i0a;
+    const t = Math.sqrt(1 - i * i);
+
+    return modified_bessel_i0(PI2 * t) * INV_BESSEL_I0;
 }
 
 kaiser_1.support = 1;

package/src/engine/graphics/texture/sampler/filter/kaiser_bessel_window.js

@@ -13,7 +13,9 @@ const INV_BESSEL_3_PI_3 = 1 / BESSEL_3_PI_3;
  */
 export function kaiser_bessel_window(x) {
     const i = clamp(x * 0.6666666666666666, -1.0, 1.0);
+
     const t = Math.sqrt(1.0 - i * i);
+
     return bessel_3(PI3 * t) * INV_BESSEL_3_PI_3;
 }
 

package/src/engine/graphics/texture/sampler/filter/mitchell.js

@@ -1,3 +1,5 @@
+import { assert } from "../../../../../core/assert.js";
+
 const b = 1.0 / 3.0;
 const c = 1.0 / 3.0;
 
@@ -33,6 +35,7 @@ export function mitchell(x) {
     }
     return 0.0;
 }
+
 mitchell.support = 2;
 
 /**
@@ -42,6 +45,7 @@ mitchell.support = 2;
  * @returns {number}
  */
 export function mitchell_v1(x) {
+    assert.greaterThanOrEqual(x, 0);
 
     if (x < 1.0) {
         return 0.8888888888888888 + x * x * (-2 + x * 1.1666666666666667);