@woosh/meep-engine 2.46.0 → 2.46.2

package/src/generation/filtering/numeric/complex/CellFilterDilate.js

@@ -1,36 +0,0 @@
-import { CellFilter } from "../../CellFilter.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
-import { assert } from "../../../../core/assert.js";
-
-export class CellFilterDilate extends CellFilterUnaryOperation {
-    /**
-     *
-     * @param {CellFilter} source
-     * @returns {CellFilterDilate}
-     */
-    static from(source) {
-        const r = new CellFilterDilate();
-        assert.equal(source.isCellFilter, true, 'source.isCellFilter !== true');
-
-        r.source = source;
-
-        return r;
-    }
-
-    execute(grid, x, y, rotation) {
-        const filter = this.source;
-
-        let result = Number.NEGATIVE_INFINITY;
-
-        for (let _y = -1; _y <= 1; _y++) {
-            for (let _x = -1; _x <= 1; _x++) {
-                const v = filter.execute(grid, x + _x, y + _y, 0);
-
-                result = max2(result, v);
-            }
-        }
-
-        return result;
-    }
-}

package/src/generation/filtering/numeric/complex/CellFilterFXAA.js

@@ -1,125 +0,0 @@
-import { assert } from "../../../../core/assert.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { CellFilter } from "../../CellFilter.js";
-
-/**
- * Based on FXAA algorithm by NVidia
- */
-export class CellFilterFXAA extends CellFilter {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {CellFilter}
-         */
-        this.source = null;
-
-        /**
-         * 0.125 leaves less aliasing, but is softer (default!!!)
-         * 0.25 leaves more aliasing, and is sharper
-         * @type {number}
-         */
-        this.edge_threshold = 0.25;
-
-        /**
-         *  0.06 - faster but more aliasing in darks
-         *  0.05 - default
-         *  0.04 - slower and less aliasing in darks
-         * @type {number}
-         */
-        this.console_edge_threshold_min = 0.05;
-
-        /**
-         *  8.0 is sharper (default!!!)
-         *  4.0 is softer
-         *  2.0 is really soft (good only for vector renderer inputs)
-         * @type {number}
-         */
-        this.console_edge_sharpness = 2;
-    }
-
-    /**
-     *
-     * @param {CellFilter} source
-     * @returns {CellFilterFXAA}
-     */
-    static from(source) {
-
-        assert.defined(source, 'source');
-        assert.equal(source.isCellFilter, true, 'source.isCellFilter');
-
-        const r = new CellFilterFXAA();
-
-        r.source = source;
-
-        return r;
-    }
-
-    initialize(grid, seed) {
-        super.initialize(grid, seed);
-
-        if (!this.source.initialized) {
-            this.source.initialize(grid, seed);
-        }
-    }
-
-    execute(grid, x, y, rotation) {
-
-        const valueNw = this.source.execute(grid, x - 1, y - 1, rotation);
-        const valueNe = this.source.execute(grid, x + 1, y - 1, rotation);
-        const valueSw = this.source.execute(grid, x - 1, y + 1, rotation);
-        const valueSe = this.source.execute(grid, x + 1, y + 1, rotation);
-        const valueM = this.source.execute(grid, x, y, rotation);
-
-        const lumaNW = valueNw;
-        const lumaNE = valueNe;
-        const lumaSW = valueSw;
-        const lumaSE = valueSe;
-        const lumaM = valueM;
-
-        const lumaMaxNwSw = max2(lumaNW, lumaSW);
-        const lumaMinNwSw = min2(lumaNW, lumaSW);
-
-        const lumaMaxNeSe = max2(lumaNE, lumaSE);
-        const lumaMinNeSe = min2(lumaNE, lumaSE);
-
-        const lumaMin = min2(lumaM, min2(lumaMinNeSe, lumaMinNwSw));
-        const lumaMax = max2(lumaM, max2(lumaMaxNeSe, lumaMaxNwSw));
-
-        if (lumaMin === lumaMax) {
-            //no luma difference across the sampled region
-            return valueM;
-        }
-
-        const dir_x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
-        const dir_y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));
-
-        const dirReduce = max2(
-            (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * this.edge_threshold),
-            this.console_edge_threshold_min);
-
-        const rcpDirMin = 1.0 / (min2(Math.abs(dir_x), Math.abs(dir_y)) + dirReduce);
-
-        const dir1_x = min2(this.console_edge_sharpness, max2(-this.console_edge_sharpness, dir_x * rcpDirMin));
-        const dir1_y = min2(this.console_edge_sharpness, max2(-this.console_edge_sharpness, dir_y * rcpDirMin));
-
-
-        const valueN1 = this.source.execute(grid, x + dir1_x * (1 / 3 - 0.5), y + dir1_y * (1 / 3 - 0.5), rotation);
-        const valueP1 = this.source.execute(grid, x + dir1_x * (2 / 3 - 0.5), y + dir1_y * (2 / 3 - 0.5), rotation);
-
-        const valueN2 = this.source.execute(grid, x + dir1_x * (-0.5), y + dir1_y * (-0.5), rotation);
-        const valueP2 = this.source.execute(grid, x + dir1_x * (0.5), y + dir1_y * (0.5), rotation);
-
-
-        const valueA = (valueN1 + valueP1) * 0.5;
-        const valueB = ((valueN2 + valueP2) * 0.25) + (valueA * 0.5);
-
-        if (valueB < lumaMin || valueB > lumaMax) {
-            return valueA;
-        } else {
-            return valueB;
-        }
-    }
-}

package/src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -1,178 +0,0 @@
-import { CellFilter } from "../../CellFilter.js";
-import { gaussian } from "../../../../core/math/gaussian.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { assert } from "../../../../core/assert.js";
-
-/**
- * Build gaussian 2d kernel
- * @param {number[]} result
- * @param {number} samplesX
- * @param {number} samplesY
- * @param {number} sigma_x
- * @param {number} sigma_y
- * @return {number}
- */
-function buildKernel(result, samplesX, samplesY, sigma_x, sigma_y) {
-    assert.isNonNegativeInteger(samplesX, 'samplesX');
-    assert.isNonNegativeInteger(samplesY, 'samplesY');
-
-    const half_samples_x = samplesX * 0.5;
-    const half_samples_y = samplesY * 0.5;
-
-    let powerTotal = 0;
-    let ix, iy;
-
-    const i_samples_x = samplesX | 0;
-
-    for (iy = 0; iy < samplesY; iy++) {
-        const local_y = iy - half_samples_y;
-
-        const fy = gaussian(sigma_y, local_y);
-
-        for (ix = 0; ix < samplesX; ix++) {
-
-            const local_x = ix - half_samples_x;
-
-            const fx = gaussian(sigma_x, local_x);
-
-
-            const power = fx * fy;
-
-            powerTotal += power;
-
-            result[iy * i_samples_x + ix] = power;
-        }
-    }
-
-    return powerTotal;
-}
-
-export class CellFilterGaussianBlur extends CellFilter {
-    constructor() {
-        super();
-
-        this.samples_x = 5;
-        this.samples_y = 5;
-
-        this.sigma_x = 10;
-        this.sigma_y = 10;
-
-        /**
-         *
-         * @type {CellFilter}
-         */
-        this.source = null;
-
-        this.size_x = 1;
-        this.size_y = 1;
-
-        /**
-         *
-         * @type {number[]|ArrayLike<number>}
-         * @private
-         */
-        this.__kernel = [];
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__kernel_total_power = 0;
-    }
-
-    initialize(grid, seed) {
-        if (this.initialized) {
-            return;
-        }
-
-        if (!this.source.initialized) {
-            this.source.initialize(grid, seed);
-        }
-
-        this.__kernel = new Float32Array(this.samples_x * this.samples_y);
-
-        // initialize kernel
-        this.__kernel_total_power = buildKernel(this.__kernel, this.samples_x, this.samples_y, this.sigma_x, this.sigma_y);
-
-        super.initialize(grid, seed);
-    }
-
-
-    /**
-     *
-     * @param {CellFilter} source
-     * @param {number} x
-     * @param {number} y
-     * @param {number} quality
-     * @returns {CellFilterGaussianBlur}
-     */
-    static from(source, x, y, quality = 3) {
-        const r = new CellFilterGaussianBlur();
-
-        r.source = source;
-
-        r.samples_x = max2(2, Math.round(quality * x));
-        r.samples_y = max2(2, Math.round(quality * y));
-
-        r.size_x = x;
-        r.size_y = y;
-
-        return r;
-    }
-
-    execute(grid, x, y, rotation) {
-        assert.ok(this.__initialized, 'not initialized');
-
-        const samplesX = this.samples_x;
-        const samplesY = this.samples_y;
-
-        const half_samples_x = (samplesX - 1) * 0.5;
-        const half_samples_y = (samplesY - 1) * 0.5;
-
-        const sizeX = this.size_x;
-        const sizeY = this.size_y;
-
-        const local_u_scale = 1 / (samplesX - 1);
-        const local_v_scale = 1 / (samplesY - 1);
-
-        let sum = 0;
-        let ix, iy = 0;
-
-        const source = this.source;
-        const kernel = this.__kernel;
-
-        const i_samples_x = samplesX | 0;
-
-        for (; iy < samplesY; iy++) {
-            const local_y = iy - half_samples_y;
-
-            const ny = local_y * local_v_scale;
-
-            const offset_y = sizeY * ny;
-
-            const row_address = iy * i_samples_x;
-
-            for (ix = 0; ix < samplesX; ix++) {
-
-                const local_x = ix - half_samples_x;
-
-                const nx = local_x * local_u_scale;
-
-                const offset_x = sizeX * nx;
-
-                const power = kernel[row_address + ix];
-
-                const sourceValue = source.execute(grid, x + offset_x, y + offset_y, 0);
-
-                const sample_contribution = sourceValue * power;
-
-                sum += sample_contribution;
-
-            }
-        }
-
-        const result = sum / this.__kernel_total_power;
-
-        return result;
-    }
-}

package/src/generation/filtering/numeric/complex/CellFilterLookupTable.js

@@ -1,45 +0,0 @@
-import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
-import { assert } from "../../../../core/assert.js";
-
-
-const sample = [];
-
-export class CellFilterLookupTable extends CellFilterUnaryOperation {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {ParameterLookupTable}
-         */
-        this.lut = null;
-    }
-
-    /**
-     *
-     * @param {ParameterLookupTable} lut
-     * @param {CellFilter} source
-     * @return {CellFilterLookupTable}
-     */
-    static from(lut, source) {
-
-        assert.equal(lut.isParameterLookupTable, true, 'lut.isParameterLookupTable !== true');
-        assert.equal(lut.itemSize, 1, 'lut.itemSize !== 1');
-
-        assert.equal(source.isCellFilter, true, 'source.isCellFilter !== true');
-
-        const r = new CellFilterLookupTable();
-
-        r.lut = lut;
-        r.source = source;
-
-        return r;
-    }
-
-    operation(v) {
-        this.lut.sample(v, sample);
-
-        return sample[0];
-    }
-
-}

package/src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js

@@ -1,119 +0,0 @@
-import { seededRandom } from "../../../../core/math/random/seededRandom.js";
-import { CellFilter } from "../../CellFilter.js";
-import SimplexNoise from "simplex-noise";
-import { CellFilterAdd } from "../math/algebra/CellFilterAdd.js";
-import { CellFilterMultiply } from "../math/algebra/CellFilterMultiply.js";
-import { CellFilterLiteralFloat } from "../CellFilterLiteralFloat.js";
-import { CellFilterDivide } from "../math/algebra/CellFilterDivide.js";
-
-export class CellFilterSimplexNoise extends CellFilter {
-    constructor() {
-        super();
-
-        /**
-         * @private
-         * @type {SimplexNoise}
-         */
-        this.noise = null;
-
-        /**
-         * @private
-         * @type {function}
-         */
-        this.random = seededRandom(0);
-
-        this.scale_x = 1;
-        this.scale_y = 1;
-
-        /**
-         * RNG Seed offset
-         * @type {number}
-         * @private
-         */
-        this.__seed = 0;
-    }
-
-    /**
-     * Build a fractal noise filter with a given number of octaves
-     * @param {number} octaves
-     * @param {number} scale
-     * @param {number} persistence
-     * @param {number} lacunarity
-     * @param {number} seed
-     * @returns {CellFilter}
-     */
-    static fractal(octaves, scale, seed = 0, persistence = 0.5, lacunarity = 2) {
-        let s = seed;
-        let r;
-
-        let frequency = 1;
-        let amplitude = 1;
-        let totalAmplitude = 0;
-
-        for (let i = 0; i < octaves; i++) {
-            const noise = CellFilterSimplexNoise.from(scale * frequency, scale * frequency, s);
-
-            if (r === undefined) {
-                r = noise;
-            } else {
-                r = CellFilterAdd.from(
-                    CellFilterMultiply.from(noise, CellFilterLiteralFloat.from(amplitude)),
-                    r
-                );
-            }
-
-            totalAmplitude += amplitude;
-            amplitude *= persistence;
-            frequency *= lacunarity;
-
-            s = (s + 1) * 31;
-        }
-
-        if (totalAmplitude === 1) {
-            return r;
-        } else {
-
-            return CellFilterDivide.from(
-                r,
-                CellFilterLiteralFloat.from(totalAmplitude)
-            );
-
-        }
-    }
-
-    /**
-     *
-     * @param {number} scale_x
-     * @param {number} scale_y
-     * @param {number} [seed]
-     * @returns {CellFilterSimplexNoise}
-     */
-    static from(scale_x, scale_y, seed = 0) {
-        const r = new CellFilterSimplexNoise();
-
-        r.scale_x = scale_x;
-        r.scale_y = scale_y;
-        r.__seed = seed;
-
-        return r;
-    }
-
-    initialize(grid, seed) {
-        this.random.setCurrentSeed(seed + this.__seed);
-
-        const noise = new SimplexNoise(this.random);
-
-        this.noise = noise;
-
-        super.initialize(grid, seed);
-    }
-
-    execute(grid, x, y, rotation) {
-        const noiseValue = this.noise.noise2D(x / this.scale_x, y / this.scale_y);
-
-        //noise function returns values in range [-1,1] we need to scale that to [0,1] range
-        const normalizedValue = (noiseValue + 1) / 2;
-
-        return normalizedValue;
-    }
-}

package/src/generation/filtering/numeric/complex/CellFilterSobel.js

@@ -1,66 +0,0 @@
-import { CellFilter } from "../../CellFilter.js";
-import { assert } from "../../../../core/assert.js";
-
-/**
- * Sobel edge-detection filter
- */
-export class CellFilterSobel extends CellFilter {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {CellFilter}
-         */
-        this.source = null;
-    }
-
-    initialize(grid, seed) {
-        super.initialize(grid, seed);
-
-        if (!this.source.initialized) {
-            this.source.initialize(grid, seed);
-        }
-    }
-
-
-    /**
-     *
-     * @param {CellFilter} source
-     * @returns {CellFilterSobel}
-     */
-    static from(source) {
-        assert.equal(source.isCellFilter, true, 'source.isCellFilter !== true');
-
-        const r = new CellFilterSobel();
-
-        r.source = source;
-
-        return r;
-    }
-
-    execute(grid, x, y, rotation) {
-        const filter = this.source;
-
-        //read surrounding points
-        const topLeft = filter.execute(grid, x - 1, y - 1, 0);
-        const top = filter.execute(grid, x, y - 1, 0);
-        const topRight = filter.execute(grid, x + 1, y - 1, 0);
-
-        const left = filter.execute(grid, x - 1, y, 0);
-        const right = filter.execute(grid, x + 1, y, 0);
-
-        const bottomLeft = filter.execute(grid, x - 1, y + 1, 0);
-        const bottom = filter.execute(grid, x, y + 1, 0);
-        const bottomRight = filter.execute(grid, x + 1, y + 1, 0);
-
-        // compute gradients
-        const dX = (topRight + 2.0 * right + bottomRight) - (topLeft + 2.0 * left + bottomLeft);
-        const dY = (bottomLeft + 2.0 * bottom + bottomRight) - (topLeft + 2.0 * top + topRight);
-
-        //normalize vector
-        const magnitude = Math.sqrt(dX * dX + dY * dY);
-
-        return magnitude;
-    }
-}

package/src/generation/filtering/numeric/math/CellFilterAbsolute.js

@@ -1,27 +0,0 @@
-import { CellFilterUnaryOperation } from "../../core/CellFilterUnaryOperation.js";
-import { assert } from "../../../../core/assert.js";
-
-/**
- * Compute absolute value (see Math.abs)
- */
-export class CellFilterAbsolute extends CellFilterUnaryOperation {
-
-    /**
-     *
-     * @param {CellFilter} source
-     * @returns {CellFilterAbsolute}
-     */
-    static from(source) {
-        assert.equal(source.isCellFilter, true, 'source.isCellFilter !== true');
-
-        const r = new CellFilterAbsolute();
-
-        r.source = source;
-
-        return r;
-    }
-
-    operation(v) {
-        return Math.abs(v);
-    }
-}

package/src/generation/filtering/numeric/math/CellFilterClamp.js

@@ -1,31 +0,0 @@
-import { clamp } from "../../../../core/math/clamp.js";
-import { CellFilterOperationTertiary } from "../../core/CellFilterOperationTertiary.js";
-import { assert } from "../../../../core/assert.js";
-
-export class CellFilterClamp extends CellFilterOperationTertiary {
-    operation(a, b, c) {
-        return clamp(a, b, c);
-    }
-
-    /**
-     *
-     * @param {CellFilter} value
-     * @param {CellFilter} min
-     * @param {CellFilter} max
-     * @returns {CellFilterClamp}
-     */
-    static from(value, min, max) {
-        assert.equal(value.isCellFilter, true, "value.isCellFilter !== true");
-
-        assert.equal(min.isCellFilter, true, "min.isCellFilter !== true");
-        assert.equal(max.isCellFilter, true, "max.isCellFilter !== true");
-
-        const r = new CellFilterClamp();
-
-        r.a = value;
-        r.b = min;
-        r.c = max;
-
-        return r;
-    }
-}

package/src/generation/filtering/numeric/math/CellFilterInverseLerp.js

@@ -1,37 +0,0 @@
-import { inverseLerp } from "../../../../core/math/inverseLerp.js";
-import { CellFilterOperationTertiary } from "../../core/CellFilterOperationTertiary.js";
-import { assert } from "../../../../core/assert.js";
-
-export class CellFilterInverseLerp extends CellFilterOperationTertiary {
-
-    /**
-     *
-     * @param {CellFilter} a
-     * @param {CellFilter} b
-     * @param {CellFilter} f Interpolation factor, expected value between 0 and 1, 0 would lead to filter A being used, and 1 to filter B being used, values between 0 and 1 produce a proportional mix
-     * @returns {CellFilterInverseLerp}
-     */
-    static from(a, b, f) {
-
-        assert.defined(a, 'a');
-        assert.equal(a.isCellFilter, true, 'a.isCellFilter');
-
-        assert.defined(b, 'b');
-        assert.equal(b.isCellFilter, true, 'b.isCellFilter');
-
-        assert.defined(f, 'f');
-        assert.equal(f.isCellFilter, true, 'f.isCellFilter');
-
-        const r = new CellFilterInverseLerp();
-
-        r.a = a;
-        r.b = b;
-        r.c = f;
-
-        return r;
-    }
-
-    operation(a, b, value) {
-        return inverseLerp(a, b, value);
-    }
-}