@webex/ladon-ts 4.0.0 → 4.2.1

package/build/module/lib/pipeline.js

@@ -1,83 +1,92 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { LocalGenerator, NullGenerator, WorkerGenerator, } from './generator';
-import { BlurRenderer, PassthroughRenderer, ReplacementRenderer, } from './renderer';
-export class Pipeline {
-    constructor(input_canvas, output_canvas, config) {
-        this.input_canvas = input_canvas;
-        this.output_canvas = output_canvas;
-        this.config = config;
-        this.loaded = false;
-        const input_ctx = this.input_canvas.getContext('2d', {
-            alpha: false,
-        });
-        if (!input_ctx) {
-            throw new Error('[ladon-ts] - error getting input context 2d');
-        }
-        this.input_ctx = input_ctx;
-    }
-    onFrame() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.generator || !this.renderer) {
-                throw new Error('[ladon-ts] - pipeline is not loaded.');
-            }
-            const raw_image_data = this.input_ctx.getImageData(0, 0, this.config.input.width, this.config.input.height).data;
-            const mask = yield this.generator.getMask(raw_image_data);
-            yield this.renderer.render(raw_image_data, mask);
-            yield this.generator.postRender(raw_image_data);
-        });
-    }
-    isLoaded() {
-        return this.loaded;
-    }
-    load() {
-        return __awaiter(this, void 0, void 0, function* () {
-            switch (this.config.render.type) {
-                case 'blur':
-                    this.renderer = new BlurRenderer(this.output_canvas, this.config);
-                    break;
-                case 'passthrough':
-                    this.renderer = new PassthroughRenderer(this.output_canvas, this.config);
-                    break;
-                case 'replacement':
-                    this.renderer = new ReplacementRenderer(this.output_canvas, this.config);
-                    break;
-                default:
-                    throw new Error('[ladon-ts] - renderer not implemented.');
-            }
-            yield this.renderer.load();
-            if (this.config.render.type === 'passthrough') {
-                // automatically disable model evaluation when the renderer is set to passthrough
-                // Note: this may change when gestures are detected (model eval will be a dependency for more than rendering)
-                this.generator = new NullGenerator(this.config);
-            }
-            else {
-                switch (this.config.mask.generator) {
-                    case 'local':
-                        this.generator = new LocalGenerator(this.config);
-                        break;
-                    case 'worker':
-                        this.generator = new WorkerGenerator(this.config);
-                        break;
-                    default:
-                        throw new Error('[ladon-ts] - generator not implemented.');
-                }
-            }
-            yield this.generator.load();
-            this.loaded = true;
-        });
-    }
-    destroy() {
-        var _a, _b;
-        (_a = this.generator) === null || _a === void 0 ? void 0 : _a.destroy();
-        (_b = this.renderer) === null || _b === void 0 ? void 0 : _b.destroy();
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { LocalGenerator, NullGenerator, WorkerGenerator } from './generator';
+import { BlurRenderer, PassthroughRenderer, ReplacementRenderer } from './renderer';
+import { resizeImage } from './util';
+export class Pipeline {
+    constructor(input_canvas, output_canvas, config) {
+        this.input_canvas = input_canvas;
+        this.output_canvas = output_canvas;
+        this.config = config;
+        this.loaded = false;
+        const input_ctx = this.input_canvas.getContext('2d', {
+            alpha: false,
+            willReadFrequently: true,
+        });
+        if (!input_ctx) {
+            throw new Error('[ladon-ts] - error getting input context 2d');
+        }
+        this.input_ctx = input_ctx;
+    }
+    onFrame() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.generator || !this.renderer) {
+                throw new Error('[ladon-ts] - pipeline is not loaded.');
+            }
+            const rawImageData = this.input_ctx.getImageData(0, 0, this.config.input.width, this.config.input.height).data;
+            let maskImageData = rawImageData;
+            // Resize the image data if the model expects a fixed size input (e.g., tiny model).
+            if (this.config.mask.input_size.width !== this.config.input.width) {
+                maskImageData = resizeImage(rawImageData, this.config.input.width, this.config.input.height, this.config.mask.input_size.width, this.config.mask.input_size.height);
+            }
+            const mask = yield this.generator.getMask(maskImageData);
+            // Render the full size video image in the background with the mask on top.
+            yield this.renderer.render(rawImageData, mask);
+            // Cleanup the mask data.
+            yield this.generator.postRender(maskImageData);
+        });
+    }
+    isLoaded() {
+        return this.loaded;
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (this.config.render.type) {
+                case 'blur':
+                    this.renderer = new BlurRenderer(this.output_canvas, this.config);
+                    break;
+                case 'passthrough':
+                    this.renderer = new PassthroughRenderer(this.output_canvas, this.config);
+                    break;
+                case 'replacement':
+                    this.renderer = new ReplacementRenderer(this.output_canvas, this.config);
+                    break;
+                default:
+                    throw new Error('[ladon-ts] - renderer not implemented.');
+            }
+            yield this.renderer.load();
+            if (this.config.render.type === 'passthrough') {
+                // automatically disable model evaluation when the renderer is set to passthrough
+                // Note: this may change when gestures are detected (model eval will be a dependency for more than rendering)
+                this.generator = new NullGenerator(this.config);
+            }
+            else {
+                switch (this.config.mask.generator) {
+                    case 'local':
+                        this.generator = new LocalGenerator(this.config);
+                        break;
+                    case 'worker':
+                        this.generator = new WorkerGenerator(this.config);
+                        break;
+                    default:
+                        throw new Error('[ladon-ts] - generator not implemented.');
+                }
+            }
+            yield this.generator.load();
+            this.loaded = true;
+        });
+    }
+    destroy() {
+        var _a, _b;
+        (_a = this.generator) === null || _a === void 0 ? void 0 : _a.destroy();
+        (_b = this.renderer) === null || _b === void 0 ? void 0 : _b.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/renderer/blur-renderer.d.ts

@@ -0,0 +1,21 @@
+import { PipelineConfig } from '../config';
+import { MaskResult } from '../generator';
+import { LadonRenderer } from './ladon-renderer';
+import { WebGLRenderer } from './webgl-renderer';
+export declare class BlurRenderer extends WebGLRenderer implements LadonRenderer {
+    output_canvas: HTMLCanvasElement;
+    readonly config: PipelineConfig;
+    private program_1;
+    private program_2;
+    private framebuffer;
+    private transfer_texture;
+    private u_blur;
+    private fragment_shader_common;
+    private fragment_shader_pass_1_src;
+    fragment_shader_pass_2_src: string;
+    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    render(input: Uint8ClampedArray, mask: MaskResult): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+    private getBlurKernel;
+}

package/build/module/lib/renderer/blur-renderer.js

@@ -0,0 +1,190 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { compileShader, linkProgram } from '../util';
+import { WebGLRenderer } from './webgl-renderer';
+export class BlurRenderer extends WebGLRenderer {
+    constructor(output_canvas, config) {
+        super(output_canvas, config);
+        this.output_canvas = output_canvas;
+        this.config = config;
+        this.fragment_shader_common = `#version 300 es
+precision highp float;
+
+#define KERNEL_SIZE     ${this.config.render.kernel_size}
+#define HORIZONTAL      vec2(1.0, 0.0)
+#define VERTICAL        vec2(0.0, 1.0)
+#define EPSILON         0.00001
+
+out vec4 outColor;
+
+uniform sampler2D       u_image;
+uniform float           u_kernel[KERNEL_SIZE];
+uniform sampler2D       u_mask;
+uniform vec2            u_resolution;
+
+
+float get_mask(vec2 st) {
+    return clamp(texture(u_mask, st).r, 0.0, 1.0);
+}
+
+float get_inv_mask(vec2 st) {
+    return 1.0 - get_mask(st);
+}
+
+vec4 get_offset_mul(sampler2D src, vec2 uv, float weight) {
+    if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) {
+        return vec4(vec3(0.0), weight);
+    }
+
+    // 4th channel is masked weight value
+    return vec4(vec3(texture(src, uv).rgb * get_inv_mask(uv) * weight), get_mask(uv) * weight);
+}
+
+vec3 blur(sampler2D src, vec2 uv, vec2 direction) {
+    vec4 result = vec4(0.0);
+
+    vec2 step = (direction / u_resolution);
+    int offset = (KERNEL_SIZE - 1) / 2;
+
+    for (int i = 0; i < KERNEL_SIZE; i++) {
+        vec2 offset = step * float(i - offset);
+        result += get_offset_mul(src, uv + offset, u_kernel[i]);
+    }
+
+    if (abs(result.a - 1.0) < EPSILON) {
+        return vec3(0.0);
+    }
+
+    // redistribute weights from masked areas
+    return result.rgb * (1.0 + (result.a / (1.0 - result.a)));
+}
+`;
+        this.fragment_shader_pass_1_src = this.fragment_shader_common +
+            `
+void main() {
+    vec2 st = gl_FragCoord.xy / u_resolution;
+
+    outColor = vec4(blur(u_image, st, HORIZONTAL) * get_inv_mask(st), 1.0);
+}
+`;
+        this.fragment_shader_pass_2_src = this.fragment_shader_common +
+            `
+uniform sampler2D   u_blur;
+
+
+void main() {
+    ${this.getUVCalculation()}
+
+    vec3 blurred = blur(u_blur, st, VERTICAL);
+    vec3 image = texture(u_image, st).rgb;
+    float mask = texture(u_mask, st).r;
+
+    outColor = vec4(blurred * (1.0 - mask) + image * mask, 1.0);
+}
+`;
+        if (this.config.render.kernel_size % 2 === 0) {
+            throw new Error('[ladon-ts] - kernel_size must be odd');
+        }
+        // program pass 1 setup
+        {
+            const vertex_shader = compileShader(this.gl, this.gl.VERTEX_SHADER, this.vertex_shader_src);
+            const fragment_shader = compileShader(this.gl, this.gl.FRAGMENT_SHADER, this.fragment_shader_pass_1_src);
+            this.program_1 = linkProgram(this.gl, vertex_shader, fragment_shader);
+            this.gl.useProgram(this.program_1);
+            const framebuffer = this.gl.createFramebuffer();
+            if (!framebuffer) {
+                throw new Error('[ladon-ts] - error creating framebuffer');
+            }
+            this.framebuffer = framebuffer;
+            const transfer_texture = this.gl.createTexture();
+            if (!transfer_texture) {
+                throw new Error('[ladon-ts] - error creating output texture');
+            }
+            this.transfer_texture = transfer_texture;
+            this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, this.framebuffer);
+            this.gl.bindTexture(this.gl.TEXTURE_2D, this.transfer_texture);
+            this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR);
+            this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
+            this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
+            this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, this.config.input.width, this.config.input.height, 0, this.gl.RGBA, this.gl.UNSIGNED_BYTE, null);
+            this.gl.framebufferTexture2D(this.gl.FRAMEBUFFER, this.gl.COLOR_ATTACHMENT0, this.gl.TEXTURE_2D, this.transfer_texture, 0);
+            this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null);
+            this.setSharedUniforms(this.program_1);
+            const u_kernel = this.gl.getUniformLocation(this.program_1, 'u_kernel');
+            if (!u_kernel) {
+                throw new Error('[ladon-ts] - error finding "u_kernel" uniform');
+            }
+            this.gl.uniform1fv(u_kernel, this.getBlurKernel());
+        }
+        // program pass 2 setup
+        {
+            const vertex_shader = compileShader(this.gl, this.gl.VERTEX_SHADER, this.vertex_shader_src);
+            const fragment_shader = compileShader(this.gl, this.gl.FRAGMENT_SHADER, this.fragment_shader_pass_2_src);
+            this.program_2 = linkProgram(this.gl, vertex_shader, fragment_shader);
+            this.gl.useProgram(this.program_2);
+            const u_blur = this.gl.getUniformLocation(this.program_2, 'u_blur');
+            if (!u_blur) {
+                throw new Error('[ladon-ts] - error finding "u_blur" uniform');
+            }
+            this.u_blur = u_blur;
+            this.gl.activeTexture(this.gl.TEXTURE2);
+            this.gl.bindTexture(this.gl.TEXTURE_2D, this.transfer_texture);
+            this.gl.uniform1i(this.u_blur, 2);
+            this.setSharedUniforms(this.program_2);
+            const u_kernel = this.gl.getUniformLocation(this.program_2, 'u_kernel');
+            if (!u_kernel) {
+                throw new Error('[ladon-ts] - error finding "u_kernel" uniform');
+            }
+            this.gl.uniform1fv(u_kernel, this.getBlurKernel());
+        }
+    }
+    render(input, mask) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.uploadVideoStream(input);
+            if (mask.warm) {
+                this.gl.activeTexture(this.gl.TEXTURE1);
+                this.gl.bindTexture(this.gl.TEXTURE_2D, this.mask_texture);
+                this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.R32F, this.config.mask.output_size.width, this.config.mask.output_size.height, 0, this.gl.RED, this.gl.FLOAT, mask.data);
+            }
+            // program pass 1 - blur in one direction & output to framebuffer
+            this.gl.useProgram(this.program_1);
+            this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, this.framebuffer);
+            this.gl.drawArrays(this.gl.TRIANGLES, 0, this.verts.length / 3);
+            this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, null);
+            // program pass 2 - blur in other direction & draw to screen
+            this.gl.useProgram(this.program_2);
+            this.gl.drawArrays(this.gl.TRIANGLES, 0, this.verts.length / 3);
+            this.postDraw();
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // empty
+        });
+    }
+    destroy() {
+        // empty
+    }
+    getBlurKernel() {
+        const kernel = [];
+        let sum = 0;
+        for (let i = 0; i < this.config.render.kernel_size; i++) {
+            let w = i - (this.config.render.kernel_size - 1) / 2;
+            w = Math.exp(-(Math.pow(w, 2)) / Math.pow(this.config.render.sigma, 2));
+            kernel.push(w);
+            sum += w;
+        }
+        for (let i = 0; i < this.config.render.kernel_size; i++) {
+            kernel[i] = kernel[i] / sum;
+        }
+        return new Float32Array(kernel);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blur-renderer.js","sourceRoot":"","sources":["../../../../src/lib/renderer/blur-renderer.ts"],"names":[],"mappings":"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"}

package/build/module/lib/renderer/ladon-renderer.d.ts

@@ -0,0 +1,6 @@
+import { MaskResult } from '../generator';
+export interface LadonRenderer {
+    render(input: Uint8ClampedArray, mask: MaskResult): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/renderer/ladon-renderer.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFkb24tcmVuZGVyZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlbmRlcmVyL2xhZG9uLXJlbmRlcmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/build/module/lib/renderer/passthrough-renderer.d.ts

@@ -0,0 +1,14 @@
+import { PipelineConfig } from '../config';
+import { MaskResult } from '../generator';
+import { LadonRenderer } from './ladon-renderer';
+import { WebGLRenderer } from './webgl-renderer';
+export declare class PassthroughRenderer extends WebGLRenderer implements LadonRenderer {
+    output_canvas: HTMLCanvasElement;
+    readonly config: PipelineConfig;
+    private program;
+    private fragment_shader;
+    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    render(input: Uint8ClampedArray, _: MaskResult): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/renderer/passthrough-renderer.js

@@ -0,0 +1,57 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { compileShader, linkProgram } from '../util';
+import { WebGLRenderer } from './webgl-renderer';
+export class PassthroughRenderer extends WebGLRenderer {
+    constructor(output_canvas, config) {
+        super(output_canvas, config);
+        this.output_canvas = output_canvas;
+        this.config = config;
+        this.fragment_shader = `#version 300 es
+precision highp float;
+
+out vec4 outColor;
+
+uniform sampler2D       u_image;
+uniform vec2            u_resolution;
+
+
+void main() {
+    ${this.getUVCalculation()}
+
+    outColor = vec4(texture(u_image, st).rgb, 1.0);
+}
+`;
+        const vertex_shader = compileShader(this.gl, this.gl.VERTEX_SHADER, this.vertex_shader_src);
+        const fragment_shader = compileShader(this.gl, this.gl.FRAGMENT_SHADER, this.fragment_shader);
+        this.program = linkProgram(this.gl, vertex_shader, fragment_shader);
+        this.gl.useProgram(this.program);
+        this.setSharedUniforms(this.program);
+    }
+    render(input, 
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    _) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.uploadVideoStream(input);
+            this.gl.useProgram(this.program);
+            this.gl.drawArrays(this.gl.TRIANGLES, 0, this.verts.length / 3);
+            this.postDraw();
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // empty
+        });
+    }
+    destroy() {
+        // empty
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFzc3Rocm91Z2gtcmVuZGVyZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3JlbmRlcmVyL3Bhc3N0aHJvdWdoLXJlbmRlcmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUVBLE9BQU8sRUFBRSxhQUFhLEVBQUUsV0FBVyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBR3JELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVqRCxNQUFNLE9BQU8sbUJBQW9CLFNBQVEsYUFBYTtJQW1CbEQsWUFBbUIsYUFBZ0MsRUFBa0IsTUFBc0I7UUFDdkYsS0FBSyxDQUFDLGFBQWEsRUFBRSxNQUFNLENBQUMsQ0FBQztRQURkLGtCQUFhLEdBQWIsYUFBYSxDQUFtQjtRQUFrQixXQUFNLEdBQU4sTUFBTSxDQUFnQjtRQWhCbkYsb0JBQWUsR0FBRzs7Ozs7Ozs7OztNQVV4QixJQUFJLENBQUMsZ0JBQWdCLEVBQUU7Ozs7Q0FJNUIsQ0FBQztRQUtNLE1BQU0sYUFBYSxHQUFHLGFBQWEsQ0FBQyxJQUFJLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxFQUFFLENBQUMsYUFBYSxFQUFFLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO1FBQzVGLE1BQU0sZUFBZSxHQUFHLGFBQWEsQ0FDakMsSUFBSSxDQUFDLEVBQUUsRUFDUCxJQUFJLENBQUMsRUFBRSxDQUFDLGVBQWUsRUFDdkIsSUFBSSxDQUFDLGVBQWUsQ0FDdkIsQ0FBQztRQUVGLElBQUksQ0FBQyxPQUFPLEdBQUcsV0FBVyxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsYUFBYSxFQUFFLGVBQWUsQ0FBQyxDQUFDO1FBQ3BFLElBQUksQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUVqQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQ3pDLENBQUM7SUFFWSxNQUFNLENBQ2YsS0FBd0I7SUFDeEIsZ0VBQWdFO0lBQ2hFLENBQWE7O1lBRWIsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEtBQUssQ0FBQyxDQUFDO1lBRTlCLElBQUksQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUVqQyxJQUFJLENBQUMsRUFBRSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxDQUFDLEVBQUUsSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUM7WUFFaEUsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ3BCLENBQUM7S0FBQTtJQUVZLElBQUk7O1lBQ2IsUUFBUTtRQUNaLENBQUM7S0FBQTtJQUVNLE9BQU87UUFDVixRQUFRO0lBQ1osQ0FBQztDQUNKIn0=

package/build/module/lib/renderer/replacement-renderer.d.ts

@@ -0,0 +1,16 @@
+import { PipelineConfig } from '../config';
+import { MaskResult } from '../generator';
+import { LadonRenderer } from './ladon-renderer';
+import { WebGLRenderer } from './webgl-renderer';
+export declare class ReplacementRenderer extends WebGLRenderer implements LadonRenderer {
+    output_canvas: HTMLCanvasElement;
+    readonly config: PipelineConfig;
+    private program;
+    private background_canvas_ctx;
+    protected background_texture: WebGLTexture;
+    private fragment_shader;
+    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    render(input: Uint8ClampedArray, mask: MaskResult): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/renderer/replacement-renderer.js

@@ -0,0 +1,103 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { compileShader, linkProgram } from '../util';
+import { WebGLRenderer } from './webgl-renderer';
+export class ReplacementRenderer extends WebGLRenderer {
+    constructor(output_canvas, config) {
+        super(output_canvas, config);
+        this.output_canvas = output_canvas;
+        this.config = config;
+        this.fragment_shader = `#version 300 es
+precision highp float;
+
+out vec4 outColor;
+
+uniform sampler2D       u_background;
+uniform sampler2D       u_image;
+uniform sampler2D       u_mask;
+uniform vec2            u_resolution;
+
+
+float get_mask(vec2 st) {
+    return clamp(texture(u_mask, st).r, 0.0, 1.0);
+}
+
+float get_inv_mask(vec2 st) {
+    return 1.0 - get_mask(st);
+}
+
+void main() {
+    ${this.getUVCalculation()}
+
+    outColor = vec4(texture(u_background, st).rgb * get_inv_mask(st) + texture(u_image, st).rgb * get_mask(st), 1.0);
+}
+`;
+        const background_canvas_ctx = this.config.render.background.getContext('2d');
+        if (!background_canvas_ctx) {
+            throw new Error('[ladon-ts] - could not get background canvas context 2d');
+        }
+        this.background_canvas_ctx = background_canvas_ctx;
+        const background_data = this.background_canvas_ctx.getImageData(0, 0, this.config.render.background.width, this.config.render.background.height).data;
+        if (this.config.render.kernel_size % 2 === 0) {
+            throw new Error('[ladon-ts] - kernel_size must be odd');
+        }
+        const vertex_shader = compileShader(this.gl, this.gl.VERTEX_SHADER, this.vertex_shader_src);
+        const fragment_shader = compileShader(this.gl, this.gl.FRAGMENT_SHADER, this.fragment_shader);
+        this.program = linkProgram(this.gl, vertex_shader, fragment_shader);
+        this.gl.useProgram(this.program);
+        this.setSharedUniforms(this.program);
+        const background_texture = this.gl.createTexture();
+        if (!background_texture) {
+            throw new Error('[ladon-ts] - error creating input texture');
+        }
+        this.background_texture = background_texture;
+        this.gl.bindTexture(this.gl.TEXTURE_2D, this.background_texture);
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR);
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
+        this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, this.config.render.background.width, this.config.render.background.height, 0, this.gl.RGBA, this.gl.UNSIGNED_BYTE, background_data);
+        this.gl.bindTexture(this.gl.TEXTURE_2D, null);
+        const u_background = this.gl.getUniformLocation(this.program, 'u_background');
+        if (!u_background) {
+            throw new Error('[ladon-ts] - error finding "u_background" uniform');
+        }
+        this.gl.activeTexture(this.gl.TEXTURE2);
+        this.gl.bindTexture(this.gl.TEXTURE_2D, this.background_texture);
+        this.gl.uniform1i(u_background, 2);
+    }
+    render(input, mask) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.uploadVideoStream(input);
+            if (mask.warm) {
+                this.gl.activeTexture(this.gl.TEXTURE1);
+                this.gl.bindTexture(this.gl.TEXTURE_2D, this.mask_texture);
+                this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.R32F, this.config.input.width, this.config.input.height, 0, this.gl.RED, this.gl.FLOAT, mask.data);
+            }
+            if (!this.config.render.static) {
+                const background_data = this.background_canvas_ctx.getImageData(0, 0, this.config.render.background.width, this.config.render.background.height).data;
+                this.gl.activeTexture(this.gl.TEXTURE2);
+                this.gl.bindTexture(this.gl.TEXTURE_2D, this.background_texture);
+                this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, this.config.input.width, this.config.input.height, 0, this.gl.RGBA, this.gl.UNSIGNED_BYTE, background_data);
+            }
+            this.gl.useProgram(this.program);
+            this.gl.drawArrays(this.gl.TRIANGLES, 0, this.verts.length / 3);
+            this.postDraw();
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // empty
+        });
+    }
+    destroy() {
+        // empty
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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