@areb0s/ocr-common 1.0.0

package/src/backend/splitIntoLineImages.ts

@@ -0,0 +1,296 @@
+import cv from '@techstark/opencv-js'
+import clipper from 'js-clipper'
+import { ImageRaw } from '#common/backend'
+import type { LineImage, ImageRaw as ImageRawType } from '#common/types'
+
+type pointType = [number, number]
+type BoxType = [pointType, pointType, pointType, pointType]
+type pointsType = pointType[]
+
+export async function splitIntoLineImages(image: ImageRawType, sourceImage: ImageRawType): Promise<LineImage[]> {
+  const w = image.width
+  const h = image.height
+  const srcData = sourceImage
+
+  const edgeRect: { box: BoxType; image: ImageRawType }[] = []
+
+  const src = cvImread(image)
+
+  cv.cvtColor(src, src, cv.COLOR_RGBA2GRAY, 0)
+  const contours = new cv.MatVector()
+  const hierarchy = new cv.Mat()
+
+  cv.findContours(src, contours, hierarchy, cv.RETR_LIST, cv.CHAIN_APPROX_SIMPLE)
+
+  for (let i = 0; i < contours.size(); i++) {
+    const minSize = 3
+    const cnt = contours.get(i)
+    const { points, sside } = getMiniBoxes(cnt)
+    if (sside < minSize) continue
+    // TODO sort fast
+
+    const clipBox = unclip(points)
+
+    const boxMap = cv.matFromArray(clipBox.length / 2, 1, cv.CV_32SC2, clipBox)
+
+    const resultObj = getMiniBoxes(boxMap)
+    const box = resultObj.points
+    if (resultObj.sside < minSize + 2) {
+      continue
+    }
+    function clip(n: number, min: number, max: number) {
+      return Math.max(min, Math.min(n, max))
+    }
+
+    const rx = srcData.width / w
+    const ry = srcData.height / h
+
+    for (let i = 0; i < box.length; i++) {
+      box[i][0] *= rx
+      box[i][1] *= ry
+    }
+
+    const box1 = orderPointsClockwise(box)
+    box1.forEach((item) => {
+      item[0] = clip(Math.round(item[0]), 0, srcData.width)
+      item[1] = clip(Math.round(item[1]), 0, srcData.height)
+    })
+    const rect_width = int(linalgNorm(box1[0], box1[1]))
+    const rect_height = int(linalgNorm(box1[0], box1[3]))
+    if (rect_width <= 3 || rect_height <= 3) continue
+
+    const c = getRotateCropImage(srcData, box)
+
+    edgeRect.push({
+      box,
+      image: c,
+    })
+  }
+
+  src.delete()
+  contours.delete()
+  hierarchy.delete()
+
+  return edgeRect
+}
+
+function getMiniBoxes(contour: any) {
+  const boundingBox = cv.minAreaRect(contour)
+  const points = Array.from(boxPoints(boundingBox.center, boundingBox.size, boundingBox.angle)).sort(
+    (a, b) => a[0] - b[0],
+  ) as pointsType
+
+  let index_1 = 0,
+    index_2 = 1,
+    index_3 = 2,
+    index_4 = 3
+  if (points[1][1] > points[0][1]) {
+    index_1 = 0
+    index_4 = 1
+  } else {
+    index_1 = 1
+    index_4 = 0
+  }
+  if (points[3][1] > points[2][1]) {
+    index_2 = 2
+    index_3 = 3
+  } else {
+    index_2 = 3
+    index_3 = 2
+  }
+
+  const box = [points[index_1], points[index_2], points[index_3], points[index_4]] as BoxType
+  const side = Math.min(boundingBox.size.height, boundingBox.size.width)
+  return { points: box, sside: side }
+}
+
+function unclip(box: pointsType) {
+  const unclip_ratio = 1.5
+  const area = Math.abs(polygonPolygonArea(box))
+  const length = polygonPolygonLength(box)
+  const distance = (area * unclip_ratio) / length
+  const tmpArr: { X: number; Y: number }[] = []
+  box.forEach((item) => {
+    const obj = {
+      X: 0,
+      Y: 0,
+    }
+    obj.X = item[0]
+    obj.Y = item[1]
+    tmpArr.push(obj)
+  })
+  const offset = new clipper.ClipperOffset()
+  offset.AddPath(tmpArr, clipper.JoinType.jtRound, clipper.EndType.etClosedPolygon)
+  const expanded: { X: number; Y: number }[][] = []
+  offset.Execute(expanded, distance)
+  let expandedArr: pointsType = []
+  expanded[0] &&
+    expanded[0].forEach((item) => {
+      expandedArr.push([item.X, item.Y])
+    })
+  expandedArr = [].concat(...(<any>expandedArr))
+
+  return expandedArr
+}
+
+function orderPointsClockwise(pts: BoxType) {
+  const rect: BoxType = [
+    [0, 0],
+    [0, 0],
+    [0, 0],
+    [0, 0],
+  ]
+  const s = pts.map((pt) => pt[0] + pt[1])
+  rect[0] = pts[s.indexOf(Math.min(...s))]
+  rect[2] = pts[s.indexOf(Math.max(...s))]
+  const tmp = pts.filter((pt) => pt !== rect[0] && pt !== rect[2])
+  const diff = tmp[1].map((e, i) => e - tmp[0][i])
+  rect[1] = tmp[diff.indexOf(Math.min(...diff))]
+  rect[3] = tmp[diff.indexOf(Math.max(...diff))]
+  return rect
+}
+
+function linalgNorm(p0: pointType, p1: pointType) {
+  return Math.sqrt(Math.pow(p0[0] - p1[0], 2) + Math.pow(p0[1] - p1[1], 2))
+}
+
+function int(num: number) {
+  return num > 0 ? Math.floor(num) : Math.ceil(num)
+}
+
+function getRotateCropImage(imageRaw: ImageRawType, points: BoxType): ImageRawType {
+  const img_crop_width = int(Math.max(linalgNorm(points[0], points[1]), linalgNorm(points[2], points[3])))
+  const img_crop_height = int(Math.max(linalgNorm(points[0], points[3]), linalgNorm(points[1], points[2])))
+  const pts_std = [
+    [0, 0],
+    [img_crop_width, 0],
+    [img_crop_width, img_crop_height],
+    [0, img_crop_height],
+  ]
+
+  const srcTri = cv.matFromArray(4, 1, cv.CV_32FC2, flatten(points))
+  const dstTri = cv.matFromArray(4, 1, cv.CV_32FC2, flatten(pts_std))
+
+  // 获取到目标矩阵
+  const M = cv.getPerspectiveTransform(srcTri, dstTri)
+  const src = cvImread(imageRaw)
+  const dst = new cv.Mat()
+  const dsize = new cv.Size(img_crop_width, img_crop_height)
+  // 透视转换
+  cv.warpPerspective(src, dst, M, dsize, cv.INTER_CUBIC, cv.BORDER_REPLICATE, new cv.Scalar())
+
+  const dst_img_height = (<any>dst).matSize[0]
+  const dst_img_width = (<any>dst).matSize[1]
+  let dst_rot
+  // 图像旋转
+  if (dst_img_height / dst_img_width >= 1.5) {
+    dst_rot = new cv.Mat()
+    const dsize_rot = new cv.Size(dst.rows, dst.cols)
+    const center = new cv.Point(dst.cols / 2, dst.cols / 2)
+    const M = cv.getRotationMatrix2D(center, 90, 1)
+    cv.warpAffine(dst, dst_rot, M, dsize_rot, cv.INTER_CUBIC, cv.BORDER_REPLICATE, new cv.Scalar())
+  }
+
+  src.delete()
+  srcTri.delete()
+  dstTri.delete()
+  if (dst_rot) {
+    dst.delete()
+  }
+
+  return cvImshow(dst_rot || dst)
+}
+
+function boxPoints(center: { x: number; y: number }, size: { width: number; height: number }, angle: number) {
+  const width = size.width
+  const height = size.height
+
+  const theta = (angle * Math.PI) / 180.0
+  const cosTheta = Math.cos(theta)
+  const sinTheta = Math.sin(theta)
+
+  const cx = center.x
+  const cy = center.y
+
+  const dx = width * 0.5
+  const dy = height * 0.5
+
+  const rotatedPoints: any[] = []
+
+  // Top-Left
+  const x1 = cx - dx * cosTheta + dy * sinTheta
+  const y1 = cy - dx * sinTheta - dy * cosTheta
+  rotatedPoints.push([x1, y1])
+
+  // Top-Right
+  const x2 = cx + dx * cosTheta + dy * sinTheta
+  const y2 = cy + dx * sinTheta - dy * cosTheta
+  rotatedPoints.push([x2, y2])
+
+  // Bottom-Right
+  const x3 = cx + dx * cosTheta - dy * sinTheta
+  const y3 = cy + dx * sinTheta + dy * cosTheta
+  rotatedPoints.push([x3, y3])
+
+  // Bottom-Left
+  const x4 = cx - dx * cosTheta - dy * sinTheta
+  const y4 = cy - dx * sinTheta + dy * cosTheta
+  rotatedPoints.push([x4, y4])
+
+  return rotatedPoints
+}
+
+function polygonPolygonArea(polygon: pointsType) {
+  let i = -1,
+    n = polygon.length,
+    a: pointType,
+    b = polygon[n - 1],
+    area = 0
+
+  while (++i < n) {
+    a = b
+    b = polygon[i]
+    area += a[1] * b[0] - a[0] * b[1]
+  }
+
+  return area / 2
+}
+
+function polygonPolygonLength(polygon: pointsType) {
+  let i = -1,
+    n = polygon.length,
+    b = polygon[n - 1],
+    xa: number,
+    ya: number,
+    xb = b[0],
+    yb = b[1],
+    perimeter = 0
+
+  while (++i < n) {
+    xa = xb
+    ya = yb
+    b = polygon[i]
+    xb = b[0]
+    yb = b[1]
+    xa -= xb
+    ya -= yb
+    perimeter += Math.hypot(xa, ya)
+  }
+
+  return perimeter
+}
+
+function flatten(arr: number[] | number[][]) {
+  return arr
+    .toString()
+    .split(',')
+    .map((item) => +item)
+}
+
+function cvImread(image: ImageRawType) {
+  return cv.matFromImageData(image)
+}
+
+function cvImshow(mat: cv.Mat): ImageRawType {
+  return new ImageRaw({ data: mat.data, width: mat.cols, height: mat.rows })
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import { Ocr } from './Ocr'
+
+export default Ocr
+
+export { registerBackend } from './backend/backend'
+export * from './backend/FileUtilsBase'
+export * from './backend/ImageRawBase'
+export type * from './types'

package/src/models/Detection.ts

@@ -0,0 +1,96 @@
+import type { InferenceSession as InferenceSessionCommon, Tensor } from 'onnxruntime-common'
+import invariant from 'tiny-invariant'
+import { ImageRaw, InferenceSession, defaultModels, splitIntoLineImages } from '#common/backend'
+import type { ImageRawData, BrowserImageInput, ImageRaw as ImageRawType, ModelCreateOptions, Size } from '#common/types'
+import { ModelBase } from './ModelBase'
+
+const BASE_SIZE = 32
+
+export class Detection extends ModelBase {
+  static async create({ models, onnxOptions = {}, ...restOptions }: ModelCreateOptions) {
+    const detectionPath = models?.detectionPath || defaultModels?.detectionPath
+    invariant(detectionPath, 'detectionPath is required')
+    const model = await InferenceSession.create(detectionPath, onnxOptions)
+    return new Detection({ model, options: restOptions })
+  }
+
+  async run(input: string | ImageRawData | BrowserImageInput, { onnxOptions = {} }: { onnxOptions?: InferenceSessionCommon.RunOptions } = {}) {
+    // Use ImageRaw.from() factory method if available (browser), otherwise fallback to legacy handling
+    const image = typeof (ImageRaw as any).from === 'function'
+      ? await (ImageRaw as any).from(input)
+      : typeof input === "string" 
+        ? await ImageRaw.open(input) 
+        : new ImageRaw(input as ImageRawData)
+
+    // Resize image to multiple of 32
+    //   - image width and height must be a multiple of 32
+    //   - bigger image -> more accurate result, but takes longer time
+    // inputImage = await Image.resize(image, multipleOfBaseSize(image, { maxSize: 960 }))
+    const inputImage = await image.resize(multipleOfBaseSize(image))
+    this.debugImage(inputImage, 'out1-multiple-of-base-size.jpg')
+
+    // Covert image data to model data
+    //   - Using `(RGB / 255 - mean) / std` formula
+    //   - omit reshapeOptions (mean/std) is more accurate, can creaet a run option for them
+    const modelData = this.imageToInput(inputImage, {
+      // mean: [0.485, 0.456, 0.406],
+      // std: [0.229, 0.224, 0.225],
+    })
+
+    // Run the model
+    // console.time('Detection')
+    const modelOutput = await this.runModel({ modelData, onnxOptions })
+    // console.timeEnd('Detection')
+
+    // Convert output data back to image data
+    //   - output value is from 0 to 1, a probability, if value > 0.3, it is a text
+    //   - returns a black and white image
+    const outputImage = outputToImage(modelOutput, 0.03)
+    this.debugImage(outputImage, 'out2-black-white.jpg')
+
+    // Find text boxes, split image into lines
+    //   - findContours from the image
+    //   - returns text boxes and line images
+    const lineImages = await splitIntoLineImages(outputImage, inputImage)
+    this.debugBoxImage(inputImage, lineImages, 'boxes.jpg')
+
+    return {
+      lineImages,
+      resizedImageWidth: inputImage.width,
+      resizedImageHeight: inputImage.height,
+    }
+  }
+}
+
+function multipleOfBaseSize(image: ImageRawType, { maxSize }: { maxSize?: number } = {}): Size {
+  let width = image.width
+  let height = image.height
+  if (maxSize && Math.max(width, height) > maxSize) {
+    const ratio = width > height ? maxSize / width : maxSize / height
+    width = width * ratio
+    height = height * ratio
+  }
+  const newWidth = Math.max(
+    // Math.round
+    // Math.ceil
+    Math.ceil(width / BASE_SIZE) * BASE_SIZE,
+    BASE_SIZE,
+  )
+  const newHeight = Math.max(Math.ceil(height / BASE_SIZE) * BASE_SIZE, BASE_SIZE)
+  return { width: newWidth, height: newHeight }
+}
+
+function outputToImage(output: Tensor, threshold: number): ImageRawType {
+  const height = output.dims[2]
+  const width = output.dims[3]
+  const data = new Uint8Array(width * height * 4)
+  for (const [outIndex, outValue] of output.data.entries()) {
+    const n = outIndex * 4
+    const value = (outValue as number) > threshold ? 255 : 0
+    data[n] = value // R
+    data[n + 1] = value // G
+    data[n + 2] = value // B
+    data[n + 3] = 255 // A
+  }
+  return new ImageRaw({ data, width, height })
+}

package/src/models/ModelBase.ts

@@ -0,0 +1,74 @@
+import { type InferenceSession as InferenceSessionCommon, Tensor } from 'onnxruntime-common'
+import type {
+  ImageRaw,
+  InferenceSession,
+  LineImage,
+  ModelBaseConstructorArg,
+  ModelBaseOptions,
+  ModelData,
+  ReshapeOptions,
+} from '#common/types'
+
+export class ModelBase {
+  options: ModelBaseOptions
+  #model: InferenceSession
+
+  constructor({ model, options }: ModelBaseConstructorArg) {
+    this.#model = model
+    this.options = options
+  }
+
+  async runModel({
+    modelData,
+    onnxOptions = {},
+  }: { modelData: ModelData; onnxOptions?: InferenceSessionCommon.RunOptions }) {
+    const input = this.#prepareInput(modelData)
+    const outputs = await this.#model.run(
+      {
+        [this.#model.inputNames[0]]: input,
+      },
+      onnxOptions,
+    )
+    const output = outputs[this.#model.outputNames[0]]
+    return output
+  }
+
+  #prepareInput(modelData: ModelData) {
+    const input = Float32Array.from(modelData.data)
+    return new Tensor('float32', input, [1, 3, modelData.height, modelData.width])
+  }
+
+  imageToInput(image: ImageRaw, { mean = [0, 0, 0], std = [1, 1, 1] }: ReshapeOptions): ModelData {
+    const R: number[] = []
+    const G: number[] = []
+    const B: number[] = []
+    for (let i = 0; i < image.data.length; i += 4) {
+      R.push((image.data[i] / 255 - mean[0]) / std[0])
+      G.push((image.data[i + 1] / 255 - mean[1]) / std[1])
+      B.push((image.data[i + 2] / 255 - mean[2]) / std[2])
+    }
+    const newData = [...B, ...G, ...R]
+    return {
+      data: newData,
+      width: image.width,
+      height: image.height,
+    }
+  }
+
+  debugImage(image: ImageRaw | any, path: string) {
+    const { debugOutputDir, isDebug } = this.options
+    if (!isDebug || !debugOutputDir) {
+      return
+    }
+    image.write(`${debugOutputDir}/${path}`)
+  }
+
+  async debugBoxImage(sourceImage: ImageRaw | any, lineImages: LineImage[], path: string) {
+    const { debugOutputDir, isDebug } = this.options
+    if (!isDebug || !debugOutputDir) {
+      return
+    }
+    const boxImage = await sourceImage.drawBox(lineImages)
+    boxImage.write(`${debugOutputDir}/${path}`)
+  }
+}

package/src/models/Recognition.ts

@@ -0,0 +1,217 @@
+import type { InferenceSession as InferenceSessionCommon, Tensor } from 'onnxruntime-common'
+import invariant from 'tiny-invariant'
+import { FileUtils, InferenceSession, defaultModels } from '#common/backend'
+import type { Dictionary, Line, LineImage, ModelBaseConstructorArg, ModelCreateOptions } from '#common/types'
+import { ModelBase } from './ModelBase'
+
+export class Recognition extends ModelBase {
+  #dictionary: Dictionary
+
+  static async create({ models, onnxOptions = {}, ...restOptions }: ModelCreateOptions) {
+    const recognitionPath = models?.recognitionPath || defaultModels?.recognitionPath
+    invariant(recognitionPath, 'recognitionPath is required')
+    const dictionaryPath = models?.dictionaryPath || defaultModels?.dictionaryPath
+    invariant(dictionaryPath, 'dictionaryPath is required')
+    const model = await InferenceSession.create(recognitionPath, onnxOptions)
+    const dictionaryText = await FileUtils.read(dictionaryPath)
+    const dictionary = [...dictionaryText.split('\n'), ' ']
+    return new Recognition({ model, options: restOptions }, dictionary)
+  }
+
+  constructor(options: ModelBaseConstructorArg, dictionary: Dictionary) {
+    super(options)
+    this.#dictionary = dictionary
+  }
+
+  async run(lineImages: LineImage[], { onnxOptions = {} }: { onnxOptions?: InferenceSessionCommon.RunOptions } = {}) {
+    const modelDatas = await Promise.all(
+      // Detect text from each line image
+      lineImages.map(async (lineImage, index) => {
+        // Resize Image to 48px height
+        //  - height must <= 48
+        //  - height: 48 is more accurate then 40, but same as 30
+        const image = await (lineImage.image as any).resize({
+          height: 48,
+        })
+        this.debugImage(lineImage.image, `out9-line-${index}.jpg`)
+        this.debugImage(image, `out9-line-${index}-resized.jpg`)
+
+        // transform image data to model data
+        const modelData = this.imageToInput(image, {
+          // mean: [0.5, 0.5, 0.5],
+          // std: [0.5, 0.5, 0.5],
+        })
+        return modelData
+      }),
+    )
+
+    const allLines: Line[] = []
+    // console.time('Recognition')
+    for (const modelData of modelDatas) {
+      // Run model for each line image
+      const output = await this.runModel({ modelData, onnxOptions })
+      // use Dictoinary to decode output to text
+      const lines = await this.decodeText(output)
+      allLines.unshift(...lines)
+    }
+    // console.timeEnd('Recognition')
+    const result = calculateBox({ lines: allLines, lineImages })
+    return result
+  }
+
+  decodeText(output: Tensor) {
+    const data = output
+    const predLen = data.dims[2]
+    const line: Line[] = []
+    let ml = data.dims[0] - 1
+    for (let l = 0; l < data.data.length; l += predLen * data.dims[1]) {
+      const predsIdx: number[] = []
+      const predsProb: number[] = []
+
+      for (let i = l; i < l + predLen * data.dims[1]; i += predLen) {
+        const tmpArr = data.data.slice(i, i + predLen) as Float32Array
+        const tmpMax = tmpArr.reduce((a, b) => Math.max(a, b), Number.NEGATIVE_INFINITY)
+        const tmpIdx = tmpArr.indexOf(tmpMax)
+        predsProb.push(tmpMax)
+        predsIdx.push(tmpIdx)
+      }
+      line[ml] = decode(this.#dictionary, predsIdx, predsProb, true)
+      ml--
+    }
+    return line
+  }
+}
+
+function decode(dictionary: string[], textIndex: number[], textProb: number[], isRemoveDuplicate: boolean) {
+  const ignoredTokens = [0]
+  const charList = []
+  const confList = []
+  for (let idx = 0; idx < textIndex.length; idx++) {
+    if (textIndex[idx] in ignoredTokens) {
+      continue
+    }
+    if (isRemoveDuplicate) {
+      if (idx > 0 && textIndex[idx - 1] === textIndex[idx]) {
+        continue
+      }
+    }
+    charList.push(dictionary[textIndex[idx] - 1])
+    if (textProb) {
+      confList.push(textProb[idx])
+    } else {
+      confList.push(1)
+    }
+  }
+  let text = ''
+  let mean = 0
+  if (charList.length) {
+    text = charList.join('')
+    let sum = 0
+    confList.forEach((item) => {
+      sum += item
+    })
+    mean = sum / confList.length
+  }
+  return { text, mean }
+}
+
+function calculateBox({
+  lines,
+  lineImages,
+}: {
+  lines: Line[]
+  lineImages: LineImage[]
+}) {
+  let mainLine = lines
+  const box = lineImages
+  for (const i in mainLine) {
+    const b = box[mainLine.length - Number(i) - 1].box
+    for (const p of b) {
+      p[0] = p[0]
+      p[1] = p[1]
+    }
+    mainLine[i]['box'] = b
+  }
+  mainLine = mainLine.filter((x) => x.mean >= 0.5)
+  mainLine = afAfRec(mainLine)
+  return mainLine
+}
+
+function afAfRec(lines: Line[]) {
+  const outputLines: Line[] = []
+  const indexes: Map<BoxType, number> = new Map()
+  for (const index in lines) {
+    const box: any = lines[index].box
+    indexes.set(box, Number(index))
+  }
+
+  const groupedBoxes = groupBoxesByMidlineDifference([...indexes.keys()])
+
+  for (const boxes of groupedBoxes) {
+    const texts = []
+    let mean = 0
+    for (const box of boxes) {
+      const index = indexes.get(box)
+      if (index === undefined) {
+        continue
+      }
+      const line = lines[index]
+      texts.push(line.text)
+      mean += line.mean
+    }
+    let outputBox = undefined
+    if (boxes.at(0) && boxes.at(-1)) {
+      outputBox = [boxes.at(0)![0], boxes.at(-1)![1], boxes.at(-1)![2], boxes.at(0)![3]]
+    }
+    outputLines.push({
+      mean: mean / boxes.length,
+      text: texts.join(' '),
+      box: outputBox,
+    })
+  }
+  return outputLines
+}
+
+function calculateAverageHeight(boxes: BoxType[]): number {
+  let totalHeight = 0
+  for (const box of boxes) {
+    const [[, y1], , [, y2]] = box
+    const height = y2 - y1
+    totalHeight += height
+  }
+  return totalHeight / boxes.length
+}
+
+function groupBoxesByMidlineDifference(boxes: BoxType[]): BoxType[][] {
+  const averageHeight = calculateAverageHeight(boxes)
+  const result: BoxType[][] = []
+  for (const box of boxes) {
+    const [[, y1], , [, y2]] = box
+    const midline = (y1 + y2) / 2
+    const group = result.find((b) => {
+      const [[, groupY1], , [, groupY2]] = b[0]
+      const groupMidline = (groupY1 + groupY2) / 2
+      return Math.abs(groupMidline - midline) < averageHeight / 2
+    })
+    if (group) {
+      group.push(box)
+    } else {
+      result.push([box])
+    }
+  }
+
+  for (const group of result) {
+    group.sort((a, b) => {
+      const [ltA] = a
+      const [ltB] = b
+      return ltA[0] - ltB[0]
+    })
+  }
+
+  result.sort((a, b) => a[0][0][1] - b[0][0][1])
+
+  return result
+}
+
+type pointType = [number, number]
+type BoxType = [pointType, pointType, pointType, pointType]

package/src/models/index.ts

@@ -0,0 +1,2 @@
+export * from './Detection'
+export * from './Recognition'

package/src/types/global.d.ts

@@ -0,0 +1,7 @@
+declare module 'opencv.js'
+
+declare module 'js-clipper'
+
+declare module 'canvas'
+
+declare module 'jsdom'

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './types'