Spaces:
Running
Running
| let wasm; | |
| const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } ); | |
| if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }; | |
| let cachedUint8Memory0 = null; | |
| function getUint8Memory0() { | |
| if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) { | |
| cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); | |
| } | |
| return cachedUint8Memory0; | |
| } | |
| function getStringFromWasm0(ptr, len) { | |
| ptr = ptr >>> 0; | |
| return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); | |
| } | |
| const heap = new Array(128).fill(undefined); | |
| heap.push(undefined, null, true, false); | |
| let heap_next = heap.length; | |
| function addHeapObject(obj) { | |
| if (heap_next === heap.length) heap.push(heap.length + 1); | |
| const idx = heap_next; | |
| heap_next = heap[idx]; | |
| heap[idx] = obj; | |
| return idx; | |
| } | |
| let WASM_VECTOR_LEN = 0; | |
| function passArray8ToWasm0(arg, malloc) { | |
| const ptr = malloc(arg.length * 1, 1) >>> 0; | |
| getUint8Memory0().set(arg, ptr / 1); | |
| WASM_VECTOR_LEN = arg.length; | |
| return ptr; | |
| } | |
| const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } ); | |
| const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' | |
| ? function (arg, view) { | |
| return cachedTextEncoder.encodeInto(arg, view); | |
| } | |
| : function (arg, view) { | |
| const buf = cachedTextEncoder.encode(arg); | |
| view.set(buf); | |
| return { | |
| read: arg.length, | |
| written: buf.length | |
| }; | |
| }); | |
| function passStringToWasm0(arg, malloc, realloc) { | |
| if (realloc === undefined) { | |
| const buf = cachedTextEncoder.encode(arg); | |
| const ptr = malloc(buf.length, 1) >>> 0; | |
| getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf); | |
| WASM_VECTOR_LEN = buf.length; | |
| return ptr; | |
| } | |
| let len = arg.length; | |
| let ptr = malloc(len, 1) >>> 0; | |
| const mem = getUint8Memory0(); | |
| let offset = 0; | |
| for (; offset < len; offset++) { | |
| const code = arg.charCodeAt(offset); | |
| if (code > 0x7F) break; | |
| mem[ptr + offset] = code; | |
| } | |
| if (offset !== len) { | |
| if (offset !== 0) { | |
| arg = arg.slice(offset); | |
| } | |
| ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; | |
| const view = getUint8Memory0().subarray(ptr + offset, ptr + len); | |
| const ret = encodeString(arg, view); | |
| offset += ret.written; | |
| } | |
| WASM_VECTOR_LEN = offset; | |
| return ptr; | |
| } | |
| let cachedInt32Memory0 = null; | |
| function getInt32Memory0() { | |
| if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) { | |
| cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); | |
| } | |
| return cachedInt32Memory0; | |
| } | |
| function getObject(idx) { return heap[idx]; } | |
| function dropObject(idx) { | |
| if (idx < 132) return; | |
| heap[idx] = heap_next; | |
| heap_next = idx; | |
| } | |
| function takeObject(idx) { | |
| const ret = getObject(idx); | |
| dropObject(idx); | |
| return ret; | |
| } | |
| /** | |
| */ | |
| export class Model { | |
| static __wrap(ptr) { | |
| ptr = ptr >>> 0; | |
| const obj = Object.create(Model.prototype); | |
| obj.__wbg_ptr = ptr; | |
| return obj; | |
| } | |
| __destroy_into_raw() { | |
| const ptr = this.__wbg_ptr; | |
| this.__wbg_ptr = 0; | |
| return ptr; | |
| } | |
| free() { | |
| const ptr = this.__destroy_into_raw(); | |
| wasm.__wbg_model_free(ptr); | |
| } | |
| /** | |
| * @param {Uint8Array} data | |
| * @param {string} model_size | |
| */ | |
| constructor(data, model_size) { | |
| try { | |
| const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); | |
| const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc); | |
| const len0 = WASM_VECTOR_LEN; | |
| const ptr1 = passStringToWasm0(model_size, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); | |
| const len1 = WASM_VECTOR_LEN; | |
| wasm.model_new(retptr, ptr0, len0, ptr1, len1); | |
| var r0 = getInt32Memory0()[retptr / 4 + 0]; | |
| var r1 = getInt32Memory0()[retptr / 4 + 1]; | |
| var r2 = getInt32Memory0()[retptr / 4 + 2]; | |
| if (r2) { | |
| throw takeObject(r1); | |
| } | |
| return Model.__wrap(r0); | |
| } finally { | |
| wasm.__wbindgen_add_to_stack_pointer(16); | |
| } | |
| } | |
| /** | |
| * @param {Uint8Array} image | |
| * @param {number} conf_threshold | |
| * @param {number} iou_threshold | |
| * @returns {string} | |
| */ | |
| run(image, conf_threshold, iou_threshold) { | |
| let deferred3_0; | |
| let deferred3_1; | |
| try { | |
| const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); | |
| const ptr0 = passArray8ToWasm0(image, wasm.__wbindgen_malloc); | |
| const len0 = WASM_VECTOR_LEN; | |
| wasm.model_run(retptr, this.__wbg_ptr, ptr0, len0, conf_threshold, iou_threshold); | |
| var r0 = getInt32Memory0()[retptr / 4 + 0]; | |
| var r1 = getInt32Memory0()[retptr / 4 + 1]; | |
| var r2 = getInt32Memory0()[retptr / 4 + 2]; | |
| var r3 = getInt32Memory0()[retptr / 4 + 3]; | |
| var ptr2 = r0; | |
| var len2 = r1; | |
| if (r3) { | |
| ptr2 = 0; len2 = 0; | |
| throw takeObject(r2); | |
| } | |
| deferred3_0 = ptr2; | |
| deferred3_1 = len2; | |
| return getStringFromWasm0(ptr2, len2); | |
| } finally { | |
| wasm.__wbindgen_add_to_stack_pointer(16); | |
| wasm.__wbindgen_free(deferred3_0, deferred3_1, 1); | |
| } | |
| } | |
| } | |
| /** | |
| */ | |
| export class ModelPose { | |
| static __wrap(ptr) { | |
| ptr = ptr >>> 0; | |
| const obj = Object.create(ModelPose.prototype); | |
| obj.__wbg_ptr = ptr; | |
| return obj; | |
| } | |
| __destroy_into_raw() { | |
| const ptr = this.__wbg_ptr; | |
| this.__wbg_ptr = 0; | |
| return ptr; | |
| } | |
| free() { | |
| const ptr = this.__destroy_into_raw(); | |
| wasm.__wbg_modelpose_free(ptr); | |
| } | |
| /** | |
| * @param {Uint8Array} data | |
| * @param {string} model_size | |
| */ | |
| constructor(data, model_size) { | |
| try { | |
| const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); | |
| const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc); | |
| const len0 = WASM_VECTOR_LEN; | |
| const ptr1 = passStringToWasm0(model_size, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); | |
| const len1 = WASM_VECTOR_LEN; | |
| wasm.modelpose_new(retptr, ptr0, len0, ptr1, len1); | |
| var r0 = getInt32Memory0()[retptr / 4 + 0]; | |
| var r1 = getInt32Memory0()[retptr / 4 + 1]; | |
| var r2 = getInt32Memory0()[retptr / 4 + 2]; | |
| if (r2) { | |
| throw takeObject(r1); | |
| } | |
| return ModelPose.__wrap(r0); | |
| } finally { | |
| wasm.__wbindgen_add_to_stack_pointer(16); | |
| } | |
| } | |
| /** | |
| * @param {Uint8Array} image | |
| * @param {number} conf_threshold | |
| * @param {number} iou_threshold | |
| * @returns {string} | |
| */ | |
| run(image, conf_threshold, iou_threshold) { | |
| let deferred3_0; | |
| let deferred3_1; | |
| try { | |
| const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); | |
| const ptr0 = passArray8ToWasm0(image, wasm.__wbindgen_malloc); | |
| const len0 = WASM_VECTOR_LEN; | |
| wasm.modelpose_run(retptr, this.__wbg_ptr, ptr0, len0, conf_threshold, iou_threshold); | |
| var r0 = getInt32Memory0()[retptr / 4 + 0]; | |
| var r1 = getInt32Memory0()[retptr / 4 + 1]; | |
| var r2 = getInt32Memory0()[retptr / 4 + 2]; | |
| var r3 = getInt32Memory0()[retptr / 4 + 3]; | |
| var ptr2 = r0; | |
| var len2 = r1; | |
| if (r3) { | |
| ptr2 = 0; len2 = 0; | |
| throw takeObject(r2); | |
| } | |
| deferred3_0 = ptr2; | |
| deferred3_1 = len2; | |
| return getStringFromWasm0(ptr2, len2); | |
| } finally { | |
| wasm.__wbindgen_add_to_stack_pointer(16); | |
| wasm.__wbindgen_free(deferred3_0, deferred3_1, 1); | |
| } | |
| } | |
| } | |
| async function __wbg_load(module, imports) { | |
| if (typeof Response === 'function' && module instanceof Response) { | |
| if (typeof WebAssembly.instantiateStreaming === 'function') { | |
| try { | |
| return await WebAssembly.instantiateStreaming(module, imports); | |
| } catch (e) { | |
| if (module.headers.get('Content-Type') != 'application/wasm') { | |
| console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e); | |
| } else { | |
| throw e; | |
| } | |
| } | |
| } | |
| const bytes = await module.arrayBuffer(); | |
| return await WebAssembly.instantiate(bytes, imports); | |
| } else { | |
| const instance = await WebAssembly.instantiate(module, imports); | |
| if (instance instanceof WebAssembly.Instance) { | |
| return { instance, module }; | |
| } else { | |
| return instance; | |
| } | |
| } | |
| } | |
| function __wbg_get_imports() { | |
| const imports = {}; | |
| imports.wbg = {}; | |
| imports.wbg.__wbindgen_error_new = function(arg0, arg1) { | |
| const ret = new Error(getStringFromWasm0(arg0, arg1)); | |
| return addHeapObject(ret); | |
| }; | |
| imports.wbg.__wbg_log_598ccd735a33342c = function(arg0, arg1) { | |
| console.log(getStringFromWasm0(arg0, arg1)); | |
| }; | |
| imports.wbg.__wbindgen_throw = function(arg0, arg1) { | |
| throw new Error(getStringFromWasm0(arg0, arg1)); | |
| }; | |
| return imports; | |
| } | |
| function __wbg_init_memory(imports, maybe_memory) { | |
| } | |
| function __wbg_finalize_init(instance, module) { | |
| wasm = instance.exports; | |
| __wbg_init.__wbindgen_wasm_module = module; | |
| cachedInt32Memory0 = null; | |
| cachedUint8Memory0 = null; | |
| wasm.__wbindgen_start(); | |
| return wasm; | |
| } | |
| function initSync(module) { | |
| if (wasm !== undefined) return wasm; | |
| const imports = __wbg_get_imports(); | |
| __wbg_init_memory(imports); | |
| if (!(module instanceof WebAssembly.Module)) { | |
| module = new WebAssembly.Module(module); | |
| } | |
| const instance = new WebAssembly.Instance(module, imports); | |
| return __wbg_finalize_init(instance, module); | |
| } | |
| async function __wbg_init(input) { | |
| if (wasm !== undefined) return wasm; | |
| if (typeof input === 'undefined') { | |
| input = new URL('m_bg.wasm', import.meta.url); | |
| } | |
| const imports = __wbg_get_imports(); | |
| if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) { | |
| input = fetch(input); | |
| } | |
| __wbg_init_memory(imports); | |
| const { instance, module } = await __wbg_load(await input, imports); | |
| return __wbg_finalize_init(instance, module); | |
| } | |
| export { initSync } | |
| export default __wbg_init; | |