@webex/ladon-ts 4.0.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+## [4.0.0](https://github.com/beyonddunbar/ladon-ts/compare/v2.8.0...v4.0.0) (2023-02-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* getConfig accepts model_url_resolver (#1)
+
+### Features
+
+* getConfig accepts model_url_resolver ([#1](https://github.com/beyonddunbar/ladon-ts/issues/1)) ([a2699d6](https://github.com/beyonddunbar/ladon-ts/commit/a2699d67bd4d3efd8b1261ec5379d83554b90b6f))

package/LICENSE

@@ -0,0 +1,5 @@
+* Coded instructions, statements, and computer programs are the
+* copyrighted works and confidential proprietary information of Cisco, Inc.
+* They may not be modified, copied, reproduced, distributed, or disclosed to
+* third parties in any manner, medium, or form, in whole or in part, without
+* the prior written consent of Cisco, Inc. 

package/README.md

@@ -0,0 +1,36 @@
+# Collaboration Video AI Client Library for Web
+
+## Description
+
+The Video AI Client Library for Web is designed for TypeScript client-application developers. It offers simple, flexible, and powerful APIs for video AI.
+
+## Features
+
+### ML Annotations
+
+- Person segmentation
+
+### Rendering Effects
+
+- Horizontal flip
+- Variable strength, high quality background blur
+- Static image background replacement
+- Dynamic video background replacement
+
+### Input/Output
+
+The library supports a HTML canvas input and output interface.
+
+
+# Documentation
+
+- [Getting Started](docs/START.md)
+- [Self-Hosting](docs/HOSTING.md)
+- [Content Security Policy](docs/CSP.md)
+- [Development](docs/DEVELOPMENT.md)
+
+## Links
+
+- [Live Example](https://models.intelligence.webex.com/ladon/3.0.2/example/index.html)
+- [Performance and Visual Tests](https://models.intelligence.webex.com/ladon/3.0.2/test/index.html)
+- [Typedocs](https://sqbu-github.cisco.com/pages/WebexIntelligence/ladon-ts/)

package/build/module/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/config';
+export * from './lib/generator';
+export * from './lib/pipeline';
+export * from './lib/renderer';
+export * from './lib/util';
+export * from './lib/version';

package/build/module/index.js

@@ -0,0 +1,7 @@
+export * from './lib/config';
+export * from './lib/generator';
+export * from './lib/pipeline';
+export * from './lib/renderer';
+export * from './lib/util';
+export * from './lib/version';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxlQUFlLENBQUMifQ==

package/build/module/lib/config.d.ts

@@ -0,0 +1,61 @@
+export declare type InputConfig = {
+    readonly height: number;
+    readonly width: number;
+};
+export declare type ModelUrlResolver = string | ((model_path: string) => Promise<string>);
+export interface RenderConfig {
+    readonly type: 'blur' | 'passthrough' | 'replacement';
+    readonly horizontal_mirror?: boolean;
+}
+export interface BlurConfig extends RenderConfig {
+    readonly type: 'blur';
+    readonly kernel_size: number;
+    readonly sigma: number;
+}
+export interface ReplacementConfig extends RenderConfig {
+    readonly type: 'replacement';
+    background: HTMLCanvasElement;
+    readonly static: boolean;
+}
+export declare type Generator = 'local' | 'worker';
+export declare type MaskConfig = {
+    readonly generator: Generator;
+    readonly generation_interval_ms: number;
+    readonly model_url_resolver: ModelUrlResolver;
+    readonly model_uri: string;
+    readonly worker_uri: string;
+};
+export declare type PipelineConfig = {
+    readonly base_url?: string;
+    readonly wasm_uri?: string;
+    readonly render: BlurConfig | RenderConfig | ReplacementConfig;
+    readonly input: InputConfig;
+    readonly mask: MaskConfig;
+};
+export declare enum Quality {
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    HIGH = "HIGH",
+    ULTRA = "ULTRA"
+}
+export declare enum BlurStrength {
+    WEAK = "WEAK",
+    MODERATE = "MODERATE",
+    STRONG = "STRONG",
+    STRONGER = "STRONGER",
+    STRONGEST = "STRONGEST"
+}
+export declare const getBlurConfig: (blur_strength: BlurStrength, horizontal_mirror?: boolean) => BlurConfig;
+export declare const getConfig: (height: number, width: number, quality?: Quality, generator?: Generator, render_config?: BlurConfig | RenderConfig | ReplacementConfig, model_url_resolver?: ModelUrlResolver, base_url?: string) => {
+    mask: {
+        generator: Generator;
+        generation_interval_ms: number;
+        model_url_resolver: ModelUrlResolver;
+        model_uri: string;
+        worker_uri: string;
+    };
+    base_url?: string | undefined;
+    wasm_uri?: string | undefined;
+    render: BlurConfig | RenderConfig | ReplacementConfig;
+    input: InputConfig;
+};

package/build/module/lib/config.js

@@ -0,0 +1,109 @@
+import { LIB_VERSION } from './version';
+export var Quality;
+(function (Quality) {
+    Quality["LOW"] = "LOW";
+    Quality["MEDIUM"] = "MEDIUM";
+    Quality["HIGH"] = "HIGH";
+    Quality["ULTRA"] = "ULTRA";
+})(Quality || (Quality = {}));
+export var BlurStrength;
+(function (BlurStrength) {
+    BlurStrength["WEAK"] = "WEAK";
+    BlurStrength["MODERATE"] = "MODERATE";
+    BlurStrength["STRONG"] = "STRONG";
+    BlurStrength["STRONGER"] = "STRONGER";
+    BlurStrength["STRONGEST"] = "STRONGEST";
+})(BlurStrength || (BlurStrength = {}));
+export const getBlurConfig = (blur_strength, horizontal_mirror) => {
+    let kernel_size = 25;
+    let sigma = 11;
+    switch (blur_strength) {
+        case BlurStrength.WEAK:
+            kernel_size = 9;
+            sigma = 2;
+            break;
+        case BlurStrength.MODERATE:
+            kernel_size = 15;
+            sigma = 6;
+            break;
+        case BlurStrength.STRONG:
+            kernel_size = 25;
+            sigma = 11;
+            break;
+        case BlurStrength.STRONGER:
+            kernel_size = 37;
+            sigma = 17;
+            break;
+        case BlurStrength.STRONGEST:
+            kernel_size = 49;
+            sigma = 23;
+            break;
+        default:
+            break;
+    }
+    return {
+        type: 'blur',
+        horizontal_mirror,
+        kernel_size,
+        sigma,
+    };
+};
+export const getConfig = (height, width, quality = Quality.LOW, generator = 'local', render_config = {
+    type: 'blur',
+    horizontal_mirror: false,
+    kernel_size: 37,
+    sigma: 17,
+}, model_url_resolver = (model_path) => {
+    return new Promise((resolve) => {
+        resolve(model_path);
+    });
+}, base_url = '') => {
+    const model_version = '1.0.0';
+    const base_config = {
+        base_url,
+        wasm_uri: '/wasm/1.13.1/',
+        render: render_config,
+        input: {
+            height,
+            width,
+        },
+        mask: {
+            generation_interval_ms: 48,
+            generator,
+            model_url_resolver,
+            model_uri: `/models/${model_version}/mv2_dlv3plus_dynamic_dev_plus_dual_op11_mn3sm100.onnx`,
+            worker_uri: `/${LIB_VERSION}/worker/segmentation.js`,
+        },
+    };
+    let mask_quality_config = {};
+    switch (quality) {
+        case Quality.LOW:
+            mask_quality_config = {
+                generation_interval_ms: 48,
+                model_uri: `/models/${model_version}/mv2_dlv3plus_dynamic_dev_plus_dual_op11_mn3sm100.onnx`,
+            };
+            break;
+        case Quality.MEDIUM:
+            mask_quality_config = {
+                generation_interval_ms: 24,
+                model_uri: `/models/${model_version}/mv2_dlv3plus_dynamic_dev_plus_dual_op11_mn3sm100.onnx`,
+            };
+            break;
+        case Quality.HIGH:
+            mask_quality_config = {
+                generation_interval_ms: 36,
+                model_uri: `/models/${model_version}/mv2_dlv3plus_dynamic_dev_plus_dual_op11_full_depth_2.onnx`,
+            };
+            break;
+        case Quality.ULTRA:
+            mask_quality_config = {
+                generation_interval_ms: 0,
+                model_uri: `/models/${model_version}/mv2_dlv3plus_dynamic_dev_plus_dual_op11_full_depth_2.onnx`,
+            };
+            break;
+        default:
+            throw new Error('[ladon-ts] - unknown quality option: ' + quality);
+    }
+    return Object.assign(Object.assign({}, base_config), { mask: Object.assign(Object.assign({}, base_config.mask), mask_quality_config) });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/lib/generator.d.ts

@@ -0,0 +1,52 @@
+import { PipelineConfig } from './config';
+declare global {
+    interface ImportMeta {
+        url: string;
+    }
+}
+export interface MaskResult {
+    data: Float32Array;
+    warm: boolean;
+}
+export interface MaskGenerator {
+    getMask(input: Uint8ClampedArray): Promise<MaskResult>;
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    postRender(input: Uint8ClampedArray): Promise<void>;
+    destroy(): void;
+}
+export declare class LocalGenerator implements MaskGenerator {
+    readonly config: PipelineConfig;
+    private last_mask;
+    private mask_model?;
+    private last_mask_generation;
+    constructor(config: PipelineConfig);
+    private preprocess;
+    getMask(input: Uint8ClampedArray): Promise<MaskResult>;
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    postRender(_: Uint8ClampedArray): Promise<void>;
+    destroy(): void;
+}
+export declare class NullGenerator implements MaskGenerator {
+    readonly config: PipelineConfig;
+    private last_mask;
+    constructor(config: PipelineConfig);
+    getMask(_: Uint8ClampedArray): Promise<MaskResult>;
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    postRender(_: Uint8ClampedArray): Promise<void>;
+    destroy(): void;
+}
+export declare class WorkerGenerator implements MaskGenerator {
+    readonly config: PipelineConfig;
+    private last_mask;
+    private worker?;
+    private new_mask;
+    constructor(config: PipelineConfig);
+    getMask(_: Uint8ClampedArray): Promise<MaskResult>;
+    load(): Promise<void>;
+    isLoaded(): boolean;
+    postRender(input: Uint8ClampedArray): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/generator.js

@@ -0,0 +1,202 @@
+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 * as ort from 'onnxruntime-web';
+import { toAbsoluteURI } from './util';
+export class LocalGenerator {
+    constructor(config) {
+        this.config = config;
+        this.last_mask_generation = 0;
+        this.last_mask = new ort.Tensor('float32', new Float32Array(this.config.input.height * this.config.input.width), [1, 1, this.config.input.height, this.config.input.width]);
+    }
+    preprocess(input) {
+        const output = new Float32Array(this.config.input.width * this.config.input.height * 3);
+        for (let channel = 0; channel < 3; channel++) {
+            for (let pixel = 0; pixel < input.length / 4; pixel++) {
+                output[pixel +
+                    channel *
+                        this.config.input.width *
+                        this.config.input.height] = input[pixel * 4 + channel];
+            }
+        }
+        return output;
+    }
+    getMask(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.mask_model) {
+                throw new Error('[ladon-ts] - mask model not loaded.');
+            }
+            const mask_generation_timeout = Date.now() - this.last_mask_generation >
+                this.config.mask.generation_interval_ms;
+            if (!mask_generation_timeout) {
+                return {
+                    data: this.last_mask.data,
+                    warm: false,
+                };
+            }
+            this.last_mask_generation = Date.now();
+            const image_tns = new ort.Tensor('float32', this.preprocess(input), [
+                1,
+                3,
+                this.config.input.height,
+                this.config.input.width,
+            ]);
+            const feeds = {
+                input_image: image_tns,
+                prev_mask: this.last_mask,
+            };
+            const results = yield this.mask_model.run(feeds);
+            this.last_mask = results['output_mask'];
+            return {
+                data: this.last_mask.data,
+                warm: true,
+            };
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.wasm_uri) {
+                ort.env.wasm.wasmPaths = toAbsoluteURI(this.config.wasm_uri, this.config.base_url);
+            }
+            ort.env.wasm.numThreads = 1;
+            let model_url;
+            if (typeof this.config.mask.model_url_resolver === 'string') {
+                model_url = this.config.mask.model_url_resolver;
+            }
+            else {
+                model_url = yield this.config.mask.model_url_resolver(this.config.mask.model_uri);
+            }
+            this.mask_model = yield ort.InferenceSession.create(model_url, {
+                executionProviders: ['wasm'],
+            });
+        });
+    }
+    isLoaded() {
+        return !!this.mask_model;
+    }
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    postRender(_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // empty for local generator
+        });
+    }
+    destroy() {
+        // empty for local generator
+    }
+}
+export class NullGenerator {
+    constructor(config) {
+        this.config = config;
+        this.last_mask = new Float32Array(this.config.input.height * this.config.input.width);
+    }
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    getMask(_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                data: this.last_mask,
+                warm: false,
+            };
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // empty for null generator
+        });
+    }
+    isLoaded() {
+        return true;
+    }
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    postRender(_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // empty for null generator
+        });
+    }
+    destroy() {
+        // empty for null generator
+    }
+}
+export class WorkerGenerator {
+    constructor(config) {
+        this.config = config;
+        this.new_mask = true;
+        this.last_mask = new Float32Array(this.config.input.height * this.config.input.width);
+    }
+    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+    getMask(_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const toReturn = {
+                data: this.last_mask,
+                warm: this.new_mask,
+            };
+            this.new_mask = false;
+            return toReturn;
+        });
+    }
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cross_origin_script_url = toAbsoluteURI(this.config.mask.worker_uri, this.config.base_url);
+            const content = yield (yield fetch(cross_origin_script_url, { cache: 'force-cache' })).text();
+            const worker_url = URL.createObjectURL(new Blob([content], { type: 'text/javascript' }));
+            this.worker = new Worker(worker_url, { type: 'module' });
+            let model_url;
+            if (typeof this.config.mask.model_url_resolver === 'string') {
+                model_url = this.config.mask.model_url_resolver;
+            }
+            else {
+                model_url = yield this.config.mask.model_url_resolver(this.config.mask.model_uri);
+            }
+            const worker_config = {
+                base_url: this.config.base_url,
+                input: this.config.input,
+                mask: Object.assign(Object.assign({}, this.config.mask), { model_url_resolver: model_url }),
+                wasm_uri: this.config.wasm_uri,
+                render: { type: 'passthrough' },
+            };
+            this.worker.postMessage(worker_config);
+            let resolution_cb;
+            /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
+            const result = new Promise((resolve, _) => {
+                resolution_cb = resolve;
+            });
+            this.worker.onmessage = (event) => {
+                if (event.data.mask) {
+                    this.last_mask = event.data.mask;
+                    this.new_mask = true;
+                }
+                else {
+                    URL.revokeObjectURL(worker_url);
+                    if (resolution_cb) {
+                        resolution_cb();
+                    }
+                }
+            };
+            return result;
+        });
+    }
+    isLoaded() {
+        return !!this.worker;
+    }
+    postRender(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // claim ownership of the input tensor's buffer and forward to worker
+            if (!this.worker) {
+                throw new Error('[ladon-ts] - worker is not defined.');
+            }
+            this.worker.postMessage({
+                image: input,
+            }, [input.buffer]);
+        });
+    }
+    destroy() {
+        var _a;
+        (_a = this.worker) === null || _a === void 0 ? void 0 : _a.terminate();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2VuZXJhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9nZW5lcmF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7O0FBQUEsT0FBTyxLQUFLLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQztBQUd2QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBcUJ2QyxNQUFNLE9BQU8sY0FBYztJQUt2QixZQUE0QixNQUFzQjtRQUF0QixXQUFNLEdBQU4sTUFBTSxDQUFnQjtRQUYxQyx5QkFBb0IsR0FBRyxDQUFDLENBQUM7UUFHN0IsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQzNCLFNBQVMsRUFDVCxJQUFJLFlBQVksQ0FDWixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUNyRCxFQUNELENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQzVELENBQUM7SUFDTixDQUFDO0lBRU8sVUFBVSxDQUFDLEtBQXdCO1FBQ3ZDLE1BQU0sTUFBTSxHQUFHLElBQUksWUFBWSxDQUMzQixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FDekQsQ0FBQztRQUVGLEtBQUssSUFBSSxPQUFPLEdBQUcsQ0FBQyxFQUFFLE9BQU8sR0FBRyxDQUFDLEVBQUUsT0FBTyxFQUFFLEVBQUU7WUFDMUMsS0FBSyxJQUFJLEtBQUssR0FBRyxDQUFDLEVBQUUsS0FBSyxHQUFHLEtBQUssQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFO2dCQUNuRCxNQUFNLENBQ0YsS0FBSztvQkFDRCxPQUFPO3dCQUNILElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUs7d0JBQ3ZCLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FDbkMsR0FBRyxLQUFLLENBQUMsS0FBSyxHQUFHLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQzthQUNsQztTQUNKO1FBRUQsT0FBTyxNQUFNLENBQUM7SUFDbEIsQ0FBQztJQUVZLE9BQU8sQ0FBQyxLQUF3Qjs7WUFDekMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUU7Z0JBQ2xCLE1BQU0sSUFBSSxLQUFLLENBQUMscUNBQXFDLENBQUMsQ0FBQzthQUMxRDtZQUVELE1BQU0sdUJBQXVCLEdBQ3pCLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsb0JBQW9CO2dCQUN0QyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxzQkFBc0IsQ0FBQztZQUM1QyxJQUFJLENBQUMsdUJBQXVCLEVBQUU7Z0JBQzFCLE9BQU87b0JBQ0gsSUFBSSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSTtvQkFDekIsSUFBSSxFQUFFLEtBQUs7aUJBQ2QsQ0FBQzthQUNMO1lBRUQsSUFBSSxDQUFDLG9CQUFvQixHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUV2QyxNQUFNLFNBQVMsR0FBRyxJQUFJLEdBQUcsQ0FBQyxNQUFNLENBQUMsU0FBUyxFQUFFLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFDLEVBQUU7Z0JBQ2hFLENBQUM7Z0JBQ0QsQ0FBQztnQkFDRCxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNO2dCQUN4QixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLO2FBQzFCLENBQUMsQ0FBQztZQUVILE1BQU0sS0FBSyxHQUFHO2dCQUNWLFdBQVcsRUFBRSxTQUFTO2dCQUN0QixTQUFTLEVBQUUsSUFBSSxDQUFDLFNBQVM7YUFDNUIsQ0FBQztZQUVGLE1BQU0sT0FBTyxHQUFHLE1BQU0sSUFBSSxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDakQsSUFBSSxDQUFDLFNBQVMsR0FBRyxPQUFPLENBQUMsYUFBYSxDQUFDLENBQUM7WUFFeEMsT0FBTztnQkFDSCxJQUFJLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJO2dCQUN6QixJQUFJLEVBQUUsSUFBSTthQUNiLENBQUM7UUFDTixDQUFDO0tBQUE7SUFFWSxJQUFJOztZQUNiLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUU7Z0JBQ3RCLEdBQUcsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLFNBQVMsR0FBRyxhQUFhLENBQ2xDLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxFQUNwQixJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FDdkIsQ0FBQzthQUNMO1lBRUQsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsQ0FBQztZQUU1QixJQUFJLFNBQWlCLENBQUM7WUFDdEIsSUFBSSxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLGtCQUFrQixLQUFLLFFBQVEsRUFBRTtnQkFDekQsU0FBUyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDO2FBQ25EO2lCQUFNO2dCQUNILFNBQVMsR0FBRyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUNqRCxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQzdCLENBQUM7YUFDTDtZQUVELElBQUksQ0FBQyxVQUFVLEdBQUcsTUFBTSxHQUFHLENBQUMsZ0JBQWdCLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRTtnQkFDM0Qsa0JBQWtCLEVBQUUsQ0FBQyxNQUFNLENBQUM7YUFDL0IsQ0FBQyxDQUFDO1FBQ1AsQ0FBQztLQUFBO0lBRU0sUUFBUTtRQUNYLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUM7SUFDN0IsQ0FBQztJQUVELGdFQUFnRTtJQUNuRCxVQUFVLENBQUMsQ0FBb0I7O1lBQ3hDLDRCQUE0QjtRQUNoQyxDQUFDO0tBQUE7SUFFTSxPQUFPO1FBQ1YsNEJBQTRCO0lBQ2hDLENBQUM7Q0FDSjtBQUVELE1BQU0sT0FBTyxhQUFhO0lBR3RCLFlBQTRCLE1BQXNCO1FBQXRCLFdBQU0sR0FBTixNQUFNLENBQWdCO1FBQzlDLElBQUksQ0FBQyxTQUFTLEdBQUcsSUFBSSxZQUFZLENBQzdCLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQ3JELENBQUM7SUFDTixDQUFDO0lBRUQsZ0VBQWdFO0lBQ25ELE9BQU8sQ0FBQyxDQUFvQjs7WUFDckMsT0FBTztnQkFDSCxJQUFJLEVBQUUsSUFBSSxDQUFDLFNBQVM7Z0JBQ3BCLElBQUksRUFBRSxLQUFLO2FBQ2QsQ0FBQztRQUNOLENBQUM7S0FBQTtJQUVZLElBQUk7O1lBQ2IsMkJBQTJCO1FBQy9CLENBQUM7S0FBQTtJQUVNLFFBQVE7UUFDWCxPQUFPLElBQUksQ0FBQztJQUNoQixDQUFDO0lBRUQsZ0VBQWdFO0lBQ25ELFVBQVUsQ0FBQyxDQUFvQjs7WUFDeEMsMkJBQTJCO1FBQy9CLENBQUM7S0FBQTtJQUVNLE9BQU87UUFDViwyQkFBMkI7SUFDL0IsQ0FBQztDQUNKO0FBRUQsTUFBTSxPQUFPLGVBQWU7SUFNeEIsWUFBNEIsTUFBc0I7UUFBdEIsV0FBTSxHQUFOLE1BQU0sQ0FBZ0I7UUFGMUMsYUFBUSxHQUFHLElBQUksQ0FBQztRQUdwQixJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksWUFBWSxDQUM3QixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUNyRCxDQUFDO0lBQ04sQ0FBQztJQUVELGdFQUFnRTtJQUNuRCxPQUFPLENBQUMsQ0FBb0I7O1lBQ3JDLE1BQU0sUUFBUSxHQUFHO2dCQUNiLElBQUksRUFBRSxJQUFJLENBQUMsU0FBUztnQkFDcEIsSUFBSSxFQUFFLElBQUksQ0FBQyxRQUFRO2FBQ3RCLENBQUM7WUFFRixJQUFJLENBQUMsUUFBUSxHQUFHLEtBQUssQ0FBQztZQUV0QixPQUFPLFFBQVEsQ0FBQztRQUNwQixDQUFDO0tBQUE7SUFFWSxJQUFJOztZQUNiLE1BQU0sdUJBQXVCLEdBQUcsYUFBYSxDQUN6QyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQzNCLElBQUksQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUN2QixDQUFDO1lBRUYsTUFBTSxPQUFPLEdBQUcsTUFBTSxDQUNsQixNQUFNLEtBQUssQ0FBQyx1QkFBdUIsRUFBRSxFQUFFLEtBQUssRUFBRSxhQUFhLEVBQUUsQ0FBQyxDQUNqRSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ1QsTUFBTSxVQUFVLEdBQUcsR0FBRyxDQUFDLGVBQWUsQ0FDbEMsSUFBSSxJQUFJLENBQUMsQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLElBQUksRUFBRSxpQkFBaUIsRUFBRSxDQUFDLENBQ25ELENBQUM7WUFFRixJQUFJLENBQUMsTUFBTSxHQUFHLElBQUksTUFBTSxDQUFDLFVBQVUsRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsQ0FBQyxDQUFDO1lBRXpELElBQUksU0FBaUIsQ0FBQztZQUN0QixJQUFJLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsa0JBQWtCLEtBQUssUUFBUSxFQUFFO2dCQUN6RCxTQUFTLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQUM7YUFDbkQ7aUJBQU07Z0JBQ0gsU0FBUyxHQUFHLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsa0JBQWtCLENBQ2pELElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FDN0IsQ0FBQzthQUNMO1lBRUQsTUFBTSxhQUFhLEdBQW1CO2dCQUNsQyxRQUFRLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRO2dCQUM5QixLQUFLLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxLQUFLO2dCQUN4QixJQUFJLGtDQUNHLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxLQUNuQixrQkFBa0IsRUFBRSxTQUFTLEdBQ2hDO2dCQUNELFFBQVEsRUFBRSxJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVE7Z0JBQzlCLE1BQU0sRUFBRSxFQUFFLElBQUksRUFBRSxhQUFhLEVBQUU7YUFDbEMsQ0FBQztZQUVGLElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1lBRXZDLElBQUksYUFBeUIsQ0FBQztZQUM5QixnRUFBZ0U7WUFDaEUsTUFBTSxNQUFNLEdBQUcsSUFBSSxPQUFPLENBQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxFQUFFLEVBQUU7Z0JBQzVDLGFBQWEsR0FBRyxPQUFPLENBQUM7WUFDNUIsQ0FBQyxDQUFDLENBQUM7WUFFSCxJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsR0FBRyxDQUFDLEtBQUssRUFBRSxFQUFFO2dCQUM5QixJQUFJLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFO29CQUNqQixJQUFJLENBQUMsU0FBUyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDO29CQUNqQyxJQUFJLENBQUMsUUFBUSxHQUFHLElBQUksQ0FBQztpQkFDeEI7cUJBQU07b0JBQ0gsR0FBRyxDQUFDLGVBQWUsQ0FBQyxVQUFVLENBQUMsQ0FBQztvQkFFaEMsSUFBSSxhQUFhLEVBQUU7d0JBQ2YsYUFBYSxFQUFFLENBQUM7cUJBQ25CO2lCQUNKO1lBQ0wsQ0FBQyxDQUFDO1lBRUYsT0FBTyxNQUFNLENBQUM7UUFDbEIsQ0FBQztLQUFBO0lBRU0sUUFBUTtRQUNYLE9BQU8sQ0FBQyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDekIsQ0FBQztJQUVZLFVBQVUsQ0FBQyxLQUF3Qjs7WUFDNUMscUVBQXFFO1lBRXJFLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFO2dCQUNkLE1BQU0sSUFBSSxLQUFLLENBQUMscUNBQXFDLENBQUMsQ0FBQzthQUMxRDtZQUVELElBQUksQ0FBQyxNQUFNLENBQUMsV0FBVyxDQUNuQjtnQkFDSSxLQUFLLEVBQUUsS0FBSzthQUNmLEVBQ0QsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQ2pCLENBQUM7UUFDTixDQUFDO0tBQUE7SUFFTSxPQUFPOztRQUNWLE1BQUEsSUFBSSxDQUFDLE1BQU0sMENBQUUsU0FBUyxFQUFFLENBQUM7SUFDN0IsQ0FBQztDQUNKIn0=

package/build/module/lib/pipeline.d.ts

@@ -0,0 +1,21 @@
+import { PipelineConfig } from './config';
+export interface IPipeline {
+    onFrame(): Promise<void>;
+    isLoaded(): boolean;
+    load(): Promise<void>;
+    destroy(): void;
+}
+export declare class Pipeline implements IPipeline {
+    private input_canvas;
+    private output_canvas;
+    readonly config: PipelineConfig;
+    private generator?;
+    private renderer?;
+    private loaded;
+    private input_ctx;
+    constructor(input_canvas: HTMLCanvasElement, output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    onFrame(): Promise<void>;
+    isLoaded(): boolean;
+    load(): Promise<void>;
+    destroy(): void;
+}

package/build/module/lib/pipeline.js

@@ -0,0 +1,83 @@
+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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

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

@@ -0,0 +1,63 @@
+import { PipelineConfig } from './config';
+import { MaskResult } from './generator';
+export interface LadonRenderer {
+    render(input: Uint8ClampedArray, mask: MaskResult): Promise<void>;
+    load(): Promise<void>;
+    destroy(): void;
+}
+declare abstract class WebGLRenderer {
+    output_canvas: HTMLCanvasElement;
+    readonly config: PipelineConfig;
+    protected intermediate_canvas?: HTMLCanvasElement;
+    protected output_canvas_2d?: CanvasRenderingContext2D;
+    protected gl: WebGL2RenderingContext;
+    protected image_texture: WebGLTexture;
+    protected mask_texture: WebGLTexture;
+    protected verts: Float32Array;
+    protected vertex_shader_src: string;
+    constructor(output_canvas: HTMLCanvasElement, config: PipelineConfig);
+    protected getUVCalculation(): "vec2 st = -(gl_FragCoord.xy / u_resolution) + 1.0;" | "vec2 st = vec2((gl_FragCoord.x / u_resolution.x), -(gl_FragCoord.y / u_resolution.y) + 1.0);";
+    protected setSharedUniforms(program: WebGLProgram): void;
+    protected uploadVideoStream(input: Uint8ClampedArray): void;
+    protected postDraw(): void;
+}
+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;
+}
+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;
+}
+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;
+}
+export {};

package/build/module/lib/renderer.js

@@ -0,0 +1,463 @@
+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());
+    });
+};
+class WebGLRenderer {
+    constructor(output_canvas, config) {
+        this.output_canvas = output_canvas;
+        this.config = config;
+        this.verts = new Float32Array([
+            -1.0, -1.0, 0.0, -1.0, 1.0, 0.0, 1.0, 1.0, 0.0,
+            1.0, 1.0, 0.0, 1.0, -1.0, 0.0, -1.0, -1.0, 0.0,
+        ]);
+        this.vertex_shader_src = `#version 300 es
+
+in vec4 position;
+
+void main() {
+    gl_Position = position;
+}
+`;
+        const gl = this.output_canvas.getContext('webgl2');
+        if (!gl) {
+            const output_2d = this.output_canvas.getContext('2d');
+            if (!output_2d) {
+                throw new Error('[ladon-ts] - output canvas context must be webgl2 or 2d');
+            }
+            this.output_canvas_2d = output_2d;
+            this.intermediate_canvas = document.createElement('canvas');
+            this.intermediate_canvas.height = this.config.input.height;
+            this.intermediate_canvas.width = this.config.input.width;
+            const gl_intermediate = this.intermediate_canvas.getContext('webgl2');
+            if (!gl_intermediate) {
+                throw new Error('[ladon-ts] - error getting output context webgl');
+            }
+            this.gl = gl_intermediate;
+        }
+        else {
+            this.gl = gl;
+        }
+        const image_texture = this.gl.createTexture();
+        if (!image_texture) {
+            throw new Error('[ladon-ts] - error creating input texture');
+        }
+        this.image_texture = image_texture;
+        this.gl.bindTexture(this.gl.TEXTURE_2D, this.image_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.bindTexture(this.gl.TEXTURE_2D, null);
+        const mask_texture = this.gl.createTexture();
+        if (!mask_texture) {
+            throw new Error('[ladon-ts] - error creating mask texture');
+        }
+        this.mask_texture = mask_texture;
+        this.gl.bindTexture(this.gl.TEXTURE_2D, this.mask_texture);
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.NEAREST);
+        this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.NEAREST);
+        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.R32F, this.config.input.width, this.config.input.height, 0, this.gl.RED, this.gl.FLOAT, null);
+        this.gl.bindTexture(this.gl.TEXTURE_2D, null);
+        const vertex_array = this.gl.createVertexArray();
+        if (!vertex_array) {
+            throw new Error('[ladon-ts] - error creating vertex array');
+        }
+        this.gl.bindVertexArray(vertex_array);
+        const buffer = this.gl.createBuffer();
+        if (!buffer) {
+            throw new Error('[ladon-ts] - error creating buffer');
+        }
+        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, buffer);
+        this.gl.bufferData(this.gl.ARRAY_BUFFER, this.verts, this.gl.STATIC_DRAW);
+        this.gl.vertexAttribPointer(0, 3, this.gl.FLOAT, false, 0, 0);
+        this.gl.enableVertexAttribArray(0);
+        this.gl.viewport(0, 0, this.config.input.width, this.config.input.height);
+    }
+    getUVCalculation() {
+        if (this.config.render.horizontal_mirror) {
+            return `vec2 st = -(gl_FragCoord.xy / u_resolution) + 1.0;`;
+        }
+        return `vec2 st = vec2((gl_FragCoord.x / u_resolution.x), -(gl_FragCoord.y / u_resolution.y) + 1.0);`;
+    }
+    setSharedUniforms(program) {
+        const u_resolution = this.gl.getUniformLocation(program, 'u_resolution');
+        if (!u_resolution) {
+            throw new Error('[ladon-ts] - error finding "u_resolution" uniform');
+        }
+        this.gl.uniform2f(u_resolution, this.config.input.width, this.config.input.height);
+        const u_image = this.gl.getUniformLocation(program, 'u_image');
+        if (!u_image) {
+            throw new Error('[ladon-ts] - error finding "u_image" uniform');
+        }
+        this.gl.activeTexture(this.gl.TEXTURE0);
+        this.gl.bindTexture(this.gl.TEXTURE_2D, this.image_texture);
+        this.gl.uniform1i(u_image, 0);
+        const u_mask = this.gl.getUniformLocation(program, 'u_mask');
+        if (u_mask) {
+            this.gl.activeTexture(this.gl.TEXTURE1);
+            this.gl.bindTexture(this.gl.TEXTURE_2D, this.mask_texture);
+            this.gl.uniform1i(u_mask, 1);
+        }
+    }
+    uploadVideoStream(input) {
+        this.gl.activeTexture(this.gl.TEXTURE0);
+        this.gl.bindTexture(this.gl.TEXTURE_2D, this.image_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, input);
+    }
+    postDraw() {
+        if (this.output_canvas_2d && this.intermediate_canvas) {
+            this.output_canvas_2d.drawImage(this.intermediate_canvas, 0, 0, this.config.input.width, this.config.input.height);
+        }
+    }
+}
+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
+    }
+}
+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
+    }
+}
+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.input.width, this.config.input.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);
+    }
+}
+function compileShader(gl, shader_type, source) {
+    var _a;
+    const shader = gl.createShader(shader_type);
+    if (!shader) {
+        throw new Error('[ladon-ts] - error creating shader');
+    }
+    gl.shaderSource(shader, source);
+    gl.compileShader(shader);
+    if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+        const error = (_a = gl.getShaderInfoLog(shader)) !== null && _a !== void 0 ? _a : 'unknown error compiling shader.';
+        throw new Error('[ladon-ts] - ' + error);
+    }
+    return shader;
+}
+function linkProgram(gl, vertex_shader, fragment_shader) {
+    var _a;
+    const program = gl.createProgram();
+    if (!program) {
+        throw new Error('[ladon-ts] - error creating GPU program');
+    }
+    gl.attachShader(program, vertex_shader);
+    gl.attachShader(program, fragment_shader);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+        const error = (_a = gl.getProgramInfoLog(program)) !== null && _a !== void 0 ? _a : 'unknown error linking program.';
+        throw new Error('[ladon-ts] - ' + error);
+    }
+    return program;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../../../src/lib/renderer.ts"],"names":[],"mappings":"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"}

package/build/module/lib/util.d.ts

@@ -0,0 +1 @@
+export declare const toAbsoluteURI: (relativeURL: string, baseURL?: string) => string;

package/build/module/lib/util.js

@@ -0,0 +1,10 @@
+export const toAbsoluteURI = (relativeURL, baseURL) => {
+    // adapted from - https://github.com/axios/axios/blob/fe7d09bb08fa1c0e414956b7fc760c80459b0a43/lib/helpers/combineURLs.js
+    if (!baseURL || relativeURL.startsWith('http')) {
+        return new URL(relativeURL).href;
+    }
+    return relativeURL
+        ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+        : baseURL;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvdXRpbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsQ0FBQyxXQUFtQixFQUFFLE9BQWdCLEVBQUUsRUFBRTtJQUNuRSx5SEFBeUg7SUFFekgsSUFBSSxDQUFDLE9BQU8sSUFBSSxXQUFXLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxFQUFFO1FBQzVDLE9BQU8sSUFBSSxHQUFHLENBQUMsV0FBVyxDQUFDLENBQUMsSUFBSSxDQUFDO0tBQ3BDO0lBRUQsT0FBTyxXQUFXO1FBQ2QsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxHQUFHLEdBQUcsR0FBRyxXQUFXLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUM7UUFDckUsQ0FBQyxDQUFDLE9BQU8sQ0FBQztBQUNsQixDQUFDLENBQUMifQ==

package/build/module/lib/version.d.ts

@@ -0,0 +1 @@
+export declare const LIB_VERSION = "4.0.0";

package/build/module/lib/version.js

@@ -0,0 +1,2 @@
+export const LIB_VERSION = '4.0.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQUcsT0FBTyxDQUFDIn0=

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@webex/ladon-ts",
+  "version": "4.0.0",
+  "description": "WebexIntelligence computer vision library",
+  "type": "module",
+  "main": "build/module/worker/segmentation.js",
+  "typings": "build/module/index.d.ts",
+  "module": "build/module/index.js",
+  "keywords": [],
+  "license": "SEE LICENSE in LICENSE",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "update-version": "node -p \"'export const LIB_VERSION = ' + JSON.stringify(require('./package.json').version).replaceAll('\\\"', '\\'') + ';'\" > src/lib/version.ts",
+    "build": "run-s build:*",
+    "build:module": "tsc -p tsconfig.module.json",
+    "build:worker": "npm --prefix ./worker run build",
+    "build:test": "npm --prefix ./test run build",
+    "fix": "run-s fix:*",
+    "fix:prettier": "prettier \"src/**/*.ts\" --write",
+    "fix:lint": "eslint src --ext .ts --fix",
+    "test": "run-s build test:*",
+    "test:lint": "eslint src --ext .ts",
+    "test:prettier": "prettier \"src/**/*.ts\" --list-different",
+    "check-cli": "run-s test diff-integration-tests check-integration-tests",
+    "check-integration-tests": "run-s check-integration-test:*",
+    "diff-integration-tests": "mkdir -p diff && rm -rf diff/test && cp -r test diff/test && rm -rf diff/test/test-*/.git && cd diff && git init --quiet && git add -A && git commit --quiet --no-verify --allow-empty -m 'WIP' && echo '\\n\\nCommitted most recent integration test output in the \"diff\" directory. Review the changes with \"cd diff && git diff HEAD\" or your preferred git diff viewer.'",
+    "watch:build": "tsc -p tsconfig.module.json -w",
+    "doc": "run-s doc:html && open-cli build/docs/index.html",
+    "doc:html": "typedoc src/ --exclude **/*.spec.ts --out build/docs",
+    "doc:json": "typedoc src/ --exclude **/*.spec.ts --json build/docs/typedoc.json",
+    "doc:publish": "gh-pages -m \"[ci skip] Updates\" -d build/docs",
+    "version": "standard-version",
+    "test-release": "run-s test build doc:html",
+    "prepare-release": "run-s test version update-version build doc:html doc:publish"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.0",
+    "@types/mocha": "^9.0.0",
+    "@typescript-eslint/eslint-plugin": "^4.0.1",
+    "@typescript-eslint/parser": "^4.0.1",
+    "chai": "^4.3.4",
+    "cz-conventional-changelog": "^3.3.0",
+    "eslint": "^7.8.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-eslint-comments": "^3.2.0",
+    "eslint-plugin-functional": "^3.0.2",
+    "eslint-plugin-import": "^2.22.0",
+    "gh-pages": "^3.1.0",
+    "mocha": "^9.1.3",
+    "npm-run-all": "^4.1.5",
+    "open-cli": "^6.0.1",
+    "parcel": "^2.8.3",
+    "prettier": "^2.1.1",
+    "standard-version": "^9.0.0",
+    "typedoc": "^0.23.24",
+    "typescript": "^4.7.4"
+  },
+  "files": [
+    "build/main",
+    "build/module",
+    "!**/*.spec.*",
+    "!**/*.json",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "config": {
+    "commitizen": {
+      "path": "cz-conventional-changelog"
+    }
+  },
+  "prettier": {
+    "singleQuote": true
+  },
+  "dependencies": {
+    "onnxruntime-web": "^1.13.1"
+  }
+}