参考orcweb部署框架, 另行实现多模型部署

ocrweb_multi/README.md

@@ -0,0 +1,2 @@
+## RapidOCR多语言支持Web服务
+RapidOCR Multilanguage Web Demo

ocrweb_multi/config.yaml

@@ -0,0 +1,106 @@
+debug: '1'
+
+server:
+  host: 127.0.0.1
+  port: 9003
+  token: null
+
+global:
+  use_cuda: false
+  verbose: false
+  # Details of the params: https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html
+  cuda_provider:
+    device_id: 0
+    arena_extend_strategy: kNextPowerOfTwo
+    cudnn_conv_algo_search: EXHAUSTIVE
+    do_copy_in_default_stream: true
+
+# 模型配置
+models:
+  # 位置检测模型
+  detect:
+    det_en:
+      path: models/en_PP-OCRv3_det_infer.onnx
+      config: &detectConfig
+        pre_process:
+          - class: DetResizeForTest
+            limit_side_len: 736
+            limit_type: min
+          - class: NormalizeImage
+            std: [0.229, 0.224, 0.225]
+            mean: [0.485, 0.456, 0.406]
+            # 1 / 255
+            scale: 0.00392156862745098
+            order: hwc
+          - class: ToCHWImage
+          - class: KeepKeys
+            keep_keys: ["image", "shape"]
+        post_process:
+          thresh: 0.3
+          box_thresh: 0.5
+          max_candidates: 1000
+          unclip_ratio: 1.6
+          use_dilation: true
+    det_ch:
+      path: models/ch_PP-OCRv3_det_infer.onnx
+      config: *detectConfig
+    det_ml:
+      path: models/ch_PP-OCRv3_det_infer.onnx
+      config: *detectConfig
+  # 方向检测模型
+  classify:
+    cls_ml:
+      path: models/ch_ppocr_mobile_v2.0_cls_infer.meta.onnx
+      config:
+        batch_size: 8
+        score_thresh: 0.9
+  # 文字识别模型
+  recognize:
+    rec_ch:
+      path: models/ch_PP-OCRv3_rec_infer.meta.onnx
+      config: &recognizeConfig
+        batch_size: 8
+    rec_cht:
+      path: models/chinese_cht_PP-OCRv3_rec_infer.meta.onnx
+      config: *recognizeConfig
+    rec_en:
+      path: models/en_PP-OCRv3_rec_infer.meta.onnx
+      config: *recognizeConfig
+    rec_ja:
+      path: models/japan_PP-OCRv3_rec_infer.meta.onnx
+      config: *recognizeConfig
+
+# 多语言配置
+languages:
+  ch:
+    name: 中文
+    models:
+      detect: det_ch
+      classify: cls_ml
+      recognize: rec_ch
+    config: &languageConfig
+      text_score: 0.5
+      use_angle_cls: true
+      verbose: false
+      min_height: 30
+  cht:
+    name: 繁体中文
+    models:
+      detect: det_ch
+      classify: cls_ml
+      recognize: rec_cht
+    config: *languageConfig
+  ja:
+    name: 日文
+    models:
+      detect: det_ch
+      classify: cls_ml
+      recognize: rec_ja
+    config: *languageConfig
+  en:
+    name: 英文
+    models:
+      detect: det_en
+      classify: cls_ml
+      recognize: rec_en
+    config: *languageConfig

ocrweb_multi/main.py

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+# @Author: SWHL
+# @Contact: liekkaskono@163.com
+import logging
+import cv2
+import numpy as np
+from flask import Flask, send_file, request, make_response
+from waitress import serve
+
+
+from rapidocr.main import detect_recognize
+from utils.config import conf
+from utils.utils import tojson, parse_bool
+
+app = Flask(__name__)
+log = logging.getLogger('app')
+# 设置上传文件大小
+app.config['MAX_CONTENT_LENGTH'] = 3 * 1024 * 1024
+
+
+@app.route('/')
+def index():
+    return send_file('static/index.html')
+
+
+def json_response(data, *args):
+    return make_response(tojson(data), {"content-type": 'application/json'}, *args)
+
+
+@app.route('/lang')
+def get_languages():
+    """返回可用语言列表"""
+    data = [
+        {'code': key, 'name': val['name']} for key, val in conf['languages'].items()
+    ]
+    result = {'msg': 'OK', 'data': data}
+    log.info('Send langs: %s', data)
+    return json_response(result)
+
+
+@app.route('/ocr', methods=['POST', 'GET'])
+def ocr():
+    """执行文字识别"""
+    if conf['server'].get('token'):
+        if request.values.get('token') != conf['server']['token']:
+            return json_response({'msg': 'invalid token'}, 403)
+
+    lang = request.values.get('lang') or 'ch'
+    detect = parse_bool(request.values.get('detect') or 'true')
+    classify = parse_bool(request.values.get('classify') or 'true')
+
+    image_file = request.files.get('image')
+    nparr = np.frombuffer(image_file.stream.read(), np.uint8)
+    image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    log.info('Input: image %s, lang=%s, detect=%s, classify=%s', image.shape, lang, detect, classify)
+    if image.ndim == 2:
+        image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+    result = detect_recognize(image, lang=lang, detect=detect, classify=classify)
+    log.info('OCR Done %s %s', result['ts'], len(result['results']))
+    return json_response({'msg': 'OK', 'data': result})
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level='INFO')
+    logging.getLogger('waitress').setLevel(logging.INFO)
+    if parse_bool(conf.get('debug', '0')):
+        # Debug
+        app.run(host=conf['server']['host'], port=conf['server']['port'], debug=True)
+    else:
+        # Deploy with waitress
+        serve(app, host=conf['server']['host'], port=conf['server']['port'])

ocrweb_multi/rapidocr/classify.py

@@ -0,0 +1,122 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import copy
+import math
+import json
+from typing import List
+
+import cv2
+import numpy as np
+from utils.utils import OrtInferSession
+
+
+class ClsPostProcess(object):
+    """Convert between text-label and text-index"""
+
+    def __init__(self, label_list):
+        super(ClsPostProcess, self).__init__()
+        self.label_list = label_list
+
+    def __call__(self, preds, label=None):
+        pred_idxs = preds.argmax(axis=1)
+        decode_out = [
+            (self.label_list[idx], preds[i, idx]) for i, idx in enumerate(pred_idxs)
+        ]
+        if label is None:
+            return decode_out
+
+        label = [(self.label_list[idx], 1.0) for idx in label]
+        return decode_out, label
+
+
+class TextClassifier(object):
+    def __init__(self, path, config):
+        self.cls_batch_num = config['batch_size']
+        self.cls_thresh = config['score_thresh']
+
+        session_instance = OrtInferSession(path)
+        self.session = session_instance.session
+        metamap = self.session.get_modelmeta().custom_metadata_map
+
+        self.cls_image_shape = json.loads(metamap['shape'])
+
+        labels = json.loads(metamap['labels'])
+        self.postprocess_op = ClsPostProcess(labels)
+        self.input_name = session_instance.get_input_name()
+
+    def resize_norm_img(self, img):
+        img_c, img_h, img_w = self.cls_image_shape
+        h, w = img.shape[:2]
+        ratio = w / float(h)
+        if math.ceil(img_h * ratio) > img_w:
+            resized_w = img_w
+        else:
+            resized_w = int(math.ceil(img_h * ratio))
+
+        resized_image = cv2.resize(img, (resized_w, img_h))
+        resized_image = resized_image.astype('float32')
+        if img_c == 1:
+            resized_image = resized_image / 255
+            resized_image = resized_image[np.newaxis, :]
+        else:
+            resized_image = resized_image.transpose((2, 0, 1)) / 255
+
+        resized_image -= 0.5
+        resized_image /= 0.5
+        padding_im = np.zeros((img_c, img_h, img_w), dtype=np.float32)
+        padding_im[:, :, :resized_w] = resized_image
+        return padding_im
+
+    def __call__(self, img_list: List[np.ndarray]):
+        if isinstance(img_list, np.ndarray):
+            img_list = [img_list]
+
+        img_list = copy.deepcopy(img_list)
+
+        # Calculate the aspect ratio of all text bars
+        width_list = [img.shape[1] / float(img.shape[0]) for img in img_list]
+
+        # Sorting can speed up the cls process
+        indices = np.argsort(np.array(width_list))
+
+        img_num = len(img_list)
+        cls_res = [['', 0.0]] * img_num
+        batch_num = self.cls_batch_num
+        for beg_img_no in range(0, img_num, batch_num):
+            end_img_no = min(img_num, beg_img_no + batch_num)
+            max_wh_ratio = 0
+            for ino in range(beg_img_no, end_img_no):
+                h, w = img_list[indices[ino]].shape[0:2]
+                wh_ratio = w * 1.0 / h
+                max_wh_ratio = max(max_wh_ratio, wh_ratio)
+
+            norm_img_batch = []
+            for ino in range(beg_img_no, end_img_no):
+                norm_img = self.resize_norm_img(img_list[indices[ino]])
+                norm_img = norm_img[np.newaxis, :]
+                norm_img_batch.append(norm_img)
+            norm_img_batch = np.concatenate(norm_img_batch).astype(np.float32)
+
+            onnx_inputs = {self.input_name: norm_img_batch}
+            prob_out = self.session.run(None, onnx_inputs)[0]
+            cls_result = self.postprocess_op(prob_out)
+
+            for rno in range(len(cls_result)):
+                label, score = cls_result[rno]
+                cls_res[indices[beg_img_no + rno]] = [label, score]
+                if label == '180' and score > self.cls_thresh:
+                    img_list[indices[beg_img_no + rno]] = cv2.rotate(
+                        img_list[indices[beg_img_no + rno]], 1
+                    )
+        return img_list, cls_res

ocrweb_multi/rapidocr/detect.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# -*- encoding: utf-8 -*-
+# @Author: SWHL
+# @Contact: liekkaskono@163.com
+
+import numpy as np
+
+from utils.utils import OrtInferSession
+from .detect_process import DBPostProcess, create_operators, transform
+
+
+class TextDetector(object):
+    def __init__(self, path, config):
+        self.preprocess_op = create_operators(config['pre_process'])
+        self.postprocess_op = DBPostProcess(**config['post_process'])
+
+        session_instance = OrtInferSession(path)
+        self.session = session_instance.session
+        self.input_name = session_instance.get_input_name()
+
+    def __call__(self, img):
+        if img is None:
+            raise ValueError('img is None')
+
+        ori_im_shape = img.shape[:2]
+
+        data = {'image': img}
+        data = transform(data, self.preprocess_op)
+        img, shape_list = data
+        if img is None:
+            return None, 0
+
+        img = np.expand_dims(img, axis=0).astype(np.float32)
+        shape_list = np.expand_dims(shape_list, axis=0)
+
+        preds = self.session.run(None, {self.input_name: img})
+
+        post_result = self.postprocess_op(preds[0], shape_list)
+
+        dt_boxes = post_result[0]['points']
+        dt_boxes = self.filter_tag_det_res(dt_boxes, ori_im_shape)
+        return dt_boxes
+
+    def order_points_clockwise(self, pts):
+        """
+        reference from:
+        https://github.com/jrosebr1/imutils/blob/master/imutils/perspective.py
+        sort the points based on their x-coordinates
+        """
+        xSorted = pts[np.argsort(pts[:, 0]), :]
+
+        # grab the left-most and right-most points from the sorted
+        # x-roodinate points
+        leftMost = xSorted[:2, :]
+        rightMost = xSorted[2:, :]
+
+        # now, sort the left-most coordinates according to their
+        # y-coordinates so we can grab the top-left and bottom-left
+        # points, respectively
+        leftMost = leftMost[np.argsort(leftMost[:, 1]), :]
+        (tl, bl) = leftMost
+
+        rightMost = rightMost[np.argsort(rightMost[:, 1]), :]
+        (tr, br) = rightMost
+
+        rect = np.array([tl, tr, br, bl], dtype="float32")
+        return rect
+
+    def clip_det_res(self, points, img_height, img_width):
+        for pno in range(points.shape[0]):
+            points[pno, 0] = int(min(max(points[pno, 0], 0), img_width - 1))
+            points[pno, 1] = int(min(max(points[pno, 1], 0), img_height - 1))
+        return points
+
+    def filter_tag_det_res(self, dt_boxes, image_shape):
+        """对检测结果进行过滤"""
+        img_height, img_width = image_shape[:2]
+        dt_boxes_new = []
+        for box in dt_boxes:
+            box = self.order_points_clockwise(box)
+            box = self.clip_det_res(box, img_height, img_width)
+            rect_width = int(np.linalg.norm(box[0] - box[1]))
+            rect_height = int(np.linalg.norm(box[0] - box[3]))
+            if rect_width <= 3 or rect_height <= 3:
+                continue
+            dt_boxes_new.append(box)
+        return dt_boxes_new

ocrweb_multi/rapidocr/detect_process.py

@@ -0,0 +1,380 @@
+"""
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+# -*- encoding: utf-8 -*-
+# @Author: SWHL
+# @Contact: liekkaskono@163.com
+from copy import deepcopy
+import sys
+import warnings
+
+import cv2
+import numpy as np
+import pyclipper
+import six
+from shapely.geometry import Polygon
+
+
+class DecodeImage(object):
+    """decode image"""
+
+    def __init__(self, img_mode='RGB', channel_first=False):
+        self.img_mode = img_mode
+        self.channel_first = channel_first
+
+    def __call__(self, data):
+        img = data['image']
+        if six.PY2:
+            assert (
+                type(img) is str and len(img) > 0
+            ), "invalid input 'img' in DecodeImage"
+        else:
+            assert (
+                type(img) is bytes and len(img) > 0
+            ), "invalid input 'img' in DecodeImage"
+
+        img = np.frombuffer(img, dtype='uint8')
+        img = cv2.imdecode(img, 1)
+        if img is None:
+            return None
+
+        if self.img_mode == 'GRAY':
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+        elif self.img_mode == 'RGB':
+            assert img.shape[2] == 3, f'invalid shape of image[{img.shape}]'
+            img = img[:, :, ::-1]
+
+        if self.channel_first:
+            img = img.transpose((2, 0, 1))
+        data['image'] = img
+        return data
+
+
+class NormalizeImage(object):
+    """normalize image such as substract mean, divide std"""
+
+    def __init__(self, scale=None, mean=None, std=None, order='chw'):
+        self.scale = np.float32(scale if scale is not None else 1.0 / 255.0)
+        mean = mean if mean is not None else [0.485, 0.456, 0.406]
+        std = std if std is not None else [0.229, 0.224, 0.225]
+        shape = (3, 1, 1) if order == 'chw' else (1, 1, 3)
+        self.mean = np.array(mean).reshape(shape).astype('float32')
+        self.std = np.array(std).reshape(shape).astype('float32')
+
+    def __call__(self, data):
+        img = np.array(data['image']).astype(np.float32)
+        data['image'] = (img * self.scale - self.mean) / self.std
+        return data
+
+
+class ToCHWImage(object):
+    """convert hwc image to chw image"""
+
+    def __init__(self):
+        pass
+
+    def __call__(self, data):
+        img = data['image']
+        data['image'] = img.transpose((2, 0, 1))
+        return data
+
+
+class KeepKeys(object):
+    def __init__(self, keep_keys):
+        self.keep_keys = keep_keys
+
+    def __call__(self, data):
+        data_list = []
+        for key in self.keep_keys:
+            data_list.append(data[key])
+        return data_list
+
+
+class DetResizeForTest(object):
+    def __init__(self, **kwargs):
+        super(DetResizeForTest, self).__init__()
+        self.resize_type = 0
+        if 'image_shape' in kwargs:
+            self.image_shape = kwargs['image_shape']
+            self.resize_type = 1
+        elif 'limit_side_len' in kwargs:
+            self.limit_side_len = kwargs['limit_side_len']
+            self.limit_type = kwargs.get('limit_type', 'min')
+        elif 'resize_long' in kwargs:
+            self.resize_type = 2
+            self.resize_long = kwargs.get('resize_long', 960)
+        else:
+            self.limit_side_len = 736
+            self.limit_type = 'min'
+
+    def __call__(self, data):
+        img = data['image']
+        src_h, src_w, _ = img.shape
+
+        if self.resize_type == 0:
+            # img, shape = self.resize_image_type0(img)
+            img, [ratio_h, ratio_w] = self.resize_image_type0(img)
+        elif self.resize_type == 2:
+            img, [ratio_h, ratio_w] = self.resize_image_type2(img)
+        else:
+            # img, shape = self.resize_image_type1(img)
+            img, [ratio_h, ratio_w] = self.resize_image_type1(img)
+        data['image'] = img
+        data['shape'] = np.array([src_h, src_w, ratio_h, ratio_w])
+        return data
+
+    def resize_image_type1(self, img):
+        resize_h, resize_w = self.image_shape
+        ori_h, ori_w = img.shape[:2]  # (h, w, c)
+        ratio_h = float(resize_h) / ori_h
+        ratio_w = float(resize_w) / ori_w
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        # return img, np.array([ori_h, ori_w])
+        return img, [ratio_h, ratio_w]
+
+    def resize_image_type0(self, img):
+        """
+        resize image to a size multiple of 32 which is required by the network
+        args:
+            img(array): array with shape [h, w, c]
+        return(tuple):
+            img, (ratio_h, ratio_w)
+        """
+        limit_side_len = self.limit_side_len
+        h, w, _ = img.shape
+
+        # limit the max side
+        if self.limit_type == 'max':
+            if max(h, w) > limit_side_len:
+                if h > w:
+                    ratio = float(limit_side_len) / h
+                else:
+                    ratio = float(limit_side_len) / w
+            else:
+                ratio = 1.0
+        else:
+            if min(h, w) < limit_side_len:
+                if h < w:
+                    ratio = float(limit_side_len) / h
+                else:
+                    ratio = float(limit_side_len) / w
+            else:
+                ratio = 1.0
+        resize_h = int(h * ratio)
+        resize_w = int(w * ratio)
+
+        resize_h = int(round(resize_h / 32) * 32)
+        resize_w = int(round(resize_w / 32) * 32)
+
+        try:
+            if int(resize_w) <= 0 or int(resize_h) <= 0:
+                return None, (None, None)
+            img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        except:
+            print(img.shape, resize_w, resize_h)
+            sys.exit(0)
+        ratio_h = resize_h / float(h)
+        ratio_w = resize_w / float(w)
+        return img, [ratio_h, ratio_w]
+
+    def resize_image_type2(self, img):
+        h, w, _ = img.shape
+
+        resize_w = w
+        resize_h = h
+
+        # Fix the longer side
+        if resize_h > resize_w:
+            ratio = float(self.resize_long) / resize_h
+        else:
+            ratio = float(self.resize_long) / resize_w
+
+        resize_h = int(resize_h * ratio)
+        resize_w = int(resize_w * ratio)
+
+        max_stride = 128
+        resize_h = (resize_h + max_stride - 1) // max_stride * max_stride
+        resize_w = (resize_w + max_stride - 1) // max_stride * max_stride
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        ratio_h = resize_h / float(h)
+        ratio_w = resize_w / float(w)
+
+        return img, [ratio_h, ratio_w]
+
+
+def transform(data, ops=None):
+    """transform"""
+    if ops is None:
+        ops = []
+
+    for op in ops:
+        data = op(data)
+        if data is None:
+            return None
+    return data
+
+
+def create_operators(op_param_list):
+    """
+    create operators based on the config
+    """
+    op_map = globals()
+    ops = []
+    for args in op_param_list:
+        args = deepcopy(args)
+        op_class = op_map[args.pop('class')]
+        ops.append(op_class(**args))
+    return ops
+
+
+def draw_text_det_res(dt_boxes, img_path):
+    src_im = cv2.imread(img_path)
+    for box in dt_boxes:
+        box = np.array(box).astype(np.int32).reshape(-1, 2)
+        cv2.polylines(src_im, [box], True, color=(255, 255, 0), thickness=2)
+    return src_im
+
+
+class DBPostProcess(object):
+    """The post process for Differentiable Binarization (DB)."""
+
+    def __init__(
+        self,
+        thresh=0.3,
+        box_thresh=0.7,
+        max_candidates=1000,
+        unclip_ratio=2.0,
+        use_dilation=False,
+    ):
+        self.thresh = thresh
+        self.box_thresh = box_thresh
+        self.max_candidates = max_candidates
+        self.unclip_ratio = unclip_ratio
+        self.min_size = 3
+
+        if use_dilation:
+            self.dilation_kernel = np.array([[1, 1], [1, 1]])
+        else:
+            self.dilation_kernel = None
+
+    def boxes_from_bitmap(self, pred, _bitmap, dest_width, dest_height):
+        '''
+        _bitmap: single map with shape (1, H, W),
+                whose values are binarized as {0, 1}
+        '''
+
+        bitmap = _bitmap
+        height, width = bitmap.shape
+
+        outs = cv2.findContours(
+            (bitmap * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE
+        )
+        if len(outs) == 3:
+            img, contours, _ = outs[0], outs[1], outs[2]
+        elif len(outs) == 2:
+            contours, _ = outs[0], outs[1]
+
+        num_contours = min(len(contours), self.max_candidates)
+
+        boxes = []
+        scores = []
+        for index in range(num_contours):
+            contour = contours[index]
+            points, sside = self.get_mini_boxes(contour)
+            if sside < self.min_size:
+                continue
+            points = np.array(points)
+            score = self.box_score_fast(pred, points.reshape(-1, 2))
+            if self.box_thresh > score:
+                continue
+
+            box = self.unclip(points).reshape(-1, 1, 2)
+            box, sside = self.get_mini_boxes(box)
+            if sside < self.min_size + 2:
+                continue
+            box = np.array(box)
+
+            box[:, 0] = np.clip(np.round(box[:, 0] / width * dest_width), 0, dest_width)
+            box[:, 1] = np.clip(
+                np.round(box[:, 1] / height * dest_height), 0, dest_height
+            )
+            boxes.append(box.astype(np.int16))
+            scores.append(score)
+        return np.array(boxes, dtype=np.int16), scores
+
+    def unclip(self, box):
+        unclip_ratio = self.unclip_ratio
+        poly = Polygon(box)
+        distance = poly.area * unclip_ratio / poly.length
+        offset = pyclipper.PyclipperOffset()
+        offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+        expanded = np.array(offset.Execute(distance))
+        return expanded
+
+    def get_mini_boxes(self, contour):
+        bounding_box = cv2.minAreaRect(contour)
+        points = sorted(list(cv2.boxPoints(bounding_box)), key=lambda x: x[0])
+
+        index_1, index_2, index_3, index_4 = 0, 1, 2, 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
+
+        box = [points[index_1], points[index_2], points[index_3], points[index_4]]
+        return box, min(bounding_box[1])
+
+    def box_score_fast(self, bitmap, _box):
+        h, w = bitmap.shape[:2]
+        box = _box.copy()
+        xmin = np.clip(np.floor(box[:, 0].min()).astype(int), 0, w - 1)
+        xmax = np.clip(np.ceil(box[:, 0].max()).astype(int), 0, w - 1)
+        ymin = np.clip(np.floor(box[:, 1].min()).astype(int), 0, h - 1)
+        ymax = np.clip(np.ceil(box[:, 1].max()).astype(int), 0, h - 1)
+
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        box[:, 0] = box[:, 0] - xmin
+        box[:, 1] = box[:, 1] - ymin
+        cv2.fillPoly(mask, box.reshape(1, -1, 2).astype(np.int32), 1)
+        return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0]
+
+    def __call__(self, pred, shape_list):
+        pred = pred[:, 0, :, :]
+        segmentation = pred > self.thresh
+
+        boxes_batch = []
+        for batch_index in range(pred.shape[0]):
+            src_h, src_w, ratio_h, ratio_w = shape_list[batch_index]
+            if self.dilation_kernel is not None:
+                mask = cv2.dilate(
+                    np.array(segmentation[batch_index]).astype(np.uint8),
+                    self.dilation_kernel,
+                )
+            else:
+                mask = segmentation[batch_index]
+            boxes, scores = self.boxes_from_bitmap(
+                pred[batch_index], mask, src_w, src_h
+            )
+
+            boxes_batch.append({'points': boxes})
+        return boxes_batch

ocrweb_multi/rapidocr/main.py

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+# @Author: SWHL
+# @Contact: liekkaskono@163.com
+import copy
+from functools import lru_cache
+from pathlib import Path
+
+import numpy as np
+import cv2
+
+from utils.config import conf
+from rapidocr.rapid_ocr_api import TextSystem
+
+
+@lru_cache(maxsize=None)
+def load_language_model(lang='ch'):
+    models = conf['languages'][lang]
+    print('model', models)
+    return TextSystem(models)
+
+
+def detect_recognize(image, lang='ch', detect=True, classify=True):
+    model = load_language_model(lang)
+    results, ts = model(image, detect=detect, classify=classify)
+    ts['total'] = sum(ts.values())
+    return {'ts': ts, 'results': results}
+
+
+def check_and_read_gif(img_path):
+    if Path(img_path).name[-3:] in ['gif', 'GIF']:
+        gif = cv2.VideoCapture(img_path)
+        ret, frame = gif.read()
+        if not ret:
+            print("Cannot read {}. This gif image maybe corrupted.")
+            return None, False
+        if len(frame.shape) == 2 or frame.shape[-1] == 1:
+            frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
+        imgvalue = frame[:, :, ::-1]
+        return imgvalue, True
+    return None, False
+
+
+def draw_text_det_res(dt_boxes, raw_im):
+    src_im = copy.deepcopy(raw_im)
+    for i, box in enumerate(dt_boxes):
+        box = np.array(box).astype(np.int32).reshape(-1, 2)
+        cv2.polylines(src_im, [box], True, color=(0, 0, 255), thickness=1)
+        cv2.putText(
+            src_im,
+            str(i),
+            (int(box[0][0]), int(box[0][1])),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.5,
+            (0, 0, 0),
+            2,
+        )
+    return src_im

ocrweb_multi/rapidocr/rapid_ocr_api.py

@@ -0,0 +1,160 @@
+# !/usr/bin/env python
+# -*- encoding: utf-8 -*-
+import copy
+
+import cv2
+import numpy as np
+
+from functools import lru_cache
+from utils.config import conf
+from utils.utils import Ticker
+from .classify import TextClassifier
+from .detect import TextDetector
+from .recognize import TextRecognizer
+
+
+def get_rotate_crop_image(img, points):
+    """根据box定义, 从图像中截取相应的部分, 通过透视变换转换为标准长方形图像"""
+    img_crop_width = int(
+        max(
+            np.linalg.norm(points[0] - points[1]),
+            np.linalg.norm(points[2] - points[3]),
+        )
+    )
+    img_crop_height = int(
+        max(
+            np.linalg.norm(points[0] - points[3]),
+            np.linalg.norm(points[1] - points[2]),
+        )
+    )
+    pts_std = np.float32(
+        [
+            [0, 0],
+            [img_crop_width, 0],
+            [img_crop_width, img_crop_height],
+            [0, img_crop_height],
+        ]
+    )
+    transform = cv2.getPerspectiveTransform(points, pts_std)
+    dst_img = cv2.warpPerspective(
+        img,
+        transform,
+        (img_crop_width, img_crop_height),
+        borderMode=cv2.BORDER_REPLICATE,
+        flags=cv2.INTER_CUBIC,
+    )
+    dst_img_height, dst_img_width = dst_img.shape[:2]
+    # 将竖向的文字方向转为横向, 仅当 高>1.5*宽 时进行转换
+    if dst_img_height * 1.0 / dst_img_width >= 1.5:
+        dst_img = np.rot90(dst_img)
+    return dst_img
+
+
+@lru_cache(maxsize=None)
+def load_onnx_model(step, name):
+    model_config = conf['models'][step][name]
+    model_class = {
+        'detect': TextDetector,
+        'classify': TextClassifier,
+        'recognize': TextRecognizer,
+    }[step]
+    return model_class(model_config['path'], model_config.get('config'))
+
+
+class TextSystem(object):
+    def __init__(self, config):
+        super(TextSystem).__init__()
+        self.config = config
+        self.text_score = config['config']['text_score']
+        self.min_height = config['config']['min_height']
+
+        models = config['models']
+        self.text_detector = load_onnx_model('detect', models['detect'])
+        self.text_recognizer = load_onnx_model('recognize', models['recognize'])
+        self.text_cls = load_onnx_model('classify', models['classify'])
+
+    def __call__(self, img: np.ndarray, detect=True, classify=True):
+        ticker = Ticker()
+        h, w = img.shape[:2]
+        if not detect or h < self.min_height:
+            dt_boxes, img_crop_list = self.get_boxes_img_without_det(img, h, w)
+            ticker.tick('detect')
+        else:
+            dt_boxes = self.text_detector(img)
+            ticker.tick('detect')
+
+            if dt_boxes is None or len(dt_boxes) < 1:
+                return [], ticker.maps
+            if conf['global']['verbose']:
+                print(f'boxes num: {len(dt_boxes)}')
+
+            dt_boxes = self.sorted_boxes(dt_boxes)
+
+            img_crop_list = self.get_crop_img_list(img, dt_boxes)
+            ticker.tick('post-detect')
+
+        if classify:
+            # 进行子图像角度修正
+            img_crop_list, _ = self.text_cls(img_crop_list)
+            ticker.tick('classify')
+            if conf['global']['verbose']:
+                print(f'cls num: {len(img_crop_list)}')
+
+        recog_result = self.text_recognizer(img_crop_list)
+        ticker.tick('recognize')
+        if conf['global']['verbose']:
+            print(f'rec_res num: {len(recog_result)}')
+
+        results = self.filter_boxes_rec_by_score(dt_boxes, recog_result)
+        ticker.tick('post-recognize')
+        return results, ticker.maps
+
+    def get_boxes_img_without_det(self, img, h, w):
+        x0, y0, x1, y1 = 0, 0, w, h
+        dt_boxes = np.array([[x0, y0], [x1, y0], [x1, y1], [x0, y1]])
+        dt_boxes = dt_boxes[np.newaxis, ...]
+        img_crop_list = [img]
+        return dt_boxes, img_crop_list
+
+    def get_crop_img_list(self, img, dt_boxes):
+        img_crop_list = []
+        for box in dt_boxes:
+            tmp_box = copy.deepcopy(box)
+            img_crop = get_rotate_crop_image(img, tmp_box)
+            img_crop_list.append(img_crop)
+        return img_crop_list
+
+    @staticmethod
+    def sorted_boxes(dt_boxes):
+        """对文本框检测结果进行排序, 调整为从上到下、从左到右
+
+        args:
+            dt_boxes(array): detected text boxes with shape [4, 2]
+        return:
+            sorted boxes(array) with shape [4, 2]
+        """
+
+        class AlignBox(object):
+            def __init__(self, data) -> None:
+                self.data = data
+                self.x = data[0][0]
+                self.y = data[0][1]
+
+            def __lt__(self, other: 'AlignBox'):
+                dy = self.y - other.y
+                # y差距小于10, 视为相等, 根据x排序
+                if abs(dy) < 10:
+                    return self.x < other.x
+                # 否则根据y排序
+                return dy < 0
+
+        align_boxes = sorted([AlignBox(b) for b in dt_boxes])
+        return [b.data for b in align_boxes]
+
+    def filter_boxes_rec_by_score(self, dt_boxes, rec_res):
+        results = []
+        for box, rec_reuslt in zip(dt_boxes, rec_res):
+            text, score = rec_reuslt
+            if score >= self.text_score:
+                results.append({'box': box, 'text': text, 'score': score})
+        return results

ocrweb_multi/rapidocr/recognize.py

@@ -0,0 +1,160 @@
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import argparse
+import json
+import math
+import time
+from typing import List
+
+import cv2
+import numpy as np
+
+from utils.utils import get_resource_path, OrtInferSession
+
+
+class CTCLabelDecode(object):
+    """Convert between text-label and text-index"""
+
+    def __init__(self, characters: List[str]):
+        super(CTCLabelDecode, self).__init__()
+
+        self.characters = characters
+        self.characters.append(' ')
+
+        dict_character = self.add_special_char(self.characters)
+        self.character = dict_character
+
+        self.dict = {}
+        for i, char in enumerate(dict_character):
+            self.dict[char] = i
+
+    def __call__(self, preds, label=None):
+        preds_idx = preds.argmax(axis=2)
+        preds_prob = preds.max(axis=2)
+        text = self.decode(preds_idx, preds_prob, is_remove_duplicate=True)
+        if label is None:
+            return text
+        label = self.decode(label)
+        return text, label
+
+    def add_special_char(self, dict_character):
+        dict_character = ['blank'] + dict_character
+        return dict_character
+
+    def get_ignored_tokens(self):
+        return [0]  # for ctc blank
+
+    def decode(self, text_index, text_prob=None, is_remove_duplicate=False):
+        """convert text-index into text-label."""
+
+        result_list = []
+        ignored_tokens = self.get_ignored_tokens()
+        batch_size = len(text_index)
+        for batch_idx in range(batch_size):
+            char_list = []
+            conf_list = []
+            for idx in range(len(text_index[batch_idx])):
+                if text_index[batch_idx][idx] in ignored_tokens:
+                    continue
+                if is_remove_duplicate:
+                    # only for predict
+                    if (
+                        idx > 0
+                        and text_index[batch_idx][idx - 1] == text_index[batch_idx][idx]
+                    ):
+                        continue
+                char_list.append(self.character[int(text_index[batch_idx][idx])])
+                if text_prob is not None:
+                    conf_list.append(text_prob[batch_idx][idx])
+                else:
+                    conf_list.append(1)
+            # avoid `Mean of empty slice.` warning
+            score = np.mean(conf_list) if conf_list else 0
+            text = ''.join(char_list)
+            result_list.append((text, score))
+        return result_list
+
+
+class TextRecognizer(object):
+    def __init__(self, path, config):
+        self.rec_batch_num = config.get('rec_batch_num', 6)
+
+        session_instance = OrtInferSession(path)
+        self.session = session_instance.session
+
+        metamap = session_instance.session.get_modelmeta().custom_metadata_map
+        chars = metamap['dictionary'].splitlines()
+        self.postprocess_op = CTCLabelDecode(chars)
+        self.rec_image_shape = json.loads(metamap['shape'])
+        self.input_name = session_instance.get_input_name()
+
+    def resize_norm_img(self, img, max_wh_ratio):
+        img_channel, img_height, img_width = self.rec_image_shape
+        assert img_channel == img.shape[2]
+
+        img_width = int((32 * max_wh_ratio))
+        max_wh_ratio = 1
+
+        h, w = img.shape[:2]
+        ratio = w / float(h)
+        if math.ceil(img_height * ratio) > img_width:
+            resized_w = img_width
+        else:
+            resized_w = int(math.ceil(img_height * ratio))
+
+        resized_image = cv2.resize(img, (resized_w, img_height))
+        resized_image = resized_image.astype('float32')
+        resized_image = resized_image.transpose((2, 0, 1)) / 255
+        resized_image -= 0.5
+        resized_image /= 0.5
+
+        padding_im = np.zeros((img_channel, img_height, img_width), dtype=np.float32)
+        padding_im[:, :, 0:resized_w] = resized_image
+        return padding_im
+
+    def __call__(self, img_list: List[np.ndarray]):
+        if isinstance(img_list, np.ndarray):
+            img_list = [img_list]
+
+        # Calculate the aspect ratio of all text bars
+        width_list = [img.shape[1] / float(img.shape[0]) for img in img_list]
+
+        # Sorting can speed up the recognition process
+        indices = np.argsort(np.array(width_list))
+
+        img_num = len(img_list)
+        rec_res = [['', 0.0]] * img_num
+
+        batch_num = self.rec_batch_num
+        for beg_img_no in range(0, img_num, batch_num):
+            end_img_no = min(img_num, beg_img_no + batch_num)
+            max_wh_ratio = 0
+            for ino in range(beg_img_no, end_img_no):
+                h, w = img_list[indices[ino]].shape[0:2]
+                wh_ratio = w * 1.0 / h
+                max_wh_ratio = max(max_wh_ratio, wh_ratio)
+
+            norm_img_batch = []
+            for ino in range(beg_img_no, end_img_no):
+                norm_img = self.resize_norm_img(img_list[indices[ino]], max_wh_ratio)
+                norm_img_batch.append(norm_img[np.newaxis, :])
+            norm_img_batch = np.concatenate(norm_img_batch).astype(np.float32)
+
+            onnx_inputs = {self.input_name: norm_img_batch}
+            preds = self.session.run(None, onnx_inputs)[0]
+            rec_result = self.postprocess_op(preds)
+
+            for rno in range(len(rec_result)):
+                rec_res[indices[beg_img_no + rno]] = rec_result[rno]
+        return rec_res

ocrweb_multi/requirements.txt

@@ -0,0 +1,9 @@
+onnxruntime>=1.7.0
+opencv-python-headless==4.5.4.60
+six>=1.15.0
+pyclipper>=1.2.1
+numpy>=1.19.1
+Shapely>=1.7.1
+Flask>=2.1.2
+PyYAML
+waitress

ocrweb_multi/static/css/main.css

@@ -0,0 +1,150 @@
+html {
+    height: 100%;
+    margin: 0;
+}
+
+body {
+    background-color: #ebedef;
+    min-height: 100%;
+    margin: 0;
+}
+
+.btn-gen {
+    background-color: #00a1d6;
+    text-align: center;
+    border-radius: 18px;
+    margin: 0 5px 0 5px;
+    font-size: 15px;
+    padding: 5px 10px;
+    height: 20px;
+    min-width: 120px;
+    text-transform: uppercase;
+    color: #fff;
+    border: none;
+}
+
+.btn-gen:hover,
+.btn-gen:focus {
+    border-color: #23AAEE;
+    background-color: #23AAEE;
+    color: white;
+    cursor: pointer;
+}
+
+.row {
+    margin: 15px;
+}
+
+.small {
+    font-size: 0.8em;
+}
+
+.verysmall {
+    font-size: 0.5em;
+}
+
+.area {
+    text-align: center;
+    height: auto;
+    margin: auto;
+}
+
+.leftarea {
+    float: left;
+    width: 50%;
+    height: auto;
+    position: relative;
+}
+
+.rightarea {
+    float: left;
+    width: 50%;
+    height: auto;
+    overflow-y: auto;
+}
+
+.table {
+    width: auto;
+    height: auto;
+    margin: 0 auto;
+
+}
+
+.span_title {
+    width: 98%;
+    height: 36px;
+    margin-top: 4px;
+    line-height: 32px;
+    background-color: #00a1d6;
+    border: 1px solid #00a1d6;
+    border-radius: 20px;
+    color: #fff;
+    display: inline-block;
+    text-align: center;
+    font-size: 22px;
+    transition: .3s;
+    box-sizing: border-box;
+    cursor: default;
+}
+
+.uplodNote {
+    font-size: 10px;
+    color: #A1A1A1;
+}
+
+a {
+    text-decoration: none;
+}
+
+#input-hint {
+    margin: auto;
+    cursor: pointer;
+
+}
+
+#result_view {
+    position: relative;
+    width: 95%;
+    margin: auto;
+}
+
+#result_view img,
+#result_view canvas {
+    width: 100%;
+    height: 100%;
+}
+
+#result_view canvas {
+    position: absolute;
+    left: 0;
+    top: 0;
+}
+
+/* wrapper */
+#wrapper {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background:
+        linear-gradient(#1a98ca, #1a98ca),
+        linear-gradient(90deg, #ffffff33 1px, transparent 0, transparent 19px),
+        linear-gradient(#ffffff33 1px, transparent 0, transparent 19px),
+        linear-gradient(transparent, #1a98ca);
+    background-size: 100% 1.5%, 10% 100%, 100% 8%, 100% 100%;
+    background-repeat: no-repeat, repeat, repeat, no-repeat;
+    background-position: 0% 100%, 0 0, 0 0, 0 0;
+    /* 初始位置 */
+    clip-path: polygon(0% 0%, 100% 0%, 100% 1.5%, 0% 1.5%);
+    /* 添加动画效果 */
+    animation: move 1s infinite linear;
+}
+
+@keyframes move {
+    to {
+        background-position: 0 100%, 0 0, 0 0, 0 0;
+        /* 终止位置 */
+        clip-path: polygon(0% 0%, 100% 0%, 100% 100%, 0% 100%);
+    }
+}

ocrweb_multi/static/hint.svg

@@ -0,0 +1,4 @@
+<svg viewBox="0 0 400 200"
+  xmlns="http://www.w3.org/2000/svg">
+  <text x="4" y="20" class="large">未选择图片</text>
+</svg>

ocrweb_multi/static/index.html

@@ -0,0 +1,221 @@
+<!DOCTYPE html>
+<html lang="zh">
+
+<head>
+    <meta charset="UTF-8">
+    <title>RapidOCR Demo</title>
+    <link rel=stylesheet type="text/css" href="/static/css/main.css">
+    <link rel="shortcut icon" href="/static/favicon.ico" type="image/x-icon" />
+    <style>
+        h1 {
+            text-align: center;
+            margin: 0;
+        }
+
+        div.header {
+            padding: 10px;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="header">
+        <h1>
+            Rapid🗲OCR Demo
+            &thinsp;
+            <a href="https://github.com/RapidAI/RapidOCR" class="verysmall">欢迎Star</a>&thinsp;
+            <a href="https://github.com/RapidAI/RapidOCR/tree/main/ocrweb#readme" class="verysmall">了解Demo</a>
+        </h1>
+    </div>
+    <div class="area">
+        <input type="file" style="display: none;" name="pic" id="target_image" />
+        <div id="input-hint" class="row">
+            <span class="btn-gen">选择图片 <span class="small">支持拖拽/粘贴/点击; 支持常见图片格式; 大小不超过3M</span></span>
+        </div>
+        <div class="row">
+            <span>选择语言:</span>
+            <span id="langs"></span>
+        </div>
+    </div>
+    <div class="area">
+        <div class="leftarea" id="detectDiv">
+            <span class="span_title">文 本 检 测 结 果</span><br /><br />
+            <div id="result_view">
+                <img src="/static/hint.svg" alt="目标图片">
+                <canvas id="overlay"></canvas>
+                <div id="wrapper" style="display: none"></div>
+            </div>
+        </div>
+        <div class="rightarea" id="recogDiv">
+            <span id="rec_res" class="span_title">文 本 识 别 结 果</span>
+            <br /><br />
+            <table id="locTable" class="table" cellspacing="0" cellpadding="5"></table>
+        </div>
+    </div>
+    <script src="/static/js/jquery-3.0.0.min.js"></script>
+    <script type="text/javascript">
+        const cvs = $('canvas')[0];
+        const ctx = cvs.getContext('2d');
+        var targetFile = null;
+        $(function () {
+            // onload
+            $.ajax({
+                url: '/lang',
+                type: 'GET',
+                success: (data) => {
+                    console.log(data);
+                    let langs = $('#langs');
+                    langs.html('');
+                    let checked = ' checked';
+                    for (let item of data.data) {
+                        langs.append(`<label class="btn-gen"><input name="lang" type="radio" value="${item.code}"${checked}>${item.name}</label>`);
+                        checked = '';
+                    }
+                    $('input[name=lang]').on('change', requestOCR);
+                }
+            })
+        })
+
+        $('#result_view > img').on('load', function (e) {
+            cvs.width = e.target.naturalWidth;
+            cvs.height = e.target.naturalHeight;
+        });
+        $('#input-hint').on('click', function (e) {
+            $('#target_image').click();
+        });
+        $('body').on('dragover', function (e) {
+            e.preventDefault();
+        });
+        $('body').on('drop', function (e) {
+            e.preventDefault();
+            let trans = e.originalEvent.dataTransfer;
+            if (trans.items) {
+                for (let i = 0; i < trans.items.length; i++) {
+                    // If dropped items aren't files, reject them
+                    if (trans.items[i].kind === 'file') {
+                        targetFile = trans.items[i].getAsFile();
+                        // console.log(`… file[${i}].name = ${targetFile.name}`);
+                        requestOCR();
+                        return;
+                    }
+                }
+            } else {
+                // Use DataTransfer interface to access the file(s)
+                for (let i = 0; i < trans.files.length; i++) {
+                    // console.log(`… file[${i}].name = ${trans.files[i].name}`);
+                    targetFile = trans.files[i];
+                    requestOCR();
+                    return;
+                }
+            }
+        });
+        $("#target_image").on('change', function () {
+            targetFile = $("#target_image")[0].files[0];
+            console.log('Use file', targetFile)
+            requestOCR();
+        });
+        function getTs(ts, keys) {
+            let t = 0;
+            for (let key of keys) {
+                t += (ts[key] || 0);
+            }
+            return t.toFixed(4);
+        }
+        function drawPolyLines(points) {
+            ctx.moveTo(points[0][0], points[0][1]);
+            for (let pt of points) {
+                ctx.lineTo(pt[0], pt[1]);
+            }
+            ctx.lineTo(points[0][0], points[0][1]);
+            ctx.stroke();
+        }
+        function requestOCR() {
+            if (!targetFile) {
+                return;
+            }
+            // 判断图像格式是否匹配
+            let imageName = targetFile.name;
+            let index = imageName.lastIndexOf('.');
+            let extName = imageName.substr(index + 1);
+            let imgArr = ['jpg', 'bmp', 'png', 'jpeg'];
+            if (!(imgArr.includes(extName.toLocaleLowerCase()))) {
+                alert("图像文件格式不支持！");
+                return;
+            }
+
+            // 判断图像大小是否符合
+            let imageSize = targetFile.size / 1024 / 1024;
+            if (imageSize >= 3) {
+                alert("图像大小超过3M!");
+                return;
+            }
+            var reader = new FileReader();
+            reader.onload = function (e) {
+                $('#result_view > img').attr('src', e.target.result);
+            };
+            reader.readAsDataURL(targetFile);
+
+            var formdata = new FormData();
+            formdata.set('image', targetFile);
+            formdata.set('lang', $('input[name=lang]:checked').val());
+
+            $.ajax({
+                url: "/ocr",
+                type: "POST",
+                data: formdata,
+                processData: false,
+                contentType: false,
+                beforeSend: function () {
+                    $("#wrapper").show();
+                    $("#locTable").hide();
+                    $("#rec_res").html("文本识别结果");
+                },
+                error: function (evt) {
+                    console.log(evt);
+                    alert('检测失败: ' + evt);
+                },
+                success: function (resp) {
+                    $("#wrapper").hide();
+                    if (resp.msg !== 'OK') {
+                        alert('检测失败: ', resp.msg);
+                        return;
+                    }
+                    let data = resp.data;
+                    $("#rec_res").html("文 本 检 测 结 果(Total:" + data.ts.total.toFixed(3) + "s)")
+                    $("#rec_res").show();
+                    let html = [];
+                    html.push('<tr>' +
+                        '<th align="right">Det: ' + getTs(data.ts, ['detect', 'post-detect']) + 's</th>' +
+                        '<th align="center">Cls: ' + getTs(data.ts, ['classify', 'post-classify']) + 's</th>' +
+                        '<th align="left">Rec: ' + getTs(data.ts, ['recognize', 'post-recognize']) + 's</th>' +
+                        "</tr>")
+                    html.push("<tr>" +
+                        '<th bgcolor="#C0C0C0">序号</th>' +
+                        '<th bgcolor="#C0C0C0">识别结果</th>' +
+                        '<th bgcolor="#C0C0C0">置信度</th>' +
+                        "</tr>")
+                    ctx.strokeStyle = '#ff0000'
+                    ctx.font = '16px sans-serif'
+                    ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+                    for (let idx = 0; idx < data.results.length; idx++) {
+                        let result = data.results[idx];
+                        drawPolyLines(result.box);
+                        ctx.fillText(idx, result.box[0][0], result.box[0][1]);
+                        ctx.strokeText(idx, result.box[0][0], result.box[0][1]);
+                        html.push('<tr><td>');
+                        html.push(idx);
+                        html.push('</td><td>');
+                        html.push(result.text);
+                        html.push('</td><td>');
+                        html.push(result.score.toFixed(4));
+                        html.push('</td></tr>');
+                    }
+                    $("#locTable").html(html.join(''));
+                    $("#locTable").show();
+                }
+            });
+        }
+    </script>
+</body>
+
+</html>

ocrweb_multi/static/js/jquery-3.0.0.min.js

@@ -0,0 +1,4 @@
+/*! jQuery v3.0.0 | (c) jQuery Foundation | jquery.org/license */
+!function(a,b){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){"use strict";var c=[],d=a.document,e=Object.getPrototypeOf,f=c.slice,g=c.concat,h=c.push,i=c.indexOf,j={},k=j.toString,l=j.hasOwnProperty,m=l.toString,n=m.call(Object),o={};function p(a,b){b=b||d;var c=b.createElement("script");c.text=a,b.head.appendChild(c).parentNode.removeChild(c)}var q="3.0.0",r=function(a,b){return new r.fn.init(a,b)},s=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,t=/^-ms-/,u=/-([a-z])/g,v=function(a,b){return b.toUpperCase()};r.fn=r.prototype={jquery:q,constructor:r,length:0,toArray:function(){return f.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:f.call(this)},pushStack:function(a){var b=r.merge(this.constructor(),a);return b.prevObject=this,b},each:function(a){return r.each(this,a)},map:function(a){return this.pushStack(r.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(f.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor()},push:h,sort:c.sort,splice:c.splice},r.extend=r.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||r.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(a=arguments[h]))for(b in a)c=g[b],d=a[b],g!==d&&(j&&d&&(r.isPlainObject(d)||(e=r.isArray(d)))?(e?(e=!1,f=c&&r.isArray(c)?c:[]):f=c&&r.isPlainObject(c)?c:{},g[b]=r.extend(j,f,d)):void 0!==d&&(g[b]=d));return g},r.extend({expando:"jQuery"+(q+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===r.type(a)},isArray:Array.isArray,isWindow:function(a){return null!=a&&a===a.window},isNumeric:function(a){var b=r.type(a);return("number"===b||"string"===b)&&!isNaN(a-parseFloat(a))},isPlainObject:function(a){var b,c;return a&&"[object Object]"===k.call(a)?(b=e(a))?(c=l.call(b,"constructor")&&b.constructor,"function"==typeof c&&m.call(c)===n):!0:!1},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?j[k.call(a)]||"object":typeof a},globalEval:function(a){p(a)},camelCase:function(a){return a.replace(t,"ms-").replace(u,v)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b){var c,d=0;if(w(a)){for(c=a.length;c>d;d++)if(b.call(a[d],d,a[d])===!1)break}else for(d in a)if(b.call(a[d],d,a[d])===!1)break;return a},trim:function(a){return null==a?"":(a+"").replace(s,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(w(Object(a))?r.merge(c,"string"==typeof a?[a]:a):h.call(c,a)),c},inArray:function(a,b,c){return null==b?-1:i.call(b,a,c)},merge:function(a,b){for(var c=+b.length,d=0,e=a.length;c>d;d++)a[e++]=b[d];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,e,f=0,h=[];if(w(a))for(d=a.length;d>f;f++)e=b(a[f],f,c),null!=e&&h.push(e);else for(f in a)e=b(a[f],f,c),null!=e&&h.push(e);return g.apply([],h)},guid:1,proxy:function(a,b){var c,d,e;return"string"==typeof b&&(c=a[b],b=a,a=c),r.isFunction(a)?(d=f.call(arguments,2),e=function(){return a.apply(b||this,d.concat(f.call(arguments)))},e.guid=a.guid=a.guid||r.guid++,e):void 0},now:Date.now,support:o}),"function"==typeof Symbol&&(r.fn[Symbol.iterator]=c[Symbol.iterator]),r.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),function(a,b){j["[object "+b+"]"]=b.toLowerCase()});function w(a){var b=!!a&&"length"in a&&a.length,c=r.type(a);return"function"===c||r.isWindow(a)?!1:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var x=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u="sizzle"+1*new Date,v=a.document,w=0,x=0,y=ha(),z=ha(),A=ha(),B=function(a,b){return a===b&&(l=!0),0},C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=function(a,b){for(var c=0,d=a.length;d>c;c++)if(a[c]===b)return c;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\x00-\\xa0])+",M="\\["+K+"*("+L+")(?:"+K+"*([*^$|!~]?=)"+K+"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|("+L+"))|)"+K+"*\\]",N=":("+L+")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|"+M+")*)|.*)\\)|)",O=new RegExp(K+"+","g"),P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")Line truncated
+return j.call(r(a),c)})),b))for(;i>h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},T=function(a){return 1===a.nodeType||9===a.nodeType||!+a.nodeType};function U(){this.expando=r.expando+U.uid++}U.uid=1,U.prototype={cache:function(a){var b=a[this.expando];return b||(b={},T(a)&&(a.nodeType?a[this.expando]=b:Object.defineProperty(a,this.expando,{value:b,configurable:!0}))),b},set:function(a,b,c){var d,e=this.cache(a);if("string"==typeof b)e[r.camelCase(b)]=c;else for(d in b)e[r.camelCase(d)]=b[d];return e},get:function(a,b){return void 0===b?this.cache(a):a[this.expando]&&a[this.expando][r.camelCase(b)]},access:function(a,b,c){return void 0===b||b&&"string"==typeof b&&void 0===c?this.get(a,b):(this.set(a,b,c),void 0!==c?c:b)},remove:function(a,b){var c,d=a[this.expando];if(void 0!==d){if(void 0!==b){r.isArray(b)?b=b.map(r.camelCase):(b=r.camelCase(b),b=b in d?[b]:b.match(K)||[]),c=b.length;while(c--)delete d[b[c]]}(void 0===b||r.isEmptyObject(d))&&(a.nodeType?a[this.expando]=void 0:delete a[this.expando])}},hasData:function(a){var b=a[this.expando];return void 0!==b&&!r.isEmptyObject(b)}};var V=new U,W=new U,X=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,Y=/[A-Z]/g;function Z(a,b,c){var d;if(void 0===c&&1===a.nodeType)if(d="data-"+b.replace(Y,"-$&").toLowerCase(),c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:X.test(c)?JSON.parse(c):c}catch(e){}W.set(a,b,c)}else c=void 0;return c}r.extend({hasData:function(a){return W.hasData(a)||V.hasData(a)},data:function(a,b,c){return W.access(a,b,c)},removeData:function(a,b){W.remove(a,b)},_data:function(a,b,c){return V.access(a,b,c)},_removeData:function(a,b){V.remove(a,b)}}),r.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=W.get(f),1===f.nodeType&&!V.get(f,"hasDataAttrs"))){c=g.length;while(c--)g[c]&&(d=g[c].name,0===d.indexOf("data-")&&(d=r.camelCase(d.slice(5)),Z(f,d,e[d])));V.set(f,"hasDataAttrs",!0)}return e}return"object"==typeof a?this.each(function(){W.set(this,a)}):S(this,function(b){var c;if(f&&void 0===b){if(c=W.get(f,a),void 0!==c)return c;if(c=Z(f,a),void 0!==c)return c}else this.each(function(){W.set(this,a,b)})},null,b,arguments.length>1,null,!0)},removeData:function(a){return this.each(function(){W.remove(this,a)})}}),r.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=V.get(a,b),c&&(!d||r.isArray(c)?d=V.access(a,b,r.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=r.queue(a,b),d=c.length,e=c.shift(),f=r._queueHooks(a,b),g=function(){r.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return V.get(a,c)||V.access(a,c,{empty:r.Callbacks("once memory").add(function(){V.remove(a,[b+"queue",c])})})}}),r.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?r.queue(this[0],a):void 0===b?this:this.each(function(){var c=r.queue(this,a,b);r._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&r.dequeue(this,a)})},dequeue:function(a){return this.each(function(){r.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=r.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=V.get(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var $=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,_=new RegExp("^(?:([+-])=|)("+$+")([a-z%]*)$","i"),aa=["Top","Right","Bottom","Left"],ba=function(a,b){return a=b||a,"none"===a.style.display||""===a.style.display&&r.contains(a.ownerDocument,a)&&"none"===r.css(a,"display")},ca=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};function da(a,b,c,d){var e,f=1,g=20,h=d?function(){return d.cur()}:function(){return r.css(a,b,"")},i=h(),j=c&&c[3]||(r.cssNumber[b]?"":"px"),k=(r.cssNumber[b]||"px"!==j&&+i)&&_.exec(r.css(a,b));if(k&&k[3]!==j){j=j||k[3],c=c||[],k=+i||1;do f=f||".5",k/=f,r.style(a,b,k+j);while(f!==(f=h()/i)&&1!==f&&--g)}return c&&(k=+k||+i||0,e=c[1]?k+(c[1]+1)*c[2]:+c[2],d&&(d.unit=j,d.start=k,d.end=e)),e}var ea={};function fa(a){var b,c=a.ownerDocument,d=a.nodeName,e=ea[d];return e?e:(b=c.body.appendChild(c.createElement(d)),e=r.css(b,"display"),b.parentNode.removeChild(b),"none"===e&&(e="block"),ea[d]=e,e)}function ga(a,b){for(var c,d,e=[],f=0,g=a.length;g>f;f++)d=a[f],d.style&&(c=d.style.display,b?("none"===c&&(e[f]=V.get(d,"display")||null,e[f]||(d.style.display="")),""===d.style.display&&ba(d)&&(e[f]=fa(d))):"none"!==c&&(e[f]="none",V.set(d,"display",c)));for(f=0;g>f;f++)null!=e[f]&&(a[f].style.display=e[f]);return a}r.fn.extend({show:function(){return ga(this,!0)},hide:function(){return ga(this)},toggle:function(a){return"boolean"==typeof a?Line truncated
+}}),hb={set:function(a,b,c){return b===!1?r.removeAttr(a,c):a.setAttribute(c,c),c}},r.each(r.expr.match.bool.source.match(/\w+/g),function(a,b){var c=ib[b]||r.find.attr;ib[b]=function(a,b,d){var e,f,g=b.toLowerCase();return d||(f=ib[g],ib[g]=e,e=null!=c(a,b,d)?g:null,ib[g]=f),e}});var jb=/^(?:input|select|textarea|button)$/i,kb=/^(?:a|area)$/i;r.fn.extend({prop:function(a,b){return S(this,r.prop,a,b,arguments.length>1)},removeProp:function(a){return this.each(function(){delete this[r.propFix[a]||a]})}}),r.extend({prop:function(a,b,c){var d,e,f=a.nodeType;if(3!==f&&8!==f&&2!==f)return 1===f&&r.isXMLDoc(a)||(b=r.propFix[b]||b,e=r.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=r.find.attr(a,"tabindex");return b?parseInt(b,10):jb.test(a.nodeName)||kb.test(a.nodeName)&&a.href?0:-1}}},propFix:{"for":"htmlFor","class":"className"}}),o.optSelected||(r.propHooks.selected={get:function(a){var b=a.parentNode;return b&&b.parentNode&&b.parentNode.selectedIndex,null},set:function(a){var b=a.parentNode;b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex)}}),r.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){r.propFix[this.toLowerCase()]=this});var lb=/[\t\r\n\f]/g;function mb(a){return a.getAttribute&&a.getAttribute("class")||""}r.fn.extend({addClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).addClass(a.call(this,b,mb(this)))});if("string"==typeof a&&a){b=a.match(K)||[];while(c=this[i++])if(e=mb(c),d=1===c.nodeType&&(" "+e+" ").replace(lb," ")){g=0;while(f=b[g++])d.indexOf(" "+f+" ")<0&&(d+=f+" ");h=r.trim(d),e!==h&&c.setAttribute("class",h)}}return this},removeClass:function(a){var b,c,d,e,f,g,h,i=0;if(r.isFunction(a))return this.each(function(b){r(this).removeClass(a.call(this,b,mb(this)))});if(!arguments.length)return this.attr("class","");if("string"==typeof a&&a){b=a.match(K)||[];while(c=this[i++])if(e=mb(c),d=1===c.nodeType&&(" "+e+" ").replace(lb," ")){g=0;while(f=b[g++])while(d.indexOf(" "+f+" ")>-1)d=d.replace(" "+f+" "," ");h=r.trim(d),e!==h&&c.setAttribute("class",h)}}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):r.isFunction(a)?this.each(function(c){r(this).toggleClass(a.call(this,c,mb(this),b),b)}):this.each(function(){var b,d,e,f;if("string"===c){d=0,e=r(this),f=a.match(K)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else void 0!==a&&"boolean"!==c||(b=mb(this),b&&V.set(this,"__className__",b),this.setAttribute&&this.setAttribute("class",b||a===!1?"":V.get(this,"__className__")||""))})},hasClass:function(a){var b,c,d=0;b=" "+a+" ";while(c=this[d++])if(1===c.nodeType&&(" "+mb(c)+" ").replace(lb," ").indexOf(b)>-1)return!0;return!1}});var nb=/\r/g,ob=/[\x20\t\r\n\f]+/g;r.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=r.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,r(this).val()):a,null==e?e="":"number"==typeof e?e+="":r.isArray(e)&&(e=r.map(e,function(a){return null==a?"":a+""})),b=r.valHooks[this.type]||r.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=r.valHooks[e.type]||r.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(nb,""):null==c?"":c)}}}),r.extend({valHooks:{option:{get:function(a){var b=r.find.attr(a,"value");return null!=b?b:r.trim(r.text(a)).replace(ob," ")}},select:{get:function(a){for(var b,c,d=a.options,e=a.selectedIndex,f="select-one"===a.type,g=f?null:[],h=f?e+1:d.length,i=0>e?h:f?e:0;h>i;i++)if(c=d[i],(c.selected||i===e)&&!c.disabled&&(!c.parentNode.disabled||!r.nodeName(c.parentNode,"optgroup"))){if(b=r(c).val(),f)return b;g.push(b)}return g},set:function(a,b){var c,d,e=a.options,f=r.makeArray(b),g=e.length;while(g--)d=e[g],(d.selected=r.inArray(r.valHooks.option.get(d),f)>-1)&&(c=!0);return c||(a.selectedIndex=-1),f}}}}),r.each(["radio","checkbox"],function(){r.valHooks[this]={set:function(a,b){return r.isArray(b)?a.checked=r.inArray(r(a).val(),b)>-1:void 0}},o.checkOn||(r.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var pb=/^(?:focusinfocus|focusoutblur)$/;r.extend(r.event,{trigger:function(b,c,e,f){var g,h,i,j,k,m,n,o=[e||d],p=l.call(b,"type")?b.type:b,q=l.call(b,"namespace")?b.namespace.split("."):[];if(h=i=e=e||d,3!==e.nodeType&&8!==e.nodeType&&!pb.test(p+r.event.triggered)&&(p.indexOf(".")>-1&&(q=p.split("."),p=q.shift(),q.sort()),k=p.indexOf(":")<0&&"on"+p,b=b[r.expando]?b:new r.Event(p,"object"==typeof b&&b),b.isTrigger=f?2:3,b.namespace=q.join("."),b.rnamespace=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=e),c=null==c?Line truncated

ocrweb_multi/utils/config.py

@@ -0,0 +1,18 @@
+import sys
+from pathlib import Path
+import yaml
+
+root_dir = Path(__file__).parent.parent
+
+def get_resource_path(name: str):
+    """依次检查资源文件的多个可能路径, 返回首个存在的路径"""
+    for path in [
+        Path(name),
+        Path(root_dir, name),
+        Path(sys.argv[0]).parent / name,
+    ]:
+        if path.exists():
+            return path
+    raise FileNotFoundError(name)
+
+conf = yaml.safe_load(get_resource_path('config.yaml').read_text())

ocrweb_multi/utils/utils.py

@@ -0,0 +1,86 @@
+import json
+import time
+import warnings
+
+from onnxruntime import (
+    get_available_providers,
+    get_device,
+    SessionOptions,
+    InferenceSession,
+)
+from utils.config import conf, get_resource_path
+
+
+def parse_bool(val):
+    if not isinstance(val, str):
+        return bool(val)
+    return val.lower() in ('1', 'true', 'yes')
+
+
+def default(obj):
+    if hasattr(obj, 'tolist'):
+        return obj.tolist()
+    return obj
+
+
+def tojson(obj, **kws):
+    return json.dumps(obj, default=default, ensure_ascii=False, **kws) + '\n'
+
+
+class OrtInferSession(object):
+    def __init__(self, model_path):
+        ort_conf = conf['global']
+        sess_opt = SessionOptions()
+        sess_opt.log_severity_level = 4
+        sess_opt.enable_cpu_mem_arena = False
+
+        cuda_ep = 'CUDAExecutionProvider'
+        cpu_ep = 'CPUExecutionProvider'
+
+        providers = []
+        if (
+            ort_conf['use_cuda']
+            and get_device() == 'GPU'
+            and cuda_ep in get_available_providers()
+        ):
+            providers = [(cuda_ep, ort_conf[cuda_ep])]
+
+        providers.append(cpu_ep)
+
+        self.session = InferenceSession(
+            str(get_resource_path(model_path)),
+            sess_options=sess_opt,
+            providers=providers,
+        )
+
+        if ort_conf['use_cuda'] and cuda_ep not in self.session.get_providers():
+            warnings.warn(
+                f'{cuda_ep} is not avaiable for current env, the inference part is automatically shifted to be executed under {cpu_ep}.\n'
+                'Please ensure the installed onnxruntime-gpu version matches your cuda and cudnn version, '
+                'you can check their relations from the offical web site: '
+                'https://onnxruntime.ai/docs/execution-providers/CUDA-ExecutionProvider.html',
+                RuntimeWarning,
+            )
+
+    def get_input_name(self, input_idx=0):
+        return self.session.get_inputs()[input_idx].name
+
+    def get_output_name(self, output_idx=0):
+        return self.session.get_outputs()[output_idx].name
+
+
+class Ticker(object):
+    def __init__(self, reset=True) -> None:
+        self.ts = time.perf_counter()
+        self.reset = reset
+        self.maps = {}
+
+    def tick(self, name, reset=None):
+        ts = time.perf_counter()
+        if reset is None:
+            reset = self.reset
+        dt = ts - self.ts
+        if reset:
+            self.ts = ts
+        self.maps[name] = dt
+        return dt