@webex/ladon-ts 5.4.5 → 5.5.0

package/build/worker/segmentation.js.map

@@ -1 +1 @@
-{"version":3,"file":"segmentation.js","sources":["../src/shim.ts","../src/console-overrides.ts","../../build/module/lib/util.js","../../build/module/lib/shared-resource-manager.js","../../build/module/lib/generator.js","../src/segmentation.ts"],"sourcesContent":["/**\n * This file is used to provide a shim for the document object in a web worker.\n * The document object is not available in a web worker, so we need to provide a shim\n * to prevent errors when running the code in a web worker.\n * \n * See: https://github.com/vitejs/vite/issues/9879#issuecomment-1372112651\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n(self.document as any)  = {\n    baseURI: location.origin\n};","/**\n * Override console methods to send logs to the main thread for display in the UI.\n */\n\nconst originalConsoleLog = console.log;\nconst originalConsoleWarn = console.warn;\nconst originalConsoleError = console.error;\n\nconsole.log = (...args) => {\n    postMessage({ type: 'log', message: args.join(' '), severity: 'log' });\n    originalConsoleLog(...args);\n};\n\nconsole.warn = (...args) => {\n    postMessage({ type: 'log', message: args.join(' '), severity: 'warn' });\n    originalConsoleWarn(...args);\n};\n\nconsole.error = (...args) => {\n    postMessage({ type: 'log', message: args.join(' '), severity: 'error' });\n    originalConsoleError(...args);\n};","var C = /* @__PURE__ */ ((o) => (o.Nearest = \"nearest\", o))(C || {});\nconst E = (o, r, s, n, t) => {\n  const a = new Uint8ClampedArray(n * t * 4), m = r / n, M = s / t, i = r * 4;\n  let c = 0;\n  for (let e = 0; e < t; e++) {\n    const l = Math.floor(e * M) * i;\n    for (let f = 0; f < n; f++) {\n      const u = l + Math.floor(f * m) * 4;\n      a[c++] = o[u], a[c++] = o[u + 1], a[c++] = o[u + 2], a[c++] = o[u + 3];\n    }\n  }\n  return a;\n};\nfunction I(o, r, s, n, t) {\n  const a = new Uint8ClampedArray(n * t);\n  if (r === n && s === t) {\n    for (let i = 0; i < o.length; i++)\n      a[i] = Math.min(Math.max(o[i], 0), 255);\n    return a;\n  }\n  const m = (r - 1) / (n - 1), M = (s - 1) / (t - 1);\n  for (let i = 0; i < t; i++)\n    for (let c = 0; c < n; c++) {\n      const e = m * c, l = M * i, f = Math.floor(e), u = Math.floor(l), d = Math.min(Math.ceil(e), r - 1), S = Math.min(Math.ceil(l), s - 1), y = e - f, h = l - u, p = o[u * r + f], w = o[u * r + d], P = o[S * r + f], x = o[S * r + d], k = p * (1 - y) * (1 - h) + w * y * (1 - h) + P * (1 - y) * h + x * y * h;\n      a[i * n + c] = Math.min(Math.max(k, 0), 255);\n    }\n  return a;\n}\nfunction R(o, r, s, n, t) {\n  const a = new Uint8ClampedArray(n * t), m = r / n, M = s / t, i = (e, l) => {\n    if (e === 0) return 1;\n    if (e < 0 && (e = -e), e < l) {\n      const f = Math.PI * e;\n      return l * Math.sin(f) * Math.sin(f / l) / (f * f);\n    }\n    return 0;\n  }, c = 3;\n  for (let e = 0; e < t; e++)\n    for (let l = 0; l < n; l++) {\n      const f = l * m, u = e * M, d = Math.floor(f), S = Math.floor(u);\n      let y = 0, h = 0;\n      for (let p = S - c + 1; p <= S + c; p++)\n        for (let w = d - c + 1; w <= d + c; w++)\n          if (w >= 0 && w < r && p >= 0 && p < s) {\n            const P = o[p * r + w], x = i(f - w, c) * i(u - p, c);\n            y += P * x, h += x;\n          }\n      a[e * n + l] = h !== 0 ? Math.round(y / h) : 0;\n    }\n  return a;\n}\nconst A = (o, r) => !r || o.startsWith(\"http\") ? new URL(o).href : o ? r.replace(/\\/+$/, \"\") + \"/\" + o.replace(/^\\/+/, \"\") : r;\nfunction L(o, r, s) {\n  const n = o.createShader(r);\n  if (!n)\n    throw new Error(\"[ladon-ts] - error creating shader\");\n  if (o.shaderSource(n, s), o.compileShader(n), !o.getShaderParameter(n, o.COMPILE_STATUS)) {\n    const t = o.getShaderInfoLog(n) ?? \"unknown error compiling shader.\";\n    throw new Error(\"[ladon-ts] - \" + t);\n  }\n  return n;\n}\nfunction T(o, r, s) {\n  const n = o.createProgram();\n  if (!n)\n    throw new Error(\"[ladon-ts] - error creating GPU program\");\n  if (o.attachShader(n, r), o.attachShader(n, s), o.linkProgram(n), !o.getProgramParameter(n, o.LINK_STATUS)) {\n    const t = o.getProgramInfoLog(n) ?? \"unknown error linking program.\";\n    throw new Error(\"[ladon-ts] - \" + t);\n  }\n  return n;\n}\nfunction b(o) {\n  if (o.startsWith(\"blob:\"))\n    return !0;\n  try {\n    return new URL(o), !0;\n  } catch {\n    return !1;\n  }\n}\nasync function U(o) {\n  const r = await caches.open(\"ladon-cache\"), s = await r.match(o);\n  if (s)\n    return s.arrayBuffer();\n  const n = await fetch(o);\n  if (!n.ok)\n    throw new Error(`Failed to fetch file: ${o}`);\n  const t = n.headers.get(\"Content-Type\") || \"application/octet-stream\";\n  if (!t.includes(\"application/wasm\") && !t.includes(\"binary/octet-stream\"))\n    throw new Error(`Unexpected MIME type: ${t} for ${o}`);\n  const a = await n.arrayBuffer(), m = new Response(a, {\n    headers: {\n      \"Content-Type\": t,\n      \"Content-Length\": a.byteLength.toString()\n    }\n  });\n  return await r.put(o, m), a;\n}\nexport {\n  C as InterpolationMethod,\n  I as bilinearUpsample,\n  L as compileShader,\n  b as isResolvedUri,\n  R as lanczos3Upsample,\n  T as linkProgram,\n  U as loadAndCacheFile,\n  E as resizeImage,\n  A as toAbsoluteURI\n};\n//# sourceMappingURL=util.js.map\n","import * as i from \"onnxruntime-web\";\nimport { loadAndCacheFile as h, isResolvedUri as c, toAbsoluteURI as m } from \"./util.js\";\nconst k = \"ort-wasm-simd-threaded.wasm\";\nclass U {\n  constructor() {\n    this.modelSessions = {}, this.resolvedUriCache = /* @__PURE__ */ new Map();\n  }\n  /**\n   * Initialize the worker using the provided configuration.\n   *\n   * @param config - The configuration object.\n   * @returns A promise that resolves when the worker is initialized.\n   */\n  async initializeWorker(e) {\n    if (typeof Worker > \"u\")\n      throw new Error(\"[ladon-ts] web workers are not supported in this environment\");\n    const r = await this.resolveUri(e, e.mask.workerUri), s = await (await fetch(r, { cache: \"force-cache\" })).text();\n    return this.workerUrl = URL.createObjectURL(new Blob([s], { type: \"text/javascript\" })), new Worker(this.workerUrl, { type: \"module\" });\n  }\n  /**\n   * Terminate the worker.\n   */\n  terminateWorker() {\n    this.worker && (this.worker.terminate(), this.worker = void 0);\n  }\n  /**\n   * Load the model using the provided configuration. This gets called by the worker when using\n   * the worker generator.\n   *\n   * @param config - The configuration object.\n   * @returns A promise that resolves when the model is preloaded.\n   */\n  async loadModel(e) {\n    const { mask: r, executionProviders: o } = e;\n    i.env.wasm.numThreads = 1;\n    const s = await this.resolveUri(e, e.wasmUri);\n    if (s)\n      try {\n        i.env.wasm.wasmBinary = await h(s + k);\n      } catch (w) {\n        console.warn(\"Failed to load or cache WASM file. Using WASM paths.\", w), i.env.wasm.wasmPaths = s;\n      }\n    const a = await this.resolveUri(e, r.modelUri);\n    let t = this.modelSessions[a];\n    if (!t) {\n      const n = { executionProviders: o != null && o.length ? o : [\"wasm\"] };\n      try {\n        const l = await h(a);\n        t = await i.InferenceSession.create(l, n);\n      } catch (l) {\n        console.warn(\"Failed to load or cache model file. Using model URL.\", l), t = await i.InferenceSession.create(a, n);\n      }\n    }\n    return this.modelSessions[a] = t, await this.warmupModel(t, r.inputSize, r.modelRank), t;\n  }\n  /**\n   * Preload the worker using the provided configuration.\n   *\n   * @param config - The configuration object.\n   * @returns A promise that resolves when the worker is preloaded.\n   */\n  async preloadWorker(e) {\n    const r = await this.prepareWorkerConfig(e);\n    this.worker = await this.initializeWorker(r), this.worker.postMessage({ type: \"preload\", config: r });\n  }\n  /**\n   * Warmup the model session with a dummy input to avoid latency when running the model for the first time.\n   *\n   * @param {ort.InferenceSession} session The model session.\n   * @param {ResolutionConfig} inputSize The input size of the model.\n   * @param {number} inputChannels The number of input channels (e.g., RGB is 3).\n   * @param {ort.Tensor.Type} inputType The input tensor type.\n   * @returns {Promise<void>} A promise that resolves when the model is warmed up.\n   * @example\n   * await warmupModel(session, inputSize, inputChannels, inputType);\n   */\n  async warmupModel(e, r = { width: 1280, height: 720 }, o = 3, s = \"float32\") {\n    const a = r.height * r.width, t = new Float32Array(o * a).fill(0), w = new i.Tensor(s, t, [\n      1,\n      o,\n      r.height,\n      r.width\n    ]), n = { [e.inputNames[0]]: w };\n    if (o === 3) {\n      const l = new Float32Array(a).fill(0), d = new i.Tensor(s, l, [\n        1,\n        1,\n        r.height,\n        r.width\n      ]);\n      n[e.inputNames[1]] = d;\n    }\n    await e.run(n);\n  }\n  /**\n   * Get the model session for the provided model URL.\n   *\n   * @param {string} modelUrl The model URL.\n   * @returns {ort.InferenceSession} The model session.\n   * @example\n   * const session = getModelSession(modelUrl);\n   */\n  getModelSession(e) {\n    return this.modelSessions[e];\n  }\n  /**\n   * Resolves the full URL for a given asset. Non-file URIs are treated as paths\n   * and resolved using the `toAbsoluteURI` method.\n   *\n   * @param config - The preload configuration.\n   * @param assetUri - The asset URI from the config.\n   * @returns The resolved full URL.\n   */\n  /**\n   * Resolves the full URL for a given asset. Non-file URIs are treated as paths and resolved\n   * using the `toAbsoluteURI` method. If the assetUri is already resolved, or if it's found in\n   * cache, it will be returned directly. If an assetUrlResolver function is provided in the\n   * configuration, it will be used to resolve the URL if the assetUri is not fully qualified,\n   * a blob URL, or in the cache.\n   *\n   * @param config - The preload configuration.\n   * @param assetUri - The asset URI from the config.\n   * @returns The resolved full URL.\n   */\n  async resolveUri(e, r) {\n    if (!r)\n      throw new Error(\"Asset URI is undefined.\");\n    if (this.resolvedUriCache.has(r))\n      return this.resolvedUriCache.get(r);\n    let o;\n    if (c(r) ? o = r : r.match(/\\.[a-z0-9]+$/i) ? typeof e.assetUrlResolver == \"function\" && (o = await e.assetUrlResolver(r, e)) : o = m(r, e.baseUrl), !o)\n      throw new Error(`Failed to resolve asset URI: ${r}`);\n    return this.resolvedUriCache.set(r, o), o;\n  }\n  getWorker() {\n    return this.worker;\n  }\n  getWorkerUrl() {\n    return this.workerUrl;\n  }\n  /**\n   * Prepare the worker configuration by resolving the final URLs and paths to send to the\n   * worker. This is necessary because we can't send functions to the worker. We also need to\n   * remove the assetUrlResolver function from the configuration.\n   *\n   * @param config - The preload configuration.\n   * @returns The worker configuration.\n   */\n  async prepareWorkerConfig(e) {\n    const o = { ...{\n      ...e,\n      mask: {\n        ...e.mask,\n        modelUri: await this.resolveUri(e, e.mask.modelUri),\n        workerUri: await this.resolveUri(e, e.mask.workerUri)\n      },\n      wasmUri: await this.resolveUri(e, e.wasmUri)\n    }, assetUrlResolver: void 0 };\n    return JSON.parse(JSON.stringify(o));\n  }\n}\nconst p = new U();\nexport {\n  p as sharedResourceManager\n};\n//# sourceMappingURL=shared-resource-manager.js.map\n","import * as c from \"onnxruntime-web\";\nimport { sharedResourceManager as d } from \"./shared-resource-manager.js\";\nclass R {\n  constructor(t) {\n    this.config = t, this.lastMaskGenerationTime = 0;\n    const { height: a, width: e } = this.config.mask.outputSize;\n    this.lastMask = new c.Tensor(\"float32\", new Float32Array(a * e), [\n      1,\n      1,\n      a,\n      e\n    ]), this.lastResult = {\n      data: this.lastMask.data,\n      facesAndLandmarks: { data: new Float32Array(0), dims: [] },\n      gesture: new Float32Array(0),\n      motion: 0,\n      timestamp: 0,\n      warm: !1\n    };\n  }\n  /**\n   * This method preprocesses an input Uint8ClampedArray to a Float32Array\n   * while maintaining memory efficiency by reusing a class-scoped output buffer.\n   * If the model rank is 4 (e.g., newer tiny model), it sets an alpha channel value.\n   *\n   * @param {Uint8ClampedArray} input - The input data to be preprocessed\n   * @param {Float32Array} alpha - The alpha channel data\n   * @returns {Float32Array} - The processed data\n   */\n  preprocess(t, a) {\n    const {\n      modelRank: e,\n      inputSize: l,\n      outputSize: s\n    } = this.config.mask, { height: r, width: i } = l, o = r * i;\n    this.output ?? (this.output = new Float32Array(o * e));\n    const k = t.length / 4;\n    for (let n = 0; n < 3; n++)\n      for (let m = 0; m < k; m++)\n        this.output[m + n * o] = t[m * 4 + (2 - n)];\n    const w = s.width / i, g = s.height / r;\n    for (let n = 0; n < i; n++) {\n      const m = Math.floor(n * w);\n      for (let h = 0; h < r; h++) {\n        const f = Math.floor(h * g), p = m + f * s.width, M = n + h * i + 3 * o, y = Math.min(Math.max(a[p], 0), 255);\n        this.output[M] = y;\n      }\n    }\n    return this.output;\n  }\n  getTimeSinceLastGeneration() {\n    return Date.now() - this.lastMaskGenerationTime;\n  }\n  async getLadonOutput(t, a) {\n    var s, r, i, o;\n    if (!this.maskModel)\n      throw new Error(\"[ladon-ts] - mask model not loaded.\");\n    if (this.getTimeSinceLastGeneration() < this.config.mask.generationIntervalMs)\n      return {\n        data: this.lastMask.data,\n        facesAndLandmarks: this.lastResult.facesAndLandmarks,\n        gesture: this.lastResult.gesture,\n        motion: this.lastResult.motion,\n        timestamp: this.lastResult.timestamp,\n        warm: !1\n      };\n    this.lastMaskGenerationTime = Date.now();\n    const e = new c.Tensor(\"float32\", this.preprocess(t, this.lastMask.data), [\n      1,\n      this.config.mask.modelRank,\n      this.config.mask.inputSize.height,\n      this.config.mask.inputSize.width\n    ]), l = await this.maskModel.run({ input: e });\n    return this.lastMask = l.segmentation, this.lastResult = {\n      data: this.lastMask.data ?? new Float32Array(0),\n      facesAndLandmarks: {\n        data: ((s = l.faces_and_landmarks) == null ? void 0 : s.data) ?? new Float32Array(0),\n        dims: ((r = l.faces_and_landmarks) == null ? void 0 : r.dims) ?? []\n      },\n      gesture: ((i = l.gesture) == null ? void 0 : i.data) ?? new Float32Array(0),\n      motion: ((o = l.motion) == null ? void 0 : o.data[0]) ?? 0,\n      timestamp: a,\n      warm: !0\n    }, this.lastResult;\n  }\n  async load() {\n    const t = await d.resolveUri(\n      this.config,\n      this.config.mask.modelUri\n    );\n    if (this.maskModel = d.getModelSession(t), this.maskModel ?? (this.maskModel = await d.loadModel(this.config)), !this.maskModel)\n      throw new Error(\"Failed to load the ONNX model.\");\n  }\n  isLoaded() {\n    return !!this.maskModel;\n  }\n  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n  async postRender(t) {\n  }\n  destroy() {\n  }\n}\nclass L {\n  constructor(t) {\n    this.config = t, this.lastMask = new Float32Array(\n      this.config.mask.outputSize.height * this.config.mask.outputSize.width\n    );\n  }\n  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n  async getLadonOutput(t) {\n    return {\n      data: this.lastMask,\n      facesAndLandmarks: { data: new Float32Array(0), dims: [] },\n      gesture: new Float32Array(0),\n      motion: 0,\n      timestamp: 0,\n      warm: !1\n    };\n  }\n  async load() {\n  }\n  isLoaded() {\n    return !0;\n  }\n  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n  async postRender(t) {\n  }\n  destroy() {\n  }\n}\nclass F {\n  constructor(t) {\n    this.config = t, this.newMask = !0, this.lastMask = new Float32Array(\n      this.config.mask.outputSize.height * this.config.mask.outputSize.width\n    ), this.lastResult = {\n      data: this.lastMask,\n      facesAndLandmarks: { data: new Float32Array(0), dims: [] },\n      gesture: new Float32Array(0),\n      motion: 0,\n      timestamp: 0,\n      warm: !1\n    };\n  }\n  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n  async getLadonOutput(t) {\n    const a = {\n      data: this.lastMask,\n      facesAndLandmarks: this.lastResult.facesAndLandmarks,\n      gesture: this.lastResult.gesture,\n      motion: this.lastResult.motion,\n      timestamp: this.lastResult.timestamp,\n      warm: this.newMask\n    };\n    return this.newMask = !1, a;\n  }\n  async load() {\n    const t = await d.prepareWorkerConfig(this.config);\n    if (this.worker = d.getWorker(), this.worker ?? (this.worker = await d.initializeWorker(t)), !this.worker)\n      throw new Error(\"[ladon-ts] - worker is not defined.\");\n    this.worker.onmessage = (s) => {\n      if (s.data.type === \"log\") {\n        const { message: r, severity: i } = s.data, o = `[ladon-ts] Message received from worker: ${r}`;\n        switch (i) {\n          case \"warn\":\n            console.warn(o);\n            break;\n          case \"error\":\n            console.error(o);\n            break;\n          default:\n            console.log(o);\n        }\n      } else if (s.data.status === \"generated\")\n        this.lastMask = s.data.mask, this.lastResult = {\n          data: s.data.mask,\n          facesAndLandmarks: s.data.facesAndLandmarks,\n          gesture: s.data.gesture,\n          motion: s.data.motion,\n          timestamp: s.data.timestamp,\n          warm: !0\n        }, this.newMask = !0;\n      else {\n        const r = d.getWorkerUrl();\n        r && URL.revokeObjectURL(r), e == null || e();\n      }\n    };\n    const a = {\n      baseUrl: t.baseUrl,\n      input: t.input,\n      mask: t.mask,\n      wasmUri: t.wasmUri,\n      render: { type: \"passthrough\" }\n    };\n    this.worker.postMessage({ type: \"init\", config: a });\n    let e;\n    return new Promise((s) => {\n      e = s;\n    });\n  }\n  isLoaded() {\n    return !!this.worker;\n  }\n  async postRender(t, a) {\n    if (!this.worker)\n      throw new Error(\"[ladon-ts] - worker is not defined.\");\n    this.worker.postMessage(\n      {\n        type: \"generate\",\n        image: t,\n        timestamp: a\n      },\n      [t.buffer]\n    );\n  }\n  destroy() {\n    d.terminateWorker();\n  }\n}\nexport {\n  R as LocalGenerator,\n  L as NullGenerator,\n  F as WorkerGenerator\n};\n//# sourceMappingURL=generator.js.map\n","import './shim';\nimport './console-overrides';\n\nimport {\n    LocalGenerator,\n    PipelineConfig,\n    PreloadConfig,\n    sharedResourceManager,\n} from '@webex/ladon-ts';\n\nlet generator: LocalGenerator;\nlet busy = false;\n\n// Message handler for worker\nself.addEventListener('message', async (event) => {\n    const { type, config, image, timestamp } = event.data;\n\n    try {\n        switch (type) {\n            case 'preload':\n                if (config) {\n                    await handlePreload(config as PreloadConfig);\n                }\n                break;\n\n            case 'init':\n                if (config) {\n                    await handleInit(config as PipelineConfig);\n                }\n                break;\n\n            case 'generate':\n                if (image) {\n                    await handleGenerate(image, timestamp);\n                }\n                break;\n\n            default:\n                console.warn(`[ladon-ts] - worker generator - unknown message: ${JSON.stringify(event.data)}`);\n        }\n    } catch (error) {\n        console.error(`[ladon-ts] - worker generator - error handling message: ${error}`);\n    }\n});\n\n// Handle preload event\nasync function handlePreload(config: PreloadConfig): Promise<void> {\n    await sharedResourceManager.loadModel(config);\n    postMessage({ status: 'preloaded' });\n}\n\n// Handle initialization\nasync function handleInit(config: PipelineConfig): Promise<void> {\n    generator = new LocalGenerator(config);\n    await generator.load();\n    postMessage({ status: 'initialized' });\n}\n\n// Handle generate event with SharedArrayBuffer support\nasync function handleGenerate(image: Uint8ClampedArray | null, timestamp: number): Promise<void> {\n    if (busy) {\n        return;\n    }\n\n    if (!generator || !generator.isLoaded()) {\n        console.warn('[ladon-ts] - Generator is not initialized');\n        return;\n    }\n\n    busy = true;\n\n    if (!image) {\n        console.warn('[ladon-ts] - No valid input provided for generation');\n        busy = false;\n        return;\n    }\n\n    // Run generator\n    const maskResult = await generator.getLadonOutput(image, timestamp);\n\n    if (maskResult.warm) {\n        postMessage({\n            facesAndLandmarks: maskResult.facesAndLandmarks,\n            gesture: maskResult.gesture,\n            mask: maskResult.data, // Transfer mask directly if TypedArray\n            motion: maskResult.motion,\n            timestamp: maskResult.timestamp,\n            status: 'generated',\n        });\n    }\n\n    setTimeout(() => {\n        busy = false;\n    }, 0);\n}\n"],"names":["args","o","U","s","n","t","a","m","e","r","i.env","h","w","l","i.InferenceSession","i.Tensor","d","c","c.Tensor","i","k","g","f","p","M","y","event","type","config","image","timestamp","error","sharedResourceManager","LocalGenerator","maskResult"],"mappings":"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"}
+{"version":3,"file":"segmentation.js","sources":["../src/shim.ts","../src/console-overrides.ts","../../build/module/lib/util.js","../../build/module/lib/resource-loader.js","../src/util.ts","../src/model-manager.ts","../src/ladon-generator.ts","../src/segmentation.ts"],"sourcesContent":["/**\n * This file is used to provide a shim for the document object in a web worker.\n * The document object is not available in a web worker, so we need to provide a shim\n * to prevent errors when running the code in a web worker.\n * \n * See: https://github.com/vitejs/vite/issues/9879#issuecomment-1372112651\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\n(self.document as any)  = {\n    baseURI: location.origin\n};","/**\n * Override console methods to send logs to the main thread for display in the UI.\n */\n\nconst originalConsoleLog = console.log;\nconst originalConsoleWarn = console.warn;\nconst originalConsoleError = console.error;\n\nconsole.log = (...args) => {\n    postMessage({ type: 'log', message: args.join(' '), severity: 'log' });\n    originalConsoleLog(...args);\n};\n\nconsole.warn = (...args) => {\n    postMessage({ type: 'log', message: args.join(' '), severity: 'warn' });\n    originalConsoleWarn(...args);\n};\n\nconsole.error = (...args) => {\n    postMessage({ type: 'log', message: args.join(' '), severity: 'error' });\n    originalConsoleError(...args);\n};","var U = /* @__PURE__ */ ((o) => (o.Nearest = \"nearest\", o))(U || {});\nconst A = (o, n, u, r, e) => {\n  const l = new Uint8ClampedArray(r * e * 4), p = n / r, y = u / e, s = n * 4;\n  let a = 0;\n  for (let t = 0; t < e; t++) {\n    const f = Math.floor(t * y) * s;\n    for (let c = 0; c < r; c++) {\n      const m = f + Math.floor(c * p) * 4;\n      l[a++] = o[m], l[a++] = o[m + 1], l[a++] = o[m + 2], l[a++] = o[m + 3];\n    }\n  }\n  return l;\n};\nfunction d(o, n, u, r, e) {\n  const l = new Uint8ClampedArray(r * e);\n  if (n === r && u === e) {\n    for (let s = 0; s < o.length; s++)\n      l[s] = Math.min(Math.max(o[s], 0), 255);\n    return l;\n  }\n  const p = (n - 1) / (r - 1), y = (u - 1) / (e - 1);\n  for (let s = 0; s < e; s++)\n    for (let a = 0; a < r; a++) {\n      const t = p * a, f = y * s, c = Math.floor(t), m = Math.floor(f), S = Math.min(Math.ceil(t), n - 1), x = Math.min(Math.ceil(f), u - 1), w = t - c, i = f - m, M = o[m * n + c], h = o[m * n + S], k = o[x * n + c], P = o[x * n + S], I = M * (1 - w) * (1 - i) + h * w * (1 - i) + k * (1 - w) * i + P * w * i;\n      l[s * r + a] = Math.min(Math.max(I, 0), 255);\n    }\n  return l;\n}\nfunction E(o, n, u, r, e) {\n  const l = new Uint8ClampedArray(r * e), p = n / r, y = u / e, s = (t, f) => {\n    if (t === 0) return 1;\n    if (t < 0 && (t = -t), t < f) {\n      const c = Math.PI * t;\n      return f * Math.sin(c) * Math.sin(c / f) / (c * c);\n    }\n    return 0;\n  }, a = 3;\n  for (let t = 0; t < e; t++)\n    for (let f = 0; f < r; f++) {\n      const c = f * p, m = t * y, S = Math.floor(c), x = Math.floor(m);\n      let w = 0, i = 0;\n      for (let M = x - a + 1; M <= x + a; M++)\n        for (let h = S - a + 1; h <= S + a; h++)\n          if (h >= 0 && h < n && M >= 0 && M < u) {\n            const k = o[M * n + h], P = s(c - h, a) * s(m - M, a);\n            w += k * P, i += P;\n          }\n      l[t * r + f] = i !== 0 ? Math.round(w / i) : 0;\n    }\n  return l;\n}\nfunction L(o, n, u) {\n  const r = o.createShader(n);\n  if (!r)\n    throw new Error(\"[ladon-ts] - error creating shader\");\n  if (o.shaderSource(r, u), o.compileShader(r), !o.getShaderParameter(r, o.COMPILE_STATUS)) {\n    const e = o.getShaderInfoLog(r) ?? \"unknown error compiling shader.\";\n    throw new Error(\"[ladon-ts] - \" + e);\n  }\n  return r;\n}\nfunction R(o, n, u) {\n  const r = o.createProgram();\n  if (!r)\n    throw new Error(\"[ladon-ts] - error creating GPU program\");\n  if (o.attachShader(r, n), o.attachShader(r, u), o.linkProgram(r), !o.getProgramParameter(r, o.LINK_STATUS)) {\n    const e = o.getProgramInfoLog(r) ?? \"unknown error linking program.\";\n    throw new Error(\"[ladon-ts] - \" + e);\n  }\n  return r;\n}\nfunction C(o) {\n  if (o.startsWith(\"blob:\"))\n    return !0;\n  try {\n    return new URL(o), !0;\n  } catch {\n    return !1;\n  }\n}\nconst T = (o, n) => !n || o.startsWith(\"http\") ? new URL(o).href : o ? n.replace(/\\/+$/, \"\") + \"/\" + o.replace(/^\\/+/, \"\") : n;\nexport {\n  U as InterpolationMethod,\n  d as bilinearUpsample,\n  L as compileShader,\n  C as isResolvedUri,\n  E as lanczos3Upsample,\n  R as linkProgram,\n  A as resizeImage,\n  T as toAbsoluteURI\n};\n//# sourceMappingURL=util.js.map\n","import { isResolvedUri as l, toAbsoluteURI as s } from \"./util.js\";\nclass t {\n  constructor() {\n    this.resolvedUriCache = /* @__PURE__ */ new Map();\n  }\n  /**\n   * Resolves the full URL for a given asset. Non-file URIs are treated as paths and resolved\n   * using the `toAbsoluteURI` method. If the assetUri is already resolved, or if it's found in\n   * cache, it will be returned directly. If an assetUrlResolver function is provided in the\n   * configuration, it will be used to resolve the URL if the assetUri is not fully qualified,\n   * a blob URL, or in the cache.\n   *\n   * @param config - The preload configuration.\n   * @param assetUri - The asset URI from the config.\n   * @returns The resolved full URL.\n   */\n  async resolveUri(o, e) {\n    if (!e)\n      throw new Error(\"Asset URI is undefined.\");\n    if (this.resolvedUriCache.has(e))\n      return this.resolvedUriCache.get(e);\n    let r;\n    if (l(e) ? r = e : e.match(/\\.[a-z0-9]+$/i) ? typeof o.assetUrlResolver == \"function\" && (r = await o.assetUrlResolver(e, o)) : r = s(e, o.baseUrl), !r)\n      throw new Error(`Failed to resolve asset URI: ${e}`);\n    return this.resolvedUriCache.set(e, r), r;\n  }\n}\nconst d = new t();\nexport {\n  t as ResourceLoader,\n  d as resourceLoader\n};\n//# sourceMappingURL=resource-loader.js.map\n","export { isResolvedUri, toAbsoluteURI } from '@webex/ladon-ts'\n\nexport async function loadAndCacheFile(fileUrl: string): Promise<ArrayBufferLike | Uint8Array> {\n    const cache = await caches.open('ladon-cache');\n\n    // Try to get the file from cache using its full URL\n    const cachedResponse = await cache.match(fileUrl);\n    if (cachedResponse) {\n        return cachedResponse.arrayBuffer();\n    }\n\n    // If not in cache, fetch and cache the file\n    const response = await fetch(fileUrl);\n\n    // Ensure the response is valid\n    if (!response.ok) {\n        throw new Error(`Failed to fetch file: ${fileUrl}`);\n    }\n\n    const contentType = response.headers.get('Content-Type') || 'binary/octet-stream';\n\n    // Validate expected MIME types\n    if (!contentType.includes('application/wasm') && !contentType.includes('binary/octet-stream')) {\n        throw new Error(`Unexpected MIME type: ${contentType} for ${fileUrl}`);\n    }\n\n    const fileBinary = await response.arrayBuffer();\n\n    // Cache the response with proper headers\n    const cachedResponseWithHeaders = new Response(fileBinary, {\n        headers: {\n            'Content-Type': contentType,\n            'Content-Length': fileBinary.byteLength.toString(),\n        },\n    });\n\n    // Store the response in the cache using the full URL as the key\n    await cache.put(fileUrl, cachedResponseWithHeaders);\n\n    return fileBinary;\n}\n","import * as ort from 'onnxruntime-web';\nimport { PreloadConfig, ResolutionConfig, resourceLoader } from '@webex/ladon-ts';\n\nimport { loadAndCacheFile } from './util';\n\n// There is only a single WASM file for all WebAssembly binaries now.\nconst ONNX_WASM_FILENAME = 'ort-wasm-simd-threaded.wasm';\n\n/**\n * Resource manager used to load resources for the segmentation worker.\n */\nexport class ModelManager {\n    private modelSessions: Record<string, ort.InferenceSession> = {};\n\n    /**\n     * Load the model using the provided configuration. This gets called by the worker when using\n     * the worker generator.\n     *\n     * @param config - The configuration object.\n     * @returns A promise that resolves when the model is preloaded.\n     */\n    public async loadModel(config: PreloadConfig) {\n        const { mask, executionProviders: providers } = config;\n\n        // Lock to a single thread to avoid performance issues.\n        ort.env.wasm.numThreads = 1;\n\n        // Get the resolved paths for the WASM binary.\n        const wasmPaths = await resourceLoader.resolveUri(config, config.wasmUri);\n\n        if (wasmPaths) {\n            try {\n                ort.env.wasm.wasmBinary = await loadAndCacheFile(wasmPaths + ONNX_WASM_FILENAME);\n            } catch (error) {\n                console.warn('Failed to load or cache WASM file. Using WASM paths.', error);\n                ort.env.wasm.wasmPaths = wasmPaths;\n            }\n        }\n\n        // Resolve the model URL.\n        const modelUrl = await resourceLoader.resolveUri(config, mask.modelUri);\n        let modelSession = this.modelSessions[modelUrl];\n\n        // If the model session is not already cached, create a new session and cache.\n        if (!modelSession) {\n            // Allows the user to specify the execution providers to use. The default is the WASM provider.\n            // TODO: Add and test support for other execution providers.\n            const executionProviders = providers?.length ? providers : ['wasm'];\n            const sessionOptions = { executionProviders };\n\n            // First try to get the model binary either from cache or by fetching and cacheing it.\n            try {\n                const modelBinary = await loadAndCacheFile(modelUrl);\n                modelSession = await ort.InferenceSession.create(modelBinary, sessionOptions);\n            } catch (error) {\n                console.warn('Failed to load or cache model file. Using model URL.', error);\n                modelSession = await ort.InferenceSession.create(modelUrl, sessionOptions);\n            }\n        }\n\n        // Cache the model session.\n        this.modelSessions[modelUrl] = modelSession;\n\n        // Warmup the model with a dummy input to avoid latency when running the model for the first time.\n        await this.warmupModel(modelSession, mask.inputSize, mask.modelRank);\n\n        return modelSession;\n    }\n\n    /**\n     * Warmup the model session with a dummy input to avoid latency when running the model for the first time.\n     *\n     * @param {ort.InferenceSession} session The model session.\n     * @param {ResolutionConfig} inputSize The input size of the model.\n     * @param {number} inputChannels The number of input channels (e.g., RGB is 3).\n     * @param {ort.Tensor.Type} inputType The input tensor type.\n     * @returns {Promise<void>} A promise that resolves when the model is warmed up.\n     * @example\n     * await warmupModel(session, inputSize, inputChannels, inputType);\n     */\n    public async warmupModel(\n        session: ort.InferenceSession,\n        inputSize: ResolutionConfig = { width: 1280, height: 720 },\n        inputChannels = 3,\n        inputType: ort.Tensor.Type = 'float32'\n    ): Promise<void> {\n        const numPixels = inputSize.height * inputSize.width;\n        const dummyInputData = new Float32Array(inputChannels * numPixels).fill(0);\n        const dummyInput = new ort.Tensor(inputType, dummyInputData, [\n            1,\n            inputChannels,\n            inputSize.height,\n            inputSize.width,\n        ]);\n        const feed = { [session.inputNames[0]]: dummyInput };\n\n        // Use an additional dummy tensor if the model expects a previous mask.\n        if (inputChannels === 3) {\n            const dummyMaskData = new Float32Array(numPixels).fill(0);\n            const prevMaskTensor = new ort.Tensor(inputType, dummyMaskData, [\n                1,\n                1,\n                inputSize.height,\n                inputSize.width,\n            ]);\n            feed[session.inputNames[1]] = prevMaskTensor;\n        }\n\n        // Run the model with the dummy input to warm it up.\n        await session.run(feed);\n    }\n\n    /**\n     * Get the model session for the provided model URL.\n     *\n     * @param {string} modelUrl The model URL.\n     * @returns {ort.InferenceSession} The model session.\n     * @example\n     * const session = getModelSession(modelUrl);\n     */\n    public getModelSession(modelUrl: string) {\n        return this.modelSessions[modelUrl];\n    }\n    \n}\n\nexport const modelManager = new ModelManager();","import * as ort from 'onnxruntime-web';\n\nimport { LadonOutput, MaskGenerator, PipelineConfig, resourceLoader } from '@webex/ladon-ts';\n\nimport { modelManager } from './model-manager';\n\n\nexport class LadonGenerator implements MaskGenerator {\n    private lastResult: LadonOutput;\n    private lastMask: ort.Tensor;\n    private maskModel?: ort.InferenceSession;\n    private lastMaskGenerationTime = 0;\n    private output?: Float32Array;\n\n    constructor(public readonly config: PipelineConfig) {\n        const { height, width } = this.config.mask.outputSize;\n        this.lastMask = new ort.Tensor('float32', new Float32Array(height * width), [\n            1,\n            1,\n            height,\n            width,\n        ]);\n        this.lastResult = {\n            data: this.lastMask.data,\n            facesAndLandmarks: { data: new Float32Array(0), dims: [] },\n            gesture: new Float32Array(0),\n            motion: 0,\n            timestamp: 0,\n            warm: false,\n        };\n    }\n\n    /**\n     * This method preprocesses an input Uint8ClampedArray to a Float32Array\n     * while maintaining memory efficiency by reusing a class-scoped output buffer.\n     * If the model rank is 4 (e.g., newer tiny model), it sets an alpha channel value.\n     *\n     * @param {Uint8ClampedArray} input - The input data to be preprocessed\n     * @param {Float32Array} alpha - The alpha channel data\n     * @returns {Float32Array} - The processed data\n     */\n    private preprocess(input: Uint8ClampedArray, alpha: Float32Array): Float32Array {\n        const {\n            modelRank: model_rank,\n            inputSize: input_size,\n            outputSize: output_size,\n        } = this.config.mask;\n        const { height, width } = input_size;\n        const numImagePixels = height * width;\n\n        // Initialize the output buffer if it is not already set\n        this.output ??= new Float32Array(numImagePixels * model_rank);\n\n        const numInputPixels = input.length / 4; // Divide by 4 for RGBA\n\n        // Directly copy channels (assumes fixed order like BGR or RGB)\n        for (let channel = 0; channel < 3; channel++) {\n            for (let pixel = 0; pixel < numInputPixels; pixel++) {\n                // Map input channels directly to output\n                this.output[pixel + channel * numImagePixels] = input[pixel * 4 + (2 - channel)];\n            }\n        }\n\n        // Scaling factors for width and height\n        const widthScale = output_size.width / width;\n        const heightScale = output_size.height / height;\n\n        // Process alpha channel\n        for (let x = 0; x < width; x++) {\n            const nearestNeighborX = Math.floor(x * widthScale);\n            for (let y = 0; y < height; y++) {\n                const nearestNeighborY = Math.floor(y * heightScale);\n                const maskIdx = nearestNeighborX + nearestNeighborY * output_size.width;\n                const outputIdx = x + y * width + 3 * numImagePixels;\n\n                // Normalize and scale alpha to [0, 255]\n                const normalizedValue = Math.min(Math.max(alpha[maskIdx], 0), 255);\n                this.output[outputIdx] = normalizedValue;\n            }\n        }\n\n        return this.output;\n    }\n\n    public getTimeSinceLastGeneration(): number {\n        return Date.now() - this.lastMaskGenerationTime;\n    }\n\n    public async getLadonOutput(input: Uint8ClampedArray, timestamp: number): Promise<LadonOutput> {\n        if (!this.maskModel) {\n            throw new Error('[ladon-ts] - mask model not loaded.');\n        }\n\n        if (this.getTimeSinceLastGeneration() < this.config.mask.generationIntervalMs) {\n            return {\n                data: this.lastMask.data,\n                facesAndLandmarks: this.lastResult.facesAndLandmarks,\n                gesture: this.lastResult.gesture,\n                motion: this.lastResult.motion,\n                timestamp: this.lastResult.timestamp,\n                warm: false,\n            };\n        }\n\n        this.lastMaskGenerationTime = Date.now();\n\n        const imageTensor = new ort.Tensor('float32', this.preprocess(input, this.lastMask.data), [\n            1,\n            this.config.mask.modelRank,\n            this.config.mask.inputSize.height,\n            this.config.mask.inputSize.width,\n        ]);\n\n        const results = await this.maskModel.run({ input: imageTensor });\n        this.lastMask = results.segmentation;\n\n        this.lastResult = {\n            data: this.lastMask.data ?? new Float32Array(0),\n            facesAndLandmarks: {\n                data: results.faces_and_landmarks?.data ?? new Float32Array(0),\n                dims: results.faces_and_landmarks?.dims ?? ([] as readonly number[]),\n            },\n            gesture: results.gesture?.data ?? new Float32Array(0),\n            motion: results.motion?.data[0] ?? 0,\n            timestamp,\n            warm: true,\n        };\n\n        return this.lastResult;\n    }\n\n    async load() {\n        const modelUrl = await resourceLoader.resolveUri(\n            this.config,\n            this.config.mask.modelUri\n        );\n\n        // Attempt to retrieve a preloaded InferenceSession from the shared resource manager.\n        this.maskModel = modelManager.getModelSession(modelUrl);\n        // If the model is not preloaded, load it from the provided model URL.\n        this.maskModel ??= await modelManager.loadModel(this.config);\n\n        if (!this.maskModel) {\n            throw new Error('Failed to load the ONNX model.');\n        }\n    }\n\n    public isLoaded(): boolean {\n        return !!this.maskModel;\n    }\n\n    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n    public async postRender(_: Uint8ClampedArray): Promise<void> {\n        // empty for local generator\n    }\n\n    public destroy(): void {\n        // empty for local generator\n    }\n}","import './shim';\nimport './console-overrides';\n\nimport { PipelineConfig, PreloadConfig } from '@webex/ladon-ts';\n\nimport { LadonGenerator } from './ladon-generator';\nimport { modelManager } from './model-manager';\n\nlet preloadPromise: Promise<void> | null = null;\nlet generator: LadonGenerator;\nlet busy = false;\n\n// Message handler for worker\nself.addEventListener('message', async (event) => {\n    const { type, config, image, timestamp } = event.data;\n\n    try {\n        switch (type) {\n            case 'preload':\n                if (config) {\n                    preloadPromise = handlePreload(config as PreloadConfig);\n                    await preloadPromise;\n                }\n                break;\n\n            case 'init':\n                if (config) {\n                    // Wait for preload to complete before initializing\n                    if (preloadPromise) {\n                        await preloadPromise;\n                    }\n                    await handleInit(config as PipelineConfig);\n                }\n                break;\n\n            case 'generate':\n                if (image) {\n                    await handleGenerate(image, timestamp);\n                }\n                break;\n\n            default:\n                console.warn(`[ladon-ts] - worker generator - unknown message: ${JSON.stringify(event.data)}`);\n        }\n    } catch (error) {\n        console.error(`[ladon-ts] - worker generator - error handling message: ${error}`);\n        postMessage({ status: 'error', error: error.message });\n    }\n});\n\n// Handle preload event\nasync function handlePreload(config: PreloadConfig): Promise<void> {\n    await modelManager.loadModel(config);\n    postMessage({ status: 'preloaded' });\n}\n\n// Handle initialization\nasync function handleInit(config: PipelineConfig): Promise<void> {\n    generator = new LadonGenerator(config);\n    await generator.load();\n    postMessage({ status: 'initialized' });\n}\n\n// Handle generate event with SharedArrayBuffer support\nasync function handleGenerate(image: Uint8ClampedArray | null, timestamp: number): Promise<void> {\n    if (busy) {\n        return;\n    }\n\n    if (!generator || !generator.isLoaded()) {\n        console.warn('[ladon-ts] - Generator is not initialized');\n        return;\n    }\n\n    busy = true;\n\n    if (!image) {\n        console.warn('[ladon-ts] - No valid input provided for generation');\n        busy = false;\n        return;\n    }\n\n    // Run generator\n    const maskResult = await generator.getLadonOutput(image, timestamp);\n\n    if (maskResult.warm) {\n        postMessage({\n            facesAndLandmarks: maskResult.facesAndLandmarks,\n            gesture: maskResult.gesture,\n            mask: maskResult.data, // Transfer mask directly if TypedArray\n            motion: maskResult.motion,\n            timestamp: maskResult.timestamp,\n            status: 'generated',\n        });\n    }\n\n    setTimeout(() => {\n        busy = false;\n    }, 0);\n}\n"],"names":["args","o","e","r","l","s","fileUrl","cache","cachedResponse","response","contentType","fileBinary","cachedResponseWithHeaders","config","mask","providers","ort.env","wasmPaths","resourceLoader","error","modelUrl","modelSession","sessionOptions","modelBinary","ort.InferenceSession","session","inputSize","inputChannels","inputType","numPixels","dummyInputData","dummyInput","ort.Tensor","feed","dummyMaskData","prevMaskTensor","height","width","input","alpha","model_rank","input_size","output_size","numImagePixels","numInputPixels","channel","pixel","widthScale","heightScale","x","nearestNeighborX","y","nearestNeighborY","maskIdx","outputIdx","normalizedValue","timestamp","imageTensor","results","_a","_b","_c","_d","_","event","type","image","maskResult"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/ladon-ts",
-  "version": "5.4.5",
+  "version": "5.5.0",
   "description": "WebexIntelligence computer vision library",
   "type": "module",
   "main": "build/module/index.js",
@@ -74,9 +74,6 @@
   "optionalDependencies": {
     "@rollup/rollup-linux-x64-gnu": "4.36.0"
   },
-  "dependencies": {
-    "onnxruntime-web": "1.20.1"
-  },
   "files": [
     "build/main",
     "build/module",

package/build/module/lib/generator.js

@@ -1,224 +0,0 @@
-import * as c from "onnxruntime-web";
-import { sharedResourceManager as d } from "./shared-resource-manager.js";
-class R {
-  constructor(t) {
-    this.config = t, this.lastMaskGenerationTime = 0;
-    const { height: a, width: e } = this.config.mask.outputSize;
-    this.lastMask = new c.Tensor("float32", new Float32Array(a * e), [
-      1,
-      1,
-      a,
-      e
-    ]), this.lastResult = {
-      data: this.lastMask.data,
-      facesAndLandmarks: { data: new Float32Array(0), dims: [] },
-      gesture: new Float32Array(0),
-      motion: 0,
-      timestamp: 0,
-      warm: !1
-    };
-  }
-  /**
-   * This method preprocesses an input Uint8ClampedArray to a Float32Array
-   * while maintaining memory efficiency by reusing a class-scoped output buffer.
-   * If the model rank is 4 (e.g., newer tiny model), it sets an alpha channel value.
-   *
-   * @param {Uint8ClampedArray} input - The input data to be preprocessed
-   * @param {Float32Array} alpha - The alpha channel data
-   * @returns {Float32Array} - The processed data
-   */
-  preprocess(t, a) {
-    const {
-      modelRank: e,
-      inputSize: l,
-      outputSize: s
-    } = this.config.mask, { height: r, width: i } = l, o = r * i;
-    this.output ?? (this.output = new Float32Array(o * e));
-    const k = t.length / 4;
-    for (let n = 0; n < 3; n++)
-      for (let m = 0; m < k; m++)
-        this.output[m + n * o] = t[m * 4 + (2 - n)];
-    const w = s.width / i, g = s.height / r;
-    for (let n = 0; n < i; n++) {
-      const m = Math.floor(n * w);
-      for (let h = 0; h < r; h++) {
-        const f = Math.floor(h * g), p = m + f * s.width, M = n + h * i + 3 * o, y = Math.min(Math.max(a[p], 0), 255);
-        this.output[M] = y;
-      }
-    }
-    return this.output;
-  }
-  getTimeSinceLastGeneration() {
-    return Date.now() - this.lastMaskGenerationTime;
-  }
-  async getLadonOutput(t, a) {
-    var s, r, i, o;
-    if (!this.maskModel)
-      throw new Error("[ladon-ts] - mask model not loaded.");
-    if (this.getTimeSinceLastGeneration() < this.config.mask.generationIntervalMs)
-      return {
-        data: this.lastMask.data,
-        facesAndLandmarks: this.lastResult.facesAndLandmarks,
-        gesture: this.lastResult.gesture,
-        motion: this.lastResult.motion,
-        timestamp: this.lastResult.timestamp,
-        warm: !1
-      };
-    this.lastMaskGenerationTime = Date.now();
-    const e = new c.Tensor("float32", this.preprocess(t, this.lastMask.data), [
-      1,
-      this.config.mask.modelRank,
-      this.config.mask.inputSize.height,
-      this.config.mask.inputSize.width
-    ]), l = await this.maskModel.run({ input: e });
-    return this.lastMask = l.segmentation, this.lastResult = {
-      data: this.lastMask.data ?? new Float32Array(0),
-      facesAndLandmarks: {
-        data: ((s = l.faces_and_landmarks) == null ? void 0 : s.data) ?? new Float32Array(0),
-        dims: ((r = l.faces_and_landmarks) == null ? void 0 : r.dims) ?? []
-      },
-      gesture: ((i = l.gesture) == null ? void 0 : i.data) ?? new Float32Array(0),
-      motion: ((o = l.motion) == null ? void 0 : o.data[0]) ?? 0,
-      timestamp: a,
-      warm: !0
-    }, this.lastResult;
-  }
-  async load() {
-    const t = await d.resolveUri(
-      this.config,
-      this.config.mask.modelUri
-    );
-    if (this.maskModel = d.getModelSession(t), this.maskModel ?? (this.maskModel = await d.loadModel(this.config)), !this.maskModel)
-      throw new Error("Failed to load the ONNX model.");
-  }
-  isLoaded() {
-    return !!this.maskModel;
-  }
-  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
-  async postRender(t) {
-  }
-  destroy() {
-  }
-}
-class L {
-  constructor(t) {
-    this.config = t, this.lastMask = new Float32Array(
-      this.config.mask.outputSize.height * this.config.mask.outputSize.width
-    );
-  }
-  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
-  async getLadonOutput(t) {
-    return {
-      data: this.lastMask,
-      facesAndLandmarks: { data: new Float32Array(0), dims: [] },
-      gesture: new Float32Array(0),
-      motion: 0,
-      timestamp: 0,
-      warm: !1
-    };
-  }
-  async load() {
-  }
-  isLoaded() {
-    return !0;
-  }
-  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
-  async postRender(t) {
-  }
-  destroy() {
-  }
-}
-class F {
-  constructor(t) {
-    this.config = t, this.newMask = !0, this.lastMask = new Float32Array(
-      this.config.mask.outputSize.height * this.config.mask.outputSize.width
-    ), this.lastResult = {
-      data: this.lastMask,
-      facesAndLandmarks: { data: new Float32Array(0), dims: [] },
-      gesture: new Float32Array(0),
-      motion: 0,
-      timestamp: 0,
-      warm: !1
-    };
-  }
-  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
-  async getLadonOutput(t) {
-    const a = {
-      data: this.lastMask,
-      facesAndLandmarks: this.lastResult.facesAndLandmarks,
-      gesture: this.lastResult.gesture,
-      motion: this.lastResult.motion,
-      timestamp: this.lastResult.timestamp,
-      warm: this.newMask
-    };
-    return this.newMask = !1, a;
-  }
-  async load() {
-    const t = await d.prepareWorkerConfig(this.config);
-    if (this.worker = d.getWorker(), this.worker ?? (this.worker = await d.initializeWorker(t)), !this.worker)
-      throw new Error("[ladon-ts] - worker is not defined.");
-    this.worker.onmessage = (s) => {
-      if (s.data.type === "log") {
-        const { message: r, severity: i } = s.data, o = `[ladon-ts] Message received from worker: ${r}`;
-        switch (i) {
-          case "warn":
-            console.warn(o);
-            break;
-          case "error":
-            console.error(o);
-            break;
-          default:
-            console.log(o);
-        }
-      } else if (s.data.status === "generated")
-        this.lastMask = s.data.mask, this.lastResult = {
-          data: s.data.mask,
-          facesAndLandmarks: s.data.facesAndLandmarks,
-          gesture: s.data.gesture,
-          motion: s.data.motion,
-          timestamp: s.data.timestamp,
-          warm: !0
-        }, this.newMask = !0;
-      else {
-        const r = d.getWorkerUrl();
-        r && URL.revokeObjectURL(r), e == null || e();
-      }
-    };
-    const a = {
-      baseUrl: t.baseUrl,
-      input: t.input,
-      mask: t.mask,
-      wasmUri: t.wasmUri,
-      render: { type: "passthrough" }
-    };
-    this.worker.postMessage({ type: "init", config: a });
-    let e;
-    return new Promise((s) => {
-      e = s;
-    });
-  }
-  isLoaded() {
-    return !!this.worker;
-  }
-  async postRender(t, a) {
-    if (!this.worker)
-      throw new Error("[ladon-ts] - worker is not defined.");
-    this.worker.postMessage(
-      {
-        type: "generate",
-        image: t,
-        timestamp: a
-      },
-      [t.buffer]
-    );
-  }
-  destroy() {
-    d.terminateWorker();
-  }
-}
-export {
-  R as LocalGenerator,
-  L as NullGenerator,
-  F as WorkerGenerator
-};
-//# sourceMappingURL=generator.js.map

package/build/module/lib/generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generator.js","sources":["../../../src/lib/generator.ts"],"sourcesContent":["import * as ort from 'onnxruntime-web';\n\nimport { PipelineConfig } from './config-types';\nimport { sharedResourceManager } from './shared-resource-manager';\n\ndeclare global {\n    interface ImportMeta {\n        url: string;\n    }\n}\n\nexport type FrameData = Uint8ClampedArray | HTMLVideoElement;\n\nexport interface FacesAndLandmarks {\n    data: Float32Array;\n    dims: readonly number[];\n}\nexport interface LadonOutput {\n    data: Float32Array; // 1x1x144x256 or 1x1x360x640\n    facesAndLandmarks: FacesAndLandmarks; // 1x1x9x16x1439\n    gesture: Float32Array; // 1x9\n    motion: number; // 1x1x1x1\n    timestamp: number;\n    warm: boolean;\n}\n\nexport interface MaskGenerator {\n    getLadonOutput(input: Uint8ClampedArray, timestamp: number): Promise<LadonOutput>;\n    load(): Promise<void>;\n    isLoaded(): boolean;\n    postRender(input: Uint8ClampedArray, timestamp: number): Promise<void>;\n    destroy(): void;\n}\n\nexport class LocalGenerator implements MaskGenerator {\n    private lastResult: LadonOutput;\n    private lastMask: ort.Tensor;\n    private maskModel?: ort.InferenceSession;\n    private lastMaskGenerationTime = 0;\n    private output?: Float32Array;\n\n    constructor(public readonly config: PipelineConfig) {\n        const { height, width } = this.config.mask.outputSize;\n        this.lastMask = new ort.Tensor('float32', new Float32Array(height * width), [\n            1,\n            1,\n            height,\n            width,\n        ]);\n        this.lastResult = {\n            data: this.lastMask.data,\n            facesAndLandmarks: { data: new Float32Array(0), dims: [] },\n            gesture: new Float32Array(0),\n            motion: 0,\n            timestamp: 0,\n            warm: false,\n        };\n    }\n\n    /**\n     * This method preprocesses an input Uint8ClampedArray to a Float32Array\n     * while maintaining memory efficiency by reusing a class-scoped output buffer.\n     * If the model rank is 4 (e.g., newer tiny model), it sets an alpha channel value.\n     *\n     * @param {Uint8ClampedArray} input - The input data to be preprocessed\n     * @param {Float32Array} alpha - The alpha channel data\n     * @returns {Float32Array} - The processed data\n     */\n    private preprocess(input: Uint8ClampedArray, alpha: Float32Array): Float32Array {\n        const {\n            modelRank: model_rank,\n            inputSize: input_size,\n            outputSize: output_size,\n        } = this.config.mask;\n        const { height, width } = input_size;\n        const numImagePixels = height * width;\n\n        // Initialize the output buffer if it is not already set\n        this.output ??= new Float32Array(numImagePixels * model_rank);\n\n        const numInputPixels = input.length / 4; // Divide by 4 for RGBA\n\n        // Directly copy channels (assumes fixed order like BGR or RGB)\n        for (let channel = 0; channel < 3; channel++) {\n            for (let pixel = 0; pixel < numInputPixels; pixel++) {\n                // Map input channels directly to output\n                this.output[pixel + channel * numImagePixels] = input[pixel * 4 + (2 - channel)];\n            }\n        }\n\n        // Scaling factors for width and height\n        const widthScale = output_size.width / width;\n        const heightScale = output_size.height / height;\n\n        // Process alpha channel\n        for (let x = 0; x < width; x++) {\n            const nearestNeighborX = Math.floor(x * widthScale);\n            for (let y = 0; y < height; y++) {\n                const nearestNeighborY = Math.floor(y * heightScale);\n                const maskIdx = nearestNeighborX + nearestNeighborY * output_size.width;\n                const outputIdx = x + y * width + 3 * numImagePixels;\n\n                // Normalize and scale alpha to [0, 255]\n                const normalizedValue = Math.min(Math.max(alpha[maskIdx], 0), 255);\n                this.output[outputIdx] = normalizedValue;\n            }\n        }\n\n        return this.output;\n    }\n\n    public getTimeSinceLastGeneration(): number {\n        return Date.now() - this.lastMaskGenerationTime;\n    }\n\n    public async getLadonOutput(input: Uint8ClampedArray, timestamp: number): Promise<LadonOutput> {\n        if (!this.maskModel) {\n            throw new Error('[ladon-ts] - mask model not loaded.');\n        }\n\n        if (this.getTimeSinceLastGeneration() < this.config.mask.generationIntervalMs) {\n            return {\n                data: this.lastMask.data,\n                facesAndLandmarks: this.lastResult.facesAndLandmarks,\n                gesture: this.lastResult.gesture,\n                motion: this.lastResult.motion,\n                timestamp: this.lastResult.timestamp,\n                warm: false,\n            };\n        }\n\n        this.lastMaskGenerationTime = Date.now();\n\n        const imageTensor = new ort.Tensor('float32', this.preprocess(input, this.lastMask.data), [\n            1,\n            this.config.mask.modelRank,\n            this.config.mask.inputSize.height,\n            this.config.mask.inputSize.width,\n        ]);\n\n        const results = await this.maskModel.run({ input: imageTensor });\n        this.lastMask = results.segmentation;\n\n        this.lastResult = {\n            data: this.lastMask.data ?? new Float32Array(0),\n            facesAndLandmarks: {\n                data: results.faces_and_landmarks?.data ?? new Float32Array(0),\n                dims: results.faces_and_landmarks?.dims ?? ([] as readonly number[]),\n            },\n            gesture: results.gesture?.data ?? new Float32Array(0),\n            motion: results.motion?.data[0] ?? 0,\n            timestamp,\n            warm: true,\n        };\n\n        return this.lastResult;\n    }\n\n    async load() {\n        const modelUrl = await sharedResourceManager.resolveUri(\n            this.config,\n            this.config.mask.modelUri\n        );\n\n        // Attempt to retrieve a preloaded InferenceSession from the shared resource manager.\n        this.maskModel = sharedResourceManager.getModelSession(modelUrl);\n        // If the model is not preloaded, load it from the provided model URL.\n        this.maskModel ??= await sharedResourceManager.loadModel(this.config);\n\n        if (!this.maskModel) {\n            throw new Error('Failed to load the ONNX model.');\n        }\n    }\n\n    public isLoaded(): boolean {\n        return !!this.maskModel;\n    }\n\n    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n    public async postRender(_: Uint8ClampedArray): Promise<void> {\n        // empty for local generator\n    }\n\n    public destroy(): void {\n        // empty for local generator\n    }\n}\n\nexport class NullGenerator implements MaskGenerator {\n    private lastMask: Float32Array;\n\n    constructor(public readonly config: PipelineConfig) {\n        this.lastMask = new Float32Array(\n            this.config.mask.outputSize.height * this.config.mask.outputSize.width\n        );\n    }\n\n    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n    public async getLadonOutput(_: Uint8ClampedArray): Promise<LadonOutput> {\n        return {\n            data: this.lastMask,\n            facesAndLandmarks: { data: new Float32Array(0), dims: [] },\n            gesture: new Float32Array(0),\n            motion: 0,\n            timestamp: 0,\n            warm: false,\n        };\n    }\n\n    public async load(): Promise<void> {\n        // empty for null generator\n    }\n\n    public isLoaded(): boolean {\n        return true;\n    }\n\n    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n    public async postRender(_: Uint8ClampedArray): Promise<void> {\n        // empty for null generator\n    }\n\n    public destroy(): void {\n        // empty for null generator\n    }\n}\n\nexport class WorkerGenerator implements MaskGenerator {\n    private lastMask: Float32Array;\n    private newMask = true;\n    private worker?: Worker;\n    private lastResult: LadonOutput;\n\n    constructor(public readonly config: PipelineConfig) {\n        this.lastMask = new Float32Array(\n            this.config.mask.outputSize.height * this.config.mask.outputSize.width\n        );\n        this.lastResult = {\n            data: this.lastMask,\n            facesAndLandmarks: { data: new Float32Array(0), dims: [] },\n            gesture: new Float32Array(0),\n            motion: 0,\n            timestamp: 0,\n            warm: false,\n        };\n    }\n\n    /* eslint-disable-next-line @typescript-eslint/no-unused-vars */\n    public async getLadonOutput(_: Uint8ClampedArray): Promise<LadonOutput> {\n        const toReturn = {\n            data: this.lastMask,\n            facesAndLandmarks: this.lastResult.facesAndLandmarks,\n            gesture: this.lastResult.gesture,\n            motion: this.lastResult.motion,\n            timestamp: this.lastResult.timestamp,\n            warm: this.newMask,\n        };\n\n        this.newMask = false;\n\n        return toReturn;\n    }\n\n    public async load(): Promise<void> {\n        // Prepare the worker configuration by resolving the final URLs and paths to send to the worker.\n        const config = await sharedResourceManager.prepareWorkerConfig(this.config);\n\n        this.worker = sharedResourceManager.getWorker();\n        this.worker ??= await sharedResourceManager.initializeWorker(config);\n\n        if (!this.worker) {\n            throw new Error('[ladon-ts] - worker is not defined.');\n        }\n\n        this.worker.onmessage = (event) => {\n            if (event.data.type === 'log') {\n                // Forward log messages from the worker to the console.\n                const { message, severity } = event.data;\n                const msg = `[ladon-ts] Message received from worker: ${message}`;\n                switch (severity) {\n                    case 'warn':\n                        console.warn(msg);\n                        break;\n                    case 'error':\n                        console.error(msg);\n                        break;\n                    default:\n                        console.log(msg);\n                }\n            } else if (event.data.status === 'generated') {\n                // Update the last mask and result with the new data from the worker.\n                this.lastMask = event.data.mask;\n                this.lastResult = {\n                    data: event.data.mask,\n                    facesAndLandmarks: event.data.facesAndLandmarks,\n                    gesture: event.data.gesture,\n                    motion: event.data.motion,\n                    timestamp: event.data.timestamp,\n                    warm: true,\n                };\n                this.newMask = true;\n            } else {\n                // Clean up the worker and revoke the URL when the worker is finished\n                const workerUrl = sharedResourceManager.getWorkerUrl();\n                if (workerUrl) {\n                    URL.revokeObjectURL(workerUrl);\n                }\n                resolutionCb?.();\n            }\n        };\n\n        const workerConfig: PipelineConfig = {\n            baseUrl: config.baseUrl,\n            input: config.input,\n            mask: config.mask,\n            wasmUri: config.wasmUri,\n            render: { type: 'passthrough' },\n        };\n\n        this.worker.postMessage({ type: 'init', config: workerConfig });\n\n        let resolutionCb: () => void;\n        const result = new Promise<void>((resolve) => {\n            resolutionCb = resolve;\n        });\n\n        return result;\n    }\n\n    public isLoaded(): boolean {\n        return !!this.worker;\n    }\n\n    public async postRender(input: Uint8ClampedArray, timestamp: number): Promise<void> {\n        // claim ownership of the input tensor's buffer and forward to worker\n\n        if (!this.worker) {\n            throw new Error('[ladon-ts] - worker is not defined.');\n        }\n\n        this.worker.postMessage(\n            {\n                type: 'generate',\n                image: input,\n                timestamp,\n            },\n            [input.buffer]\n        );\n    }\n\n    public destroy(): void {\n        sharedResourceManager.terminateWorker();\n    }\n}\n"],"names":["LocalGenerator","config","height","width","ort","input","alpha","model_rank","input_size","output_size","numImagePixels","numInputPixels","channel","pixel","widthScale","heightScale","x","nearestNeighborX","y","nearestNeighborY","maskIdx","outputIdx","normalizedValue","timestamp","imageTensor","results","_a","_b","_c","_d","modelUrl","sharedResourceManager","_","NullGenerator","WorkerGenerator","toReturn","event","message","severity","msg","workerUrl","resolutionCb","workerConfig","resolve"],"mappings":"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"}

package/build/module/lib/shared-resource-manager.d.ts

@@ -1,93 +0,0 @@
-import { PreloadConfig, ResolutionConfig, WorkerConfig } from './config-types';
-import * as ort from 'onnxruntime-web';
-/**
- * Shared resource manager used to preload and share resources across different pipelines.
- * This is useful when multiple pipelines are using the same model or when the model needs
- * to be preloaded before the pipeline is created.
- */
-declare class SharedResourceManager {
-    private modelSessions;
-    private worker?;
-    private workerUrl?;
-    private resolvedUriCache;
-    /**
-     * Initialize the worker using the provided configuration.
-     *
-     * @param config - The configuration object.
-     * @returns A promise that resolves when the worker is initialized.
-     */
-    initializeWorker(config: WorkerConfig): Promise<Worker>;
-    /**
-     * Terminate the worker.
-     */
-    terminateWorker(): void;
-    /**
-     * Load the model using the provided configuration. This gets called by the worker when using
-     * the worker generator.
-     *
-     * @param config - The configuration object.
-     * @returns A promise that resolves when the model is preloaded.
-     */
-    loadModel(config: PreloadConfig): Promise<ort.InferenceSession>;
-    /**
-     * Preload the worker using the provided configuration.
-     *
-     * @param config - The configuration object.
-     * @returns A promise that resolves when the worker is preloaded.
-     */
-    preloadWorker(config: PreloadConfig): Promise<void>;
-    /**
-     * Warmup the model session with a dummy input to avoid latency when running the model for the first time.
-     *
-     * @param {ort.InferenceSession} session The model session.
-     * @param {ResolutionConfig} inputSize The input size of the model.
-     * @param {number} inputChannels The number of input channels (e.g., RGB is 3).
-     * @param {ort.Tensor.Type} inputType The input tensor type.
-     * @returns {Promise<void>} A promise that resolves when the model is warmed up.
-     * @example
-     * await warmupModel(session, inputSize, inputChannels, inputType);
-     */
-    warmupModel(session: ort.InferenceSession, inputSize?: ResolutionConfig, inputChannels?: number, inputType?: ort.Tensor.Type): Promise<void>;
-    /**
-     * Get the model session for the provided model URL.
-     *
-     * @param {string} modelUrl The model URL.
-     * @returns {ort.InferenceSession} The model session.
-     * @example
-     * const session = getModelSession(modelUrl);
-     */
-    getModelSession(modelUrl: string): ort.InferenceSession;
-    /**
-     * Resolves the full URL for a given asset. Non-file URIs are treated as paths
-     * and resolved using the `toAbsoluteURI` method.
-     *
-     * @param config - The preload configuration.
-     * @param assetUri - The asset URI from the config.
-     * @returns The resolved full URL.
-     */
-    /**
-     * Resolves the full URL for a given asset. Non-file URIs are treated as paths and resolved
-     * using the `toAbsoluteURI` method. If the assetUri is already resolved, or if it's found in
-     * cache, it will be returned directly. If an assetUrlResolver function is provided in the
-     * configuration, it will be used to resolve the URL if the assetUri is not fully qualified,
-     * a blob URL, or in the cache.
-     *
-     * @param config - The preload configuration.
-     * @param assetUri - The asset URI from the config.
-     * @returns The resolved full URL.
-     */
-    resolveUri(config: PreloadConfig, assetUri?: string): Promise<string>;
-    getWorker(): Worker | undefined;
-    getWorkerUrl(): string | undefined;
-    /**
-     * Prepare the worker configuration by resolving the final URLs and paths to send to the
-     * worker. This is necessary because we can't send functions to the worker. We also need to
-     * remove the assetUrlResolver function from the configuration.
-     *
-     * @param config - The preload configuration.
-     * @returns The worker configuration.
-     */
-    prepareWorkerConfig(config: PreloadConfig): Promise<any>;
-}
-export declare const sharedResourceManager: SharedResourceManager;
-export {};