nodejs项目使用tesseract的文字识别功能

记录一下在 Node.js 项目中使用 tesseract 的文字识别功能。

安装 Tesseract.js

使用 Node.js 版本 16.19.1

# 指定版本，成功率更高
# 还需要安装canvas
npm install tesseract.js@5.0.4 canvas@2.11.2

使用

// WordProcess.class.js

const fs = require("fs");
const path = require("path");
const { createWorker } = require("tesseract.js");
const { createCanvas, loadImage } = require("canvas");

/**
 * 图片文字处理类
 */
module.exports = class WordProcess {
  resultFormat = /[\r\n\s]/g;
  worker;

  /**
   * 初始化
   * @param {String} modelCachePath  tesseract模型缓存路径
   * @param {String} langs 支持的语言包，默认为chi_sim+eng，表示中文简体和英文
   */
  init(modelCachePath, langs) {
    modelCachePath = modelCachePath || path.resolve(__dirname, "./lang");
    langs = langs || "chi_sim+eng";

    return new Promise((resolve, reject) => {
      createWorker(langs, 1, {
        cachePath: path.resolve(__dirname, modelCachePath),
      })
        .then((worker) => {
          this.worker = worker;
          resolve(this);
        })
        .catch((err) => {
          reject(err);
        });
    });
  }

  /**
   * 图片文字识别
   * @param {string|Buffer} imgPath 图片地址
   * @param {Boolean} format 是否去掉换行空格等符号
   * @returns {Promise<string>}
   */
  async ocr(imgPath, format = false) {
    let res = await this.worker.recognize(imgPath);
    let {
      data: { text },
    } = res;
    if (format) text = text.replace(this.resultFormat, "");
    return text;
  }

  /**
   * 图片文字位置搜索，如果找到则返回文字在图片中的绝对坐标
   * @param {string} str 要搜索位置的文字
   * @param {string} imgPath 被搜索的图片
   * @param {number} x 搜索起始坐标x
   * @param {number} y 搜索起始坐标y
   * @param {number} width 搜索宽度
   * @param {number} height 搜索高度
   * @param {[string, string]} colorRange 图片颜色过滤，这个范围外的颜色会被替换为白色
   * @returns {Promise<{x: number, y: number}>} 绝对坐标点
   */
  async findStr(
    str,
    imgPath,
    x = 0,
    y = 0,
    width,
    height,
    colorRange = ["000000", "9f2e3f"]
  ) {
    // 读取图片
    let image = await loadImage(imgPath);

    width = width || image.width;
    height = height || image.height;

    // 截取图片
    let canvas = createCanvas(image.width, image.height);
    let ctx = canvas.getContext("2d");
    ctx.drawImage(image, 0, 0);
    let imageData = ctx.getImageData(x, y, width, height);
    let croppedCanvas = createCanvas(width, height);
    let croppedCtx = croppedCanvas.getContext("2d");
    croppedCtx.putImageData(imageData, 0, 0);
    // 过滤图片颜色
    let imageData2 = croppedCtx.getImageData(0, 0, width, height);
    let data = imageData2.data;
    let colorRangeMin = colorRange[0]
        .match(/\w{2}/g)
        .map((v) => parseInt(v, 16)),
      colorRangeMax = colorRange[1].match(/\w{2}/g).map((v) => parseInt(v, 16));
    for (let i = 0; i < data.length; i += 4) {
      let red = data[i];
      let green = data[i + 1];
      let blue = data[i + 2];
      if (
        red >= colorRangeMin[0] &&
        red <= colorRangeMax[0] &&
        green >= colorRangeMin[1] &&
        green <= colorRangeMax[1] &&
        blue >= colorRangeMin[2] &&
        blue <= colorRangeMax[2]
      )
        continue;
      data[i] = 255;
      data[i + 1] = 255;
      data[i + 2] = 255;
    }
    croppedCtx.putImageData(imageData2, 0, 0);

    // 存储过滤了颜色后的图片
    let buffer = croppedCanvas.toBuffer("image/png");
    const tempImgPath = path.resolve(__dirname, "./temp.png");
    fs.writeFileSync(tempImgPath, buffer);

    // 文字识别
    let res = await this.worker.recognize(tempImgPath);
    let {
      data: { lines },
    } = res;

    // 删除图片
    fs.unlinkSync(tempImgPath);

    // 搜索行
    let line = lines.find((line, index) => {
      return line.text.replace(this.resultFormat, "").indexOf(str) > -1;
    });

    if (!line) {
      return { x: 0, y: 0 };
    }

    // 搜索列
    let word = line.words.find((word, index) => {
      return word.text.replace(this.resultFormat, "").indexOf(str[0]) > -1;
    });
    if (!word) {
      return { x: 0, y: 0 };
    }
    let point = {
      x: x + word.bbox.x0,
      y: y + word.bbox.y0,
    };
    return point;
  }
};

测试如下：

// test.js

const WordProcess = require("./WordProcess.class.js");

// 测试文字识别
const wp = new WordProcess();
wp.init()
  .then(async (ins) => {
    let imgPath = path.resolve(__dirname, "./test.png");

    // 测试文字识别
    let text = await ins.ocr(imgPath);
    console.log(text);

    // 测试文字位置搜索
    let point = await ins.findStr("av", imgPath);
    console.log(point);
  })
  .catch((err) => {
    console.log(err);
  });