@scu-xiaochuan/scu-captcha-script 0.0.1 → 0.0.2

package/dist/script.user.js

@@ -0,0 +1,314 @@
+// ==UserScript==
+// @name         四川大学本科教务系统验证码识别
+// @namespace    https://github.com/2239559319
+// @version      0.1
+// @description  四川大学本科教务系统验证码识别
+// @author       Xiao Chuan
+// @match http://zhjw.scu.edu.cn/login
+// @grant        none
+// ==/UserScript==
+(() => {
+  // ../utils/src/const.js
+  var MODEL_URL = "https://hf-mirror.net/xiaochuan-dev/scu-captcha/resolve/main/model.onnx";
+  var CHARSET = "2345678abcdefgmnpwxy";
+  var IMG_H = 32;
+  var IMG_W = 128;
+  var BLANK_IDX = 0;
+
+  // ../utils/src/img.js
+  function sinc(x) {
+    if (Math.abs(x) < 1e-12) {
+      return 1;
+    }
+    const p = Math.PI * x;
+    return Math.sin(p) / p;
+  }
+  function lanczos(x, a = 3) {
+    x = Math.abs(x);
+    if (x >= a) {
+      return 0;
+    }
+    if (x < 1e-12) {
+      return 1;
+    }
+    return sinc(x) * sinc(x / a);
+  }
+  function lanczosSample(gray, width, height, x, y) {
+    const a = 3;
+    let sum = 0;
+    let weightSum = 0;
+    const xStart = Math.floor(x) - a + 1;
+    const xEnd = Math.floor(x) + a;
+    const yStart = Math.floor(y) - a + 1;
+    const yEnd = Math.floor(y) + a;
+    for (let iy = yStart; iy <= yEnd; iy++) {
+      if (iy < 0 || iy >= height) {
+        continue;
+      }
+      const wy = lanczos(
+        y - iy,
+        a
+      );
+      for (let ix = xStart; ix <= xEnd; ix++) {
+        if (ix < 0 || ix >= width) {
+          continue;
+        }
+        const wx = lanczos(
+          x - ix,
+          a
+        );
+        const weight = wx * wy;
+        sum += gray[iy * width + ix] * weight;
+        weightSum += weight;
+      }
+    }
+    if (Math.abs(weightSum) < 1e-12) {
+      return 255;
+    }
+    const value = sum / weightSum;
+    return Math.max(
+      0,
+      Math.min(
+        255,
+        value
+      )
+    );
+  }
+  function preprocessImage(img) {
+    const sourceCanvas = document.createElement("canvas");
+    sourceCanvas.width = img.naturalWidth;
+    sourceCanvas.height = img.naturalHeight;
+    const sourceCtx = sourceCanvas.getContext("2d");
+    sourceCtx.drawImage(img, 0, 0);
+    const imageData = sourceCtx.getImageData(0, 0, img.naturalWidth, img.naturalHeight);
+    const width = img.naturalWidth;
+    const height = img.naturalHeight;
+    const gray = new Uint8Array(width * height);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const idx = (y * width + x) * 4;
+        const r = imageData.data[idx];
+        const g = imageData.data[idx + 1];
+        const b = imageData.data[idx + 2];
+        const value = 0.299 * r + 0.587 * g + 0.114 * b;
+        gray[y * width + x] = Math.round(value);
+      }
+    }
+    const scale = Math.min(IMG_W / width, IMG_H / height);
+    const newW = Math.max(1, Math.round(width * scale));
+    const newH = Math.max(1, Math.round(height * scale));
+    const output = new Float32Array(IMG_W * IMG_H);
+    output.fill(1);
+    for (let dy = 0; dy < newH; dy++) {
+      for (let dx = 0; dx < newW; dx++) {
+        const srcX = (dx + 0.5) / scale - 0.5;
+        const srcY = (dy + 0.5) / scale - 0.5;
+        const value = lanczosSample(gray, width, height, srcX, srcY);
+        const offsetX = Math.floor((IMG_W - newW) / 2);
+        const offsetY = Math.floor((IMG_H - newH) / 2);
+        const dstX = offsetX + dx;
+        const dstY = offsetY + dy;
+        if (dstX >= 0 && dstX < IMG_W && dstY >= 0 && dstY < IMG_H) {
+          output[dstY * IMG_W + dstX] = value / 255;
+        }
+      }
+    }
+    return output;
+  }
+
+  // ../utils/src/model.js
+  function ctcDecode(logits, T, numClasses, blankIdx = 0) {
+    let prev = blankIdx;
+    const chars = [];
+    for (let t = 0; t < T; t++) {
+      let maxIdx = 0;
+      let maxVal = -Infinity;
+      for (let c = 0; c < numClasses; c++) {
+        const val = logits[t * numClasses + c];
+        if (val > maxVal) {
+          maxVal = val;
+          maxIdx = c;
+        }
+      }
+      const p = maxIdx;
+      if (p !== prev && p !== blankIdx) {
+        const charIdx = p - 1;
+        if (charIdx >= 0 && charIdx < CHARSET.length) {
+          chars.push(CHARSET[charIdx]);
+        }
+      }
+      prev = p;
+    }
+    return chars.join("");
+  }
+  function getPredictionDetails(logits, T, numClasses) {
+    const details = [];
+    for (let t = 0; t < T; t++) {
+      let maxIdx = 0;
+      let maxVal = -Infinity;
+      for (let c = 0; c < numClasses; c++) {
+        const value = logits[t * numClasses + c];
+        if (value > maxVal) {
+          maxVal = value;
+          maxIdx = c;
+        }
+      }
+      let label;
+      if (maxIdx === BLANK_IDX) {
+        label = "<blank>";
+      } else {
+        const charIdx = maxIdx - 1;
+        if (charIdx >= 0 && charIdx < CHARSET.length) {
+          label = CHARSET[charIdx];
+        } else {
+          label = `<class:${maxIdx}>`;
+        }
+      }
+      details.push({
+        t,
+        classIndex: maxIdx,
+        label,
+        logit: maxVal
+      });
+    }
+    return details;
+  }
+  async function recognize(session, currentImage) {
+    try {
+      const inputData = preprocessImage(currentImage);
+      const inputTensor = new ort.Tensor("float32", inputData, [1, 1, IMG_H, IMG_W]);
+      const results = await session.run({ input: inputTensor });
+      const outputTensor = results.output;
+      const dims = outputTensor.dims;
+      const batchSize = dims[0];
+      const T = dims[1];
+      const numClasses = dims[2];
+      const logits = outputTensor.data;
+      if (batchSize !== 1) {
+        throw new Error(`Unexpected batch size: ${batchSize}`);
+      }
+      const prediction = ctcDecode(logits, T, numClasses, BLANK_IDX);
+      const details = getPredictionDetails(logits, T, numClasses);
+      let debugText = "";
+      debugText += `Input shape: [1, 1, ${IMG_H}, ${IMG_W}]
+`;
+      debugText += `Output shape: [${batchSize}, ${T}, ${numClasses}]
+`;
+      debugText += `Charset: ${CHARSET}
+`;
+      debugText += `Blank index: ${BLANK_IDX}
+`;
+      debugText += `Prediction: ${prediction}
+
+`;
+      debugText += "CTC timesteps:\n";
+      for (const item of details) {
+        debugText += `t=${String(item.t).padStart(2, "0")} class=${String(item.classIndex).padStart(2, "0")} label=${item.label} logit=${item.logit.toFixed(4)}
+`;
+      }
+      return {
+        prediction,
+        debugText
+      };
+    } catch (error) {
+      console.error(error);
+      return null;
+    }
+  }
+
+  // ../utils/src/loadModel.js
+  async function loadScript() {
+    const url = "https://unpkg.com/onnxruntime-web@1.29.0/dist/ort.min.js";
+    return new Promise((resolve, reject) => {
+      if (window.ort) {
+        resolve(window.ort);
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = url;
+      script.async = true;
+      script.onload = () => resolve(window.ort);
+      script.onerror = () => reject(new Error(`\u52A0\u8F7D ONNX Runtime Web \u5931\u8D25: ${url}`));
+      document.head.appendChild(script);
+    });
+  }
+
+  // src/script.js
+  var MODEL_CACHE_KEY = "captcha-model-v1";
+  function openDB() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open("onnx-cache", 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains("models")) {
+          db.createObjectStore("models");
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async function getCachedModel() {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction("models", "readonly");
+      const store = transaction.objectStore("models");
+      const request = store.get(MODEL_CACHE_KEY);
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async function cacheModel(buffer) {
+    const db = await openDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction("models", "readwrite");
+      const store = transaction.objectStore("models");
+      const request = store.put(buffer, MODEL_CACHE_KEY);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async function getModelBuffer() {
+    const cached = await getCachedModel();
+    if (cached) {
+      console.log("ONNX \u6A21\u578B\uFF1A\u4ECE IndexedDB \u52A0\u8F7D");
+      return cached;
+    }
+    console.log("ONNX \u6A21\u578B\uFF1A\u4ECE\u7F51\u7EDC\u4E0B\u8F7D");
+    const response = await fetch(MODEL_URL);
+    if (!response.ok) {
+      throw new Error(
+        `\u6A21\u578B\u4E0B\u8F7D\u5931\u8D25: ${response.status} ${response.statusText}`
+      );
+    }
+    const buffer = await response.arrayBuffer();
+    console.log(
+      `ONNX \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(buffer.byteLength / 1024 / 1024).toFixed(2)} MB`
+    );
+    await cacheModel(buffer);
+    console.log("ONNX \u6A21\u578B\uFF1A\u5DF2\u7F13\u5B58\u5230 IndexedDB");
+    return buffer;
+  }
+  async function loadModel2() {
+    const modelBuffer = await getModelBuffer();
+    return await ort.InferenceSession.create(
+      modelBuffer,
+      {
+        executionProviders: ["webgpu", "wasm"],
+        graphOptimizationLevel: "all"
+      }
+    );
+  }
+  async function start() {
+    await loadScript();
+    const session = await loadModel2();
+    checkImg = document.querySelector("#captchaImg");
+    setTimeout(async () => {
+      const res = await recognize(session, document.querySelector("#captchaImg"));
+      document.querySelector("#input_checkcode").value = res.prediction;
+    });
+  }
+  (async () => {
+    await start();
+  })();
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scu-xiaochuan/scu-captcha-script",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "四川大学本科教务系统验证码识别脚本",
   "main": "index.js",
   "files": [