@authme/engine 2.1.1

package/assets/engine-worker.js

@@ -0,0 +1,642 @@
+(function () {
+  // Common func
+  let wasm_loaded = false;
+  let wasm_loading = false;
+
+  let modelSession = {};
+
+  function isSimdSupported() {
+    try {
+      // Test for WebAssembly SIMD capability (for both browsers and Node.js)
+      // This typed array is a WebAssembly program containing SIMD instructions.
+      return WebAssembly.validate(
+        new Uint8Array([
+          0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1,
+          7, 0, 65, 0, 253, 15, 26, 11,
+        ])
+      );
+    } catch (e) {
+      return false;
+    }
+  }
+
+  function base64toBlob(data) {
+    const byteChars = self.atob(data);
+    const byteNumbers = new Array(byteChars.length);
+    for (let i = 0; i < byteChars.length; i++) {
+      byteNumbers[i] = byteChars.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    return new Blob([byteArray], { type: 'application/octet-stream' });
+  }
+
+  async function fetchModel(code) {
+    const method = self.config.dataTransferMethod || 'binary';
+
+    const resp = await fetch(
+      `${self.config.apiBaseUrl}/api/model-management/v1/model/${code}${
+        method === 'binary' ? '/file' : ''
+      }`,
+      {
+        headers: {
+          Authorization: 'Bearer ' + self.config.token,
+        },
+      }
+    );
+
+    if (method === 'binary') {
+      return resp.blob();
+    } else {
+      const data = await resp.json();
+      return base64toBlob(data.data);
+    }
+  }
+
+  async function loadWasm() {
+    return new Promise((res, rej) => {
+      // console.log('load wasm');
+      if (wasm_loaded || wasm_loading) {
+        res(true);
+      } else {
+        wasm_loading = true;
+        self['Module'] = {};
+        self['Module'] = {
+          locateFile: (path, scriptDirectory) => `${scriptDirectory}/${path}`,
+          print: (msg) => {
+            postMessage({
+              module: 'DEBUG',
+              command: 'DEBUG',
+              id: null,
+              value: msg,
+            });
+          },
+        };
+        self.importScripts(
+          isSimdSupported()
+            ? `${self.config.scriptPath}ml_engine_web.simd.js`
+            : `${self.config.scriptPath}ml_engine_web.js`
+        );
+        let tryInitEngineLib = async () => {
+          try {
+            const module = await AuthmeMLEngineLib({
+              print: (msg) => {
+                console.log(msg);
+                postMessage({
+                  module: 'DEBUG',
+                  command: 'DEBUG',
+                  id: null,
+                  value: msg,
+                });
+              },
+            });
+            self.EngineLib = module;
+            module.FS.mkdir('/model');
+            wasm_loaded = true;
+            wasm_loading = false;
+            // console.log('load wasm finished');
+            res(true);
+          } catch (error) {
+            console.warn(
+              'init Authme EngineLib error:',
+              error,
+              ' Try after 1 second.'
+            );
+            await waitTime(500);
+            await tryInitEngineLib();
+          }
+        };
+        tryInitEngineLib();
+      }
+    });
+  }
+
+  // MRZ
+  self.MRZ = {
+    instance: null,
+    init: async function () {
+      return await self.Base.init(self.MRZ, 'MRZ');
+    },
+    start: function () {
+      return self.Base.start(self.MRZ);
+    },
+    stop: function () {
+      return self.Base.stop(self.MRZ);
+    },
+    getJsonReport: function () {
+      return self.Base.getJsonReport(self.MRZ);
+    },
+    setFrameSize: function (params) {
+      return self.Base.setFrameSize(self.MRZ, params);
+    },
+    recognition: function (params) {
+      const result = self.Base.recognition(self.MRZ, params);
+      if (result) {
+        result.eStatus = result.eStatus.constructor.name;
+        result.tField = Object.entries(result.tField)
+          .map(([k, v]) => [
+            k,
+            v
+              .map((x) => String.fromCharCode(x))
+              .filter((x) => x !== '\x00')
+              .join(''),
+          ])
+          .reduce((prev, cur) => {
+            prev[cur[0]] = cur[1];
+            return prev;
+          }, {});
+      }
+      return result;
+    },
+    getParams: function () {
+      return self.Base.getParams(self.MRZ);
+    },
+    setParams: function (params) {
+      return self.Base.setParams(self.MRZ, params);
+    },
+    getDebugImage: function (params) {
+      return self.Base.getDebugImage(self.MRZ, params);
+    },
+    destroy: function () {
+      return self.Base.destroy(self.MRZ);
+    },
+  };
+
+  // Card OCR
+  self.CardOCR = {
+    instance: null,
+    init: async function () {
+      let result = await self.Base.init(self.CardOCR, 'CardOCR');
+      return result;
+    },
+    start: function () {
+      return self.Base.start(self.CardOCR);
+    },
+    stop: function () {
+      return self.Base.stop(self.CardOCR);
+    },
+    getJsonReport: function () {
+      return self.Base.getJsonReport(self.CardOCR);
+    },
+    setFrameSize: function (params) {
+      return self.Base.setFrameSize(self.CardOCR, params);
+    },
+    recognition: function (params) {
+      const result = self.Base.recognition(self.CardOCR, params);
+      if (result) {
+        if (result.pointer > 0) {
+          result.imageData = self.EngineLib.HEAPU8.slice(
+            result.pointer,
+            result.pointer + result.iHeight * result.iWidth * 4
+          );
+          self.EngineLib._free(result.pointer);
+        }
+        result.eStatus = result.eStatus.constructor.name;
+        result.info.cardClass.eClass =
+          result.info.cardClass.eClass.constructor.name;
+      }
+      return result;
+    },
+    getDebugImage: function (params) {
+      return self.Base.getDebugImage(self.CardOCR, params);
+    },
+    setType: function (params) {
+      const engine = self.CardOCR.instance;
+      if (engine) {
+        const engineParams = engine.getParams();
+        engineParams.eTargetCardType =
+          self.EngineLib.EAuthMeCardClass.values[params.type];
+        engineParams.fImageBlurTh = 750;
+        engine.setParams(engineParams);
+        return true;
+      }
+      return false;
+    },
+    setMaskPosition: function (params) {
+      const positions = params.positions;
+      return self.CardOCR.instance?.setCardMatchROI(
+        positions[0][0],
+        positions[0][1],
+        positions[1][0],
+        positions[1][1],
+        positions[2][0],
+        positions[2][1],
+        positions[3][0],
+        positions[3][1]
+      );
+    },
+    getParams: function () {
+      return self.Base.getParams(self.CardOCR);
+    },
+    setParams: function (params) {
+      return self.Base.setParams(self.CardOCR, params);
+    },
+    destroy: function () {
+      return self.Base.destroy(self.CardOCR);
+    },
+  };
+
+  // Id Card Anti Fraud
+  self.IdCardAntiFraud = {
+    instance: null,
+    init: async function () {
+      await self.Base.init(self.IdCardAntiFraud, 'IdCardAntiFraudService');
+      if (self.IdCardAntiFraud.instance) {
+        const engine = self.IdCardAntiFraud.instance;
+        const engineParams = engine.getParams();
+        engineParams.timeoutSec = 52;
+        engine.setParams(engineParams);
+        return true;
+      }
+    },
+    start: function () {
+      return self.Base.start(self.IdCardAntiFraud);
+    },
+    stop: function () {
+      return self.Base.stop(self.IdCardAntiFraud);
+    },
+    getJsonReport: function () {
+      return self.Base.getJsonReport(self.IdCardAntiFraud);
+    },
+    setFrameSize: function (params) {
+      return self.Base.setFrameSize(self.IdCardAntiFraud, params);
+    },
+    recognition: function (params) {
+      const result = self.Base.recognition(self.IdCardAntiFraud, params);
+      if (result) {
+        result.eStatus = result.eStatus.constructor.name;
+        result.eStage = result.eStage.constructor.name;
+        result.info.eCardMatchStatus =
+          result.info.eCardMatchStatus.constructor.name;
+        result.info.cardClass.eClass =
+          result.info.cardClass.eClass.constructor.name;
+        result.info.laserTag.eStatus =
+          result.info.laserTag.eStatus.constructor.name;
+        result.info.metalTag.aeStatus = result.info.metalTag.aeStatus.map(
+          (x) => x.constructor.name
+        );
+        result.info.taiwanHole.eStatus =
+          result.info.taiwanHole.eStatus.constructor.name;
+      }
+      return result;
+    },
+    setMaskPosition: function (params) {
+      const positions = params.positions;
+      return self.IdCardAntiFraud.instance?.setFrontalCardVertices(
+        positions[0][0],
+        positions[0][1],
+        positions[1][0],
+        positions[1][1],
+        positions[2][0],
+        positions[2][1],
+        positions[3][0],
+        positions[3][1]
+      );
+    },
+    setStage: function (params) {
+      if (self.IdCardAntiFraud.instance) {
+        const stageList = new self.EngineLib.FraudStageList();
+        params.forEach((x) => {
+          stageList.push_back(self.EngineLib.EAuthMeIDCardAntiFraudStage[x]);
+        });
+        self.IdCardAntiFraud.instance.setStage(stageList);
+      }
+    },
+    getParams: function () {
+      return self.Base.getParams(self.IdCardAntiFraud);
+    },
+    setParams: function (params) {
+      return self.Base.setParams(self.IdCardAntiFraud, params);
+    },
+    getDebugImage: function (params) {
+      return self.Base.getDebugImage(self.IdCardAntiFraud, params);
+    },
+    destroy: function () {
+      return self.Base.destroy(self.IdCardAntiFraud);
+    },
+  };
+
+  self.Fas = {
+    instance: null,
+    init: async function () {
+      await self.Base.init(self.Fas, 'CFASService');
+    },
+    start: function () {
+      return self.Base.start(self.Fas);
+    },
+    stop: function () {
+      return self.Base.stop(self.Fas);
+    },
+    getJsonReport: function () {
+      return self.Base.getJsonReport(self.Fas);
+    },
+    setFrameSize: function (params) {
+      self.Base.setFrameSize(self.Fas, params);
+      if (config.frame.width / config.frame.height >= 1) {
+        const params = self.Fas.instance.getParams();
+        params.fFaceRoiPreviewRatioW = 0.3;
+        self.Fas.instance.setParams(params);
+      }
+    },
+    setStage: function (params) {
+      if (self.Fas.instance) {
+        const stageList = new self.EngineLib.FASStageList();
+        params.stageList.forEach((x) => {
+          stageList.push_back(self.EngineLib.EAuthMeFASServiceStage[x]);
+        });
+        self.Fas.instance.setStage(stageList);
+      }
+    },
+    recognition: function (params) {
+      const result = self.Base.recognition(self.Fas, params);
+      if (result) {
+        result.eStatus = result.eStatus.constructor.name;
+        result.eStage = result.eStage.constructor.name;
+        result.info.eye.eStatus = result.info.eye.eStatus.constructor.name;
+        result.info.fas.eStatus = result.info.fas.eStatus.constructor.name;
+        result.info.mouth.eStatus = result.info.mouth.eStatus.constructor.name;
+        result.info.pose.ePose = result.info.pose.ePose.constructor.name;
+        result.info.miniFAS = result.info.miniFAS.constructor.name;
+      }
+      return result;
+    },
+    getParams: function () {
+      return self.Base.getParams(self.Fas);
+    },
+    setParams: function (params) {
+      return self.Base.setParams(self.Fas, params);
+    },
+    getDebugImage: function (params) {
+      return self.Base.getDebugImage(self.Fas, params);
+    },
+    destroy: function () {
+      return self.Base.destroy(self.Fas);
+    },
+  };
+
+  // Base
+  self.Base = {
+    init: async function (target, constructorName) {
+      return new Promise((res, rej) => {
+        try {
+          setTimeout(async () => {
+            const models = [];
+            const versionVector =
+              self.EngineLib[constructorName]['getModelVersion']();
+            target.sessionUsed = [];
+            for (let i = 0; i < versionVector.size(); i++) {
+              let item = versionVector.get(i);
+              target.sessionUsed.push(item.szName);
+              models.push({
+                name: item.szName,
+                version: item.szVersion,
+              });
+            }
+
+            let queryModelString = models
+              .map((x) => 'models=' + x.name + '[' + x.version + ']')
+              .join('&');
+
+            let modelPath = await loadModels(queryModelString);
+            let modelPointer = models.map(({ name }, index) => {
+              if (modelSession[name]) {
+                return modelSession[name];
+              } else {
+                modelSession[name] = self.EngineLib.createInferenceSession(
+                  name,
+                  modelPath[index]
+                );
+                return modelSession[name];
+              }
+            });
+            const instance = new self.EngineLib[constructorName]();
+            instance.initial(...modelPointer);
+            const engine = instance;
+            const uiParams = engine.getUIParams();
+            uiParams.previewPosition.fLeft = 0;
+            uiParams.previewPosition.fTop = 0;
+            uiParams.previewPosition.fRight = 1;
+            uiParams.previewPosition.fBottom = 1;
+            engine.setUIParams(uiParams);
+            target.instance = instance;
+            res(true);
+          }, 10);
+        } catch (error) {
+          rej(error.message);
+        }
+      });
+    },
+    start: function (target) {
+      return target?.instance?.start();
+    },
+    stop: function (target) {
+      return target?.instance?.stop();
+    },
+    setFrameSize: function (target, params) {
+      config.frame.width = Math.floor(params.width);
+      config.frame.height = Math.floor(params.height);
+      if (target.instance) {
+        const engine = target.instance;
+        const uiParams = engine.getUIParams();
+        uiParams.analyzeSize.iHeight = config.frame.height;
+        uiParams.analyzeSize.iWidth = config.frame.width;
+        engine.setUIParams(uiParams);
+        return true;
+      }
+    },
+    recognition: function (target, params) {
+      const engine = target.instance;
+      if (engine) {
+        try {
+          const data = params.data;
+          const heapInfo = putOnHeap(data);
+          const result = engine.run(
+            heapInfo.byteOffset,
+            heapInfo.length,
+            config.frame.width,
+            config.frame.height
+          );
+          self.EngineLib._free(heapInfo.dataPtr);
+          return result;
+        } catch (error) {
+          // console.warn(error);
+          // console.warn('[Recognition Error]: ' + error?.message);
+          return null;
+        }
+      }
+      console.warn('engine not initialized');
+    },
+    getParams: function (target) {
+      return target.instance.getParams();
+    },
+    setParams: function (target, params) {
+      return target.instance.setParams(params.params);
+    },
+    getDebugImage: function (target, params) {
+      const data = params.data;
+      const heapInfo = putOnHeap(data);
+      let imageData;
+      const pointer = target.instance.getDebugImage(
+        heapInfo.byteOffset,
+        heapInfo.length,
+        config.frame.width,
+        config.frame.height
+      );
+      self.EngineLib._free(heapInfo.dataPtr);
+      if (pointer) {
+        imageData = self.EngineLib.HEAPU8.slice(
+          pointer,
+          pointer + config.frame.width * config.frame.height * 4
+        );
+        self.EngineLib._free(pointer);
+      }
+      return imageData;
+    },
+    destroy: function (target) {
+      if (target.instance) {
+        target.instance.delete();
+        target.instance = null;
+      }
+      if (target.sessionUsed) {
+        target.sessionUsed.forEach((name) => {
+          if (modelSession[name]) {
+            self.EngineLib.deleteSession(modelSession[name]);
+            modelSession[name] = null;
+          }
+        });
+        target.sessionUsed = [];
+      }
+    },
+    getJsonReport: function (target) {
+      return target?.instance?.getJsonReport();
+    },
+  };
+
+  self.Core = {
+    setConfig: async function (config) {
+      self.config = {
+        ...self.config,
+        ...config,
+      };
+      return true;
+    },
+    loadEngine: async function () {
+      return await loadWasm();
+    },
+    verify: async function (params) {
+      for (let index = 0; index < 20; index++) {
+        if (self.EngineLib) {
+          let result = self.EngineLib.verifySDK(params.cert, params.authToken);
+          return result.constructor.name;
+        }
+        await waitTime(500);
+      }
+      return false;
+    },
+  };
+
+  addEventListener(
+    'message',
+    async function ({ data }) {
+      const { module, command, id, value } = data;
+      const fn = self[module][command];
+      if (fn) {
+        // console.log(`call ${module}.${command} :`, value);
+        const result = await fn(value);
+        // console.log(`worker return value for ${command}:`, result);
+        postMessage({
+          module,
+          command,
+          id,
+          value: result,
+        });
+      }
+    }.bind(self)
+  );
+
+  let config = {
+    scriptPath: 'assets',
+    apiBaseUrl: '/',
+    frame: {
+      width: 0,
+      height: 0,
+    },
+  };
+
+  async function loadModel(modelInfo) {
+    const { name, code } = modelInfo;
+    const modelData = await fetchModel(code);
+    console.log(modelData);
+    try {
+      const FS = self.EngineLib.FS;
+      FS.mkdir(name);
+      FS.mount(
+        FS.filesystems.WORKERFS,
+        {
+          blobs: [
+            {
+              name,
+              data: modelData,
+            },
+          ],
+        },
+        '/' + name
+      );
+    } catch (error) {
+      if (error?.errno === 20) {
+        // File Exist
+        return `/${name}/${name}`;
+      } else {
+        throw error;
+      }
+    }
+
+    return `/${name}/${name}`;
+  }
+
+  async function loadModels(modelString) {
+    const start = performance.now();
+    const resp = await fetch(
+      self.config.apiBaseUrl + '/api/model-management/v1/model?' + modelString,
+      {
+        headers: {
+          Authorization: 'Bearer ' + self.config.token,
+        },
+      }
+    );
+    if (!resp.ok) {
+      throw new Error('[HTTP Error] Status: ' + resp.status);
+    }
+    const result = await resp.json();
+    const modelPath = [];
+    for (let i = 0; i < result.models.length; i++) {
+      modelPath.push(await loadModel(result.models[i]));
+    }
+    const end = performance.now();
+    // console.log('Load Model Time: ', +end - start + ' ms');
+    return modelPath;
+  }
+
+  function putOnHeap(data) {
+    const Module = self.EngineLib;
+    const uint8ArrData = new Uint8Array(data);
+    const numBytes = uint8ArrData.length * uint8ArrData.BYTES_PER_ELEMENT;
+    const dataPtr = Module._malloc(numBytes);
+    const dataOnHeap = new Uint8Array(Module.HEAPU8.buffer, dataPtr, numBytes);
+    dataOnHeap.set(uint8ArrData);
+    return {
+      byteOffset: dataOnHeap.byteOffset,
+      length: uint8ArrData.length,
+      dataPtr: dataPtr,
+      dataOnHeap: dataOnHeap,
+      Module: Module,
+    };
+  }
+
+  async function waitTime(ms) {
+    return new Promise((res) => {
+      setTimeout(() => {
+        res(true);
+      }, ms);
+    });
+  }
+})();