@field/cascade 0.11.0 → 0.13.0

package/dist/runtime/builtins/image/filters.js

@@ -0,0 +1,394 @@
+import { output, readPlanar } from "./io.js";
+import { Planar, resample, resizeToFit, resolveOutputSize } from "./planar.js";
+/**
+ * `cascade.image.Blur`, `NormalMap`, `Resize`, `Transform` and `Composite`:
+ * the class library's pixel loops, unchanged. An unwired input leaves the
+ * output unset, as the class nodes did.
+ */
+// ---------------------------------------------------------------- Blur
+/** Box radii for an n-pass approximation of a Gaussian of this sigma. */
+function boxesForGauss(sigma, n) {
+    const wIdeal = Math.sqrt((12 * sigma * sigma) / n + 1);
+    let wl = Math.floor(wIdeal);
+    if (wl % 2 === 0)
+        wl--;
+    const wu = wl + 2;
+    const mIdeal = (12 * sigma * sigma - n * wl * wl - 4 * n * wl - 3 * n) / (-4 * wl - 4);
+    const m = Math.round(mIdeal);
+    const sizes = [];
+    for (let i = 0; i < n; i++)
+        sizes.push(i < m ? wl : wu);
+    return sizes.map((s) => (s - 1) / 2);
+}
+/** One box pass, horizontal then vertical, sliding sums: O(1) a pixel. */
+function boxBlurPass(data, w, h, r, wrap) {
+    if (r < 1)
+        return;
+    const temp = new Float32Array(w * h);
+    const ri = Math.floor(r);
+    const invDiameter = 1 / (ri * 2 + 1);
+    for (let y = 0; y < h; y++) {
+        const row = y * w;
+        let sum = 0;
+        for (let i = -ri; i <= ri; i++) {
+            const px = wrap ? ((i % w) + w) % w : Math.max(0, Math.min(w - 1, i));
+            sum += data[row + px];
+        }
+        temp[row] = sum * invDiameter;
+        for (let x = 1; x < w; x++) {
+            const removeX = wrap ? (((x - ri - 1) % w) + w) % w : Math.max(0, x - ri - 1);
+            const addX = wrap ? (((x + ri) % w) + w) % w : Math.min(w - 1, x + ri);
+            sum -= data[row + removeX];
+            sum += data[row + addX];
+            temp[row + x] = sum * invDiameter;
+        }
+    }
+    for (let x = 0; x < w; x++) {
+        let sum = 0;
+        for (let i = -ri; i <= ri; i++) {
+            const py = wrap ? ((i % h) + h) % h : Math.max(0, Math.min(h - 1, i));
+            sum += temp[py * w + x];
+        }
+        data[x] = sum * invDiameter;
+        for (let y = 1; y < h; y++) {
+            const removeY = wrap ? (((y - ri - 1) % h) + h) % h : Math.max(0, y - ri - 1);
+            const addY = wrap ? (((y + ri) % h) + h) % h : Math.min(h - 1, y + ri);
+            sum -= temp[removeY * w + x];
+            sum += temp[addY * w + x];
+            data[y * w + x] = sum * invDiameter;
+        }
+    }
+}
+function boxBlur(source, radius, wrapEdges) {
+    if (radius <= 0)
+        return source.clone();
+    const boxes = boxesForGauss(radius, 3);
+    const result = source.emptyClone();
+    for (let c = 0; c < source.channelCount; c++) {
+        const channel = new Float32Array(source.channels[c]);
+        for (const box of boxes)
+            boxBlurPass(channel, source.width, source.height, box, wrapEdges);
+        result.channels[c].set(channel);
+    }
+    return result;
+}
+function gaussianBlur(source, radius, wrapEdges) {
+    if (radius <= 0)
+        return source.clone();
+    const { width, height } = source;
+    const result = source.emptyClone();
+    const kernelSize = Math.ceil(radius * 3) * 2 + 1;
+    const kernel = new Float32Array(kernelSize);
+    const sigma = radius / 3;
+    const twoSigmaSq = 2 * sigma * sigma;
+    const half = (kernelSize - 1) >> 1;
+    let sum = 0;
+    for (let i = 0; i < kernelSize; i++) {
+        const x = i - half;
+        const value = Math.exp(-(x * x) / twoSigmaSq);
+        kernel[i] = value;
+        sum += value;
+    }
+    const invSum = 1 / sum;
+    for (let i = 0; i < kernelSize; i++)
+        kernel[i] *= invSum;
+    const wrapX = wrapEdges
+        ? (coord) => ((coord % width) + width) % width
+        : (coord) => (coord < 0 ? 0 : coord >= width ? width - 1 : coord);
+    const wrapY = wrapEdges
+        ? (coord) => ((coord % height) + height) % height
+        : (coord) => (coord < 0 ? 0 : coord >= height ? height - 1 : coord);
+    for (let c = 0; c < source.channelCount; c++) {
+        const src = source.channels[c];
+        const dst = result.channels[c];
+        const temp = new Float32Array(width * height);
+        for (let y = 0; y < height; y++) {
+            const row = y * width;
+            for (let x = 0; x < width; x++) {
+                let acc = 0;
+                for (let k = 0; k < kernelSize; k++)
+                    acc += src[row + wrapX(x + k - half)] * kernel[k];
+                temp[row + x] = acc;
+            }
+        }
+        for (let x = 0; x < width; x++) {
+            for (let y = 0; y < height; y++) {
+                let acc = 0;
+                for (let k = 0; k < kernelSize; k++)
+                    acc += temp[wrapY(y + k - half) * width + x] * kernel[k];
+                dst[y * width + x] = acc;
+            }
+        }
+    }
+    return result;
+}
+export async function executeBlur(context) {
+    const source = await readPlanar(context, context.inputs.image);
+    if (!source)
+        return;
+    const { method, radius, wrapEdges } = context.props;
+    await output(context, method === "gaussian" ? gaussianBlur(source, radius, wrapEdges) : boxBlur(source, radius, wrapEdges));
+}
+// ---------------------------------------------------------------- NormalMap
+export async function executeNormalMap(context) {
+    const source = await readPlanar(context, context.inputs.image);
+    if (!source)
+        return;
+    const { scale, flipX, flipY } = context.props;
+    const { width, height } = source;
+    const result = Planar.rgba(width, height);
+    const heightMap = source.channels[0];
+    const [rOut, gOut, bOut, aOut] = result.channels;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = y * width + x;
+            const h00 = heightMap[idx];
+            const h10 = heightMap[Math.min(x + 1, width - 1) + y * width];
+            const h01 = heightMap[x + Math.min(y + 1, height - 1) * width];
+            const dx = (h10 - h00) * scale;
+            const dy = (h01 - h00) * scale;
+            // normalize(-dx, -dy, 1), mapped from [-1, 1] to [0, 1].
+            const nx = -(flipX ? -dx : dx);
+            const ny = -(flipY ? -dy : dy);
+            const nz = 1.0;
+            const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+            rOut[idx] = (nx / length) * 0.5 + 0.5;
+            gOut[idx] = (ny / length) * 0.5 + 0.5;
+            bOut[idx] = (nz / length) * 0.5 + 0.5;
+            aOut[idx] = 1.0;
+        }
+    }
+    await output(context, result);
+}
+// ---------------------------------------------------------------- Resize
+export async function executeResize(context) {
+    const source = await readPlanar(context, context.inputs.image);
+    if (!source)
+        return;
+    const { props } = context;
+    const scaled = props.mode === "scale";
+    const width = scaled ? Math.round(source.width * props.scale) : props.width;
+    const height = scaled ? Math.round(source.height * props.scale) : props.height;
+    await output(context, resample(source, width, height));
+}
+// ---------------------------------------------------------------- Transform
+function pivotPoint(pivot, custom, width, height) {
+    switch (pivot) {
+        case "top-left": return [0, 0];
+        case "top-right": return [width, 0];
+        case "bottom-left": return [0, height];
+        case "bottom-right": return [width, height];
+        case "custom": return [custom[0] * width, custom[1] * height];
+        default: return [width / 2, height / 2];
+    }
+}
+function wrapCoord(coord, size, mode) {
+    if (mode === "clamp")
+        return Math.max(0, Math.min(size - 1, coord));
+    if (mode === "repeat") {
+        coord = coord % size;
+        if (coord < 0)
+            coord += size;
+        return coord;
+    }
+    if (mode === "mirror") {
+        const period = size * 2;
+        coord = Math.abs(coord % period);
+        if (coord >= size)
+            coord = period - coord - 1;
+        return Math.max(0, Math.min(size - 1, coord));
+    }
+    return coord; // transparent: checked before sampling
+}
+export async function executeTransform(context) {
+    const input = await readPlanar(context, context.inputs.image);
+    if (!input)
+        return;
+    const { props } = context;
+    const { width, height } = input;
+    const [tx, ty] = props.translate;
+    const rotation = (props.rotation * Math.PI) / 180;
+    const sx = props.scale[0];
+    const sy = props.uniformScale ? sx : props.scale[1];
+    const [pivotX, pivotY] = pivotPoint(props.pivot, props.customPivot, width, height);
+    const cosR = Math.cos(-rotation);
+    const sinR = Math.sin(-rotation);
+    const invSx = 1 / sx;
+    const invSy = 1 / sy;
+    const buffer = Planar.rgba(width, height);
+    const channelCount = Math.min(input.channelCount, 4);
+    const nearest = props.filter === "nearest";
+    const wrap = props.wrap;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = y * width + x;
+            // Destination to source: about the pivot, rotated and scaled back.
+            const dx = x - pivotX - tx;
+            const dy = y - pivotY - ty;
+            const srcX = (dx * cosR - dy * sinR) * invSx + pivotX;
+            const srcY = (dx * sinR + dy * cosR) * invSy + pivotY;
+            if (wrap === "transparent" && (srcX < 0 || srcX >= width || srcY < 0 || srcY >= height)) {
+                for (let c = 0; c < 4; c++)
+                    buffer.channels[c][idx] = 0;
+                continue;
+            }
+            if (nearest) {
+                const srcIdx = wrapCoord(Math.round(srcY), height, wrap) * width + wrapCoord(Math.round(srcX), width, wrap);
+                for (let c = 0; c < channelCount; c++)
+                    buffer.channels[c][idx] = input.channels[c][srcIdx];
+            }
+            else {
+                const x0 = Math.floor(srcX);
+                const y0 = Math.floor(srcY);
+                const fx = srcX - x0;
+                const fy = srcY - y0;
+                const wx0 = wrapCoord(x0, width, wrap);
+                const wx1 = wrapCoord(x0 + 1, width, wrap);
+                const wy0 = wrapCoord(y0, height, wrap);
+                const wy1 = wrapCoord(y0 + 1, height, wrap);
+                for (let c = 0; c < channelCount; c++) {
+                    const channel = input.channels[c];
+                    const v00 = channel[wy0 * width + wx0];
+                    const v10 = channel[wy0 * width + wx1];
+                    const v01 = channel[wy1 * width + wx0];
+                    const v11 = channel[wy1 * width + wx1];
+                    const v0 = v00 + (v10 - v00) * fx;
+                    const v1 = v01 + (v11 - v01) * fx;
+                    buffer.channels[c][idx] = v0 + (v1 - v0) * fy;
+                }
+            }
+            if (channelCount < 4)
+                buffer.channels[3][idx] = 1;
+        }
+    }
+    await output(context, buffer);
+}
+// ---------------------------------------------------------------- Composite
+function blend(base, layer, mode, opacity) {
+    const { width, height } = base;
+    const result = Planar.rgba(width, height);
+    const [r1, g1, b1, a1] = (base.channelCount >= 4 ? base : base.toRGBA()).channels;
+    const [r2, g2, b2, a2] = (layer.channelCount >= 4 ? layer : layer.toRGBA()).channels;
+    const [rOut, gOut, bOut, aOut] = result.channels;
+    for (let i = 0; i < width * height; i++) {
+        const baseR = r1[i], baseG = g1[i], baseB = b1[i], baseA = a1[i];
+        const blendR = r2[i], blendG = g2[i], blendB = b2[i], blendA = a2[i];
+        let r, g, b;
+        switch (mode) {
+            case "normal":
+                r = blendR;
+                g = blendG;
+                b = blendB;
+                break;
+            case "multiply":
+                r = baseR * blendR;
+                g = baseG * blendG;
+                b = baseB * blendB;
+                break;
+            case "screen":
+                r = 1 - (1 - baseR) * (1 - blendR);
+                g = 1 - (1 - baseG) * (1 - blendG);
+                b = 1 - (1 - baseB) * (1 - blendB);
+                break;
+            case "overlay":
+                r = baseR < 0.5 ? 2 * baseR * blendR : 1 - 2 * (1 - baseR) * (1 - blendR);
+                g = baseG < 0.5 ? 2 * baseG * blendG : 1 - 2 * (1 - baseG) * (1 - blendG);
+                b = baseB < 0.5 ? 2 * baseB * blendB : 1 - 2 * (1 - baseB) * (1 - blendB);
+                break;
+            case "darken":
+                r = Math.min(baseR, blendR);
+                g = Math.min(baseG, blendG);
+                b = Math.min(baseB, blendB);
+                break;
+            case "lighten":
+                r = Math.max(baseR, blendR);
+                g = Math.max(baseG, blendG);
+                b = Math.max(baseB, blendB);
+                break;
+            case "color-dodge":
+                r = blendR === 1 ? 1 : Math.min(1, baseR / (1 - blendR));
+                g = blendG === 1 ? 1 : Math.min(1, baseG / (1 - blendG));
+                b = blendB === 1 ? 1 : Math.min(1, baseB / (1 - blendB));
+                break;
+            case "color-burn":
+                r = blendR === 0 ? 0 : Math.max(0, 1 - (1 - baseR) / blendR);
+                g = blendG === 0 ? 0 : Math.max(0, 1 - (1 - baseG) / blendG);
+                b = blendB === 0 ? 0 : Math.max(0, 1 - (1 - baseB) / blendB);
+                break;
+            case "hard-light":
+                r = blendR < 0.5 ? 2 * baseR * blendR : 1 - 2 * (1 - baseR) * (1 - blendR);
+                g = blendG < 0.5 ? 2 * baseG * blendG : 1 - 2 * (1 - baseG) * (1 - blendG);
+                b = blendB < 0.5 ? 2 * baseB * blendB : 1 - 2 * (1 - baseB) * (1 - blendB);
+                break;
+            case "soft-light":
+                r = blendR < 0.5 ? baseR - (1 - 2 * blendR) * baseR * (1 - baseR) : baseR + (2 * blendR - 1) * (Math.sqrt(baseR) - baseR);
+                g = blendG < 0.5 ? baseG - (1 - 2 * blendG) * baseG * (1 - baseG) : baseG + (2 * blendG - 1) * (Math.sqrt(baseG) - baseG);
+                b = blendB < 0.5 ? baseB - (1 - 2 * blendB) * baseB * (1 - baseB) : baseB + (2 * blendB - 1) * (Math.sqrt(baseB) - baseB);
+                break;
+            case "difference":
+                r = Math.abs(baseR - blendR);
+                g = Math.abs(baseG - blendG);
+                b = Math.abs(baseB - blendB);
+                break;
+            case "exclusion":
+                r = baseR + blendR - 2 * baseR * blendR;
+                g = baseG + blendG - 2 * baseG * blendG;
+                b = baseB + blendB - 2 * baseB * blendB;
+                break;
+            case "add":
+            case "linear-dodge":
+                r = Math.min(1, baseR + blendR);
+                g = Math.min(1, baseG + blendG);
+                b = Math.min(1, baseB + blendB);
+                break;
+            case "subtract":
+                r = Math.max(0, baseR - blendR);
+                g = Math.max(0, baseG - blendG);
+                b = Math.max(0, baseB - blendB);
+                break;
+            case "divide":
+                r = blendR === 0 ? 1 : Math.min(1, baseR / blendR);
+                g = blendG === 0 ? 1 : Math.min(1, baseG / blendG);
+                b = blendB === 0 ? 1 : Math.min(1, baseB / blendB);
+                break;
+            case "pin-light":
+                r = blendR < 0.5 ? Math.min(baseR, 2 * blendR) : Math.max(baseR, 2 * (blendR - 0.5));
+                g = blendG < 0.5 ? Math.min(baseG, 2 * blendG) : Math.max(baseG, 2 * (blendG - 0.5));
+                b = blendB < 0.5 ? Math.min(baseB, 2 * blendB) : Math.max(baseB, 2 * (blendB - 0.5));
+                break;
+            case "vivid-light":
+                r = blendR < 0.5 ? (blendR === 0 ? 0 : 1 - (1 - baseR) / (2 * blendR)) : (blendR === 1 ? 1 : baseR / (2 * (1 - blendR)));
+                g = blendG < 0.5 ? (blendG === 0 ? 0 : 1 - (1 - baseG) / (2 * blendG)) : (blendG === 1 ? 1 : baseG / (2 * (1 - blendG)));
+                b = blendB < 0.5 ? (blendB === 0 ? 0 : 1 - (1 - baseB) / (2 * blendB)) : (blendB === 1 ? 1 : baseB / (2 * (1 - blendB)));
+                break;
+            case "linear-burn":
+                r = Math.max(0, baseR + blendR - 1);
+                g = Math.max(0, baseG + blendG - 1);
+                b = Math.max(0, baseB + blendB - 1);
+                break;
+            default:
+                r = blendR;
+                g = blendG;
+                b = blendB;
+        }
+        rOut[i] = baseR + (r - baseR) * opacity * blendA;
+        gOut[i] = baseG + (g - baseG) * opacity * blendA;
+        bOut[i] = baseB + (b - baseB) * opacity * blendA;
+        aOut[i] = baseA + (blendA - baseA) * opacity;
+    }
+    return result;
+}
+export async function executeComposite(context) {
+    const { props } = context;
+    const inputs = [await readPlanar(context, context.inputs.image1), await readPlanar(context, context.inputs.image2)];
+    const { width, height } = resolveOutputSize(props.outputResolution, inputs, props.customResolution);
+    const [base, layer] = inputs.map((buffer) => {
+        if (!buffer || (buffer.width === width && buffer.height === height))
+            return buffer;
+        return resizeToFit(buffer, width, height, props.fitMode);
+    });
+    if (!base || !layer)
+        return;
+    await output(context, blend(base, layer, props.blendMode, props.opacity));
+}
+//# sourceMappingURL=filters.js.map

package/dist/runtime/builtins/image/generators.d.ts

@@ -0,0 +1,7 @@
+import type { NodeExecutionContext } from "@field/cascade/contracts";
+import type { checkersDefinition, colorDefinition, noiseDefinition, rampDefinition } from "./definitions.js";
+export declare function executeColor(context: NodeExecutionContext<typeof colorDefinition>): Promise<void>;
+export declare function executeCheckers(context: NodeExecutionContext<typeof checkersDefinition>): Promise<void>;
+export declare function executeNoise(context: NodeExecutionContext<typeof noiseDefinition>): Promise<void>;
+export declare function executeRamp(context: NodeExecutionContext<typeof rampDefinition>): Promise<void>;
+//# sourceMappingURL=generators.d.ts.map

package/dist/runtime/builtins/image/generators.js

@@ -0,0 +1,144 @@
+import { normalizeColor, output } from "./io.js";
+import { Planar } from "./planar.js";
+import { createNoise2D } from "./simplex.js";
+/** `cascade.image.Color`, `Checkers`, `Noise` and `Ramp`: images from props alone. */
+function size(resolution) {
+    return [resolution[0], resolution[1]];
+}
+export async function executeColor(context) {
+    const [width, height] = size(context.props.resolution);
+    await output(context, Planar.solid(width, height, normalizeColor(context.props.color)));
+}
+export async function executeCheckers(context) {
+    const { props } = context;
+    const [width, height] = size(props.resolution);
+    const color1 = normalizeColor(props.color1);
+    const color2 = normalizeColor(props.color2);
+    const checkerSize = props.mode === "size" ? props.size : width / props.divisions;
+    let offsetX = 0;
+    let offsetY = 0;
+    if (props.centered) {
+        // The centre of the image is the centre of a cell.
+        offsetX = (width / 2) % checkerSize - checkerSize / 2;
+        offsetY = (height / 2) % checkerSize - checkerSize / 2;
+    }
+    const buffer = Planar.rgba(width, height);
+    const [r, g, b, a] = buffer.channels;
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const idx = y * width + x;
+            const even = (Math.floor((x - offsetX) / checkerSize) + Math.floor((y - offsetY) / checkerSize)) % 2 === 0;
+            const color = even ? color1 : color2;
+            r[idx] = color.r;
+            g[idx] = color.g;
+            b[idx] = color.b;
+            a[idx] = color.a;
+        }
+    }
+    await output(context, buffer);
+}
+export async function executeNoise(context) {
+    const { props } = context;
+    const [width, height] = size(props.resolution);
+    // The class node's LCG, so a seed draws the noise it always drew.
+    let rng = props.seed;
+    const noise2D = createNoise2D(() => {
+        rng = (rng * 9301 + 49297) % 233280;
+        return rng / 233280;
+    });
+    const buffer = Planar.grayscale(width, height);
+    const gray = buffer.channels[0];
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let value = 0;
+            let amplitude = 1;
+            let frequency = props.scale;
+            let maxValue = 0;
+            for (let i = 0; i < props.iterations; i++) {
+                value += noise2D(x * frequency, y * frequency) * amplitude;
+                maxValue += amplitude;
+                amplitude *= 0.5;
+                frequency *= 2;
+            }
+            gray[y * width + x] = (value / maxValue + 1) * 0.5;
+        }
+    }
+    await output(context, buffer);
+}
+function interpolateColor(color1, color2, t, interpolation) {
+    if (interpolation === "constant")
+        return t < 0.5 ? color1 : color2;
+    if (interpolation === "smooth")
+        t = t * t * (3 - 2 * t);
+    return {
+        r: color1.r + (color2.r - color1.r) * t,
+        g: color1.g + (color2.g - color1.g) * t,
+        b: color1.b + (color2.b - color1.b) * t,
+        a: (color1.a ?? 1) + ((color2.a ?? 1) - (color1.a ?? 1)) * t,
+    };
+}
+function colorAt(points, position) {
+    const sorted = [...points].sort((a, b) => a.position - b.position);
+    position = Math.max(0, Math.min(1, position));
+    let before = null;
+    let after = null;
+    for (const point of sorted) {
+        if (point.position <= position)
+            before = point;
+        if (point.position >= position && !after) {
+            after = point;
+            break;
+        }
+    }
+    if (!before && after)
+        return normalizeColor(after.color);
+    if (before && !after)
+        return normalizeColor(before.color);
+    if (!before || !after)
+        return { r: 0, g: 0, b: 0, a: 1 };
+    if (before.position === position)
+        return normalizeColor(before.color);
+    if (after.position === position)
+        return normalizeColor(after.color);
+    const t = (position - before.position) / (after.position - before.position);
+    return interpolateColor(normalizeColor(before.color), normalizeColor(after.color), t, after.interpolation || "linear");
+}
+export async function executeRamp(context) {
+    const { props } = context;
+    const [width, height] = size(props.resolution);
+    const points = (props.points ?? []);
+    if (points.length === 0)
+        return;
+    const buffer = Planar.rgba(width, height);
+    const [r, g, b, a] = buffer.channels;
+    const centerX = width / 2;
+    const centerY = height / 2;
+    const maxDist = Math.sqrt(centerX * centerX + centerY * centerY);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            let position = 0;
+            if (props.type === "horizontal") {
+                position = x / width;
+            }
+            else if (props.type === "vertical") {
+                position = y / height;
+            }
+            else if (props.type === "radial") {
+                position = (Math.atan2(y - centerY, x - centerX) + Math.PI) / (2 * Math.PI);
+            }
+            else if (props.type === "concentric") {
+                const dx = x - centerX;
+                const dy = y - centerY;
+                position = Math.sqrt(dx * dx + dy * dy) / maxDist;
+            }
+            const color = colorAt(points, position);
+            const idx = y * width + x;
+            r[idx] = color.r;
+            g[idx] = color.g;
+            b[idx] = color.b;
+            a[idx] = color.a ?? 1;
+        }
+    }
+    await output(context, buffer);
+}
+//# sourceMappingURL=generators.js.map