Skip to content

📄 Awesome OCR multiple programing languages toolkits based on ONNX Runtime, OpenVINO, MNN, PaddlePaddle, TensorRT and PyTorch.

add ch_ppocr_mobile_v2_det

SWHLd85be81cb45f
diff --git a/python/bpocr.py b/python/bpocr.py
index 946c02e..22cc455 100755
--- a/python/bpocr.py
+++ b/python/bpocr.py
@@ -2,13 +2,15 @@
# -*- encoding: utf-8 -*-
import copy
import math
-import os
+import random
+from pathlib import Path
import cv2
import numpy as np
from PIL import Image, ImageDraw, ImageFont
-from ch_ppocr_mobile_v1_det import TextDetector
+# from ch_ppocr_mobile_v1_det import TextDetector
+from ch_ppocr_mobile_v2_det_train import TextDetector
from ch_ppocr_mobile_v2_rec import TextRecognizer
font_path = r'resources\simfang.ttf'
@@ -22,12 +24,17 @@ def test_text_det():
test_detector = TextDetector(det_model_path)
+ img, flag = check_and_read_gif(image_path)
+ if not flag:
+ img = cv2.imread(image_path)
+ if img is None:
+ raise ValueError(f"error in loading image:{image_path}")
+
# dst_boxes: 检测到图像中的文本框坐标,ndarray格式
# (10, 4, 2)→[10个,4个坐标,每个坐标两个点]
- dt_boxes, elapse, ori_im = test_detector(image_path)
-
- cv2.imwrite('det_results.jpg', im)
- print('图像已经保存在了det_results.jpg中')
+ dt_boxes, elapse = test_detector(img)
+ print(dt_boxes.shape)
+ print(elapse)
def test_text_rec():
@@ -40,14 +47,39 @@ def test_text_rec():
print(f'识别结果:{rec_res}\tcost: {elapse}s')
-def draw_ocr_box_txt(image, boxes, txts, scores=None, drop_score=0.5,
+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=(255, 255, 0),
+ thickness=2)
+ cv2.putText(src_im, str(i), (int(box[0][0]), int(box[0][1])),
+ cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 3)
+ return src_im
+
+
+def draw_ocr_box_txt(image, boxes, txts,
+ scores=None, drop_score=0.5,
font_path="./doc/simfang.ttf"):
h, w = image.height, image.width
img_left = image.copy()
img_right = Image.new('RGB', (w, h), (255, 255, 255))
- import random
-
random.seed(0)
draw_left = ImageDraw.Draw(img_left)
draw_right = ImageDraw.Draw(img_right)
@@ -88,20 +120,23 @@ def draw_ocr_box_txt(image, boxes, txts, scores=None, drop_score=0.5,
return np.array(img_show)
-def visualize(img, boxes, rec_res, image_file):
- image = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+def visualize(image_path, boxes, rec_res):
+ image = Image.open(image_path)
txts = [rec_res[i][0] for i in range(len(rec_res))]
scores = [rec_res[i][1] for i in range(len(rec_res))]
draw_img = draw_ocr_box_txt(image, boxes, txts, scores,
drop_score=drop_score,
font_path=font_path)
+
draw_img_save = "./inference_results/"
- if not os.path.exists(draw_img_save):
- os.makedirs(draw_img_save)
- cv2.imwrite(
- os.path.join(draw_img_save, os.path.basename(image_file)),
- draw_img[:, :, ::-1])
+ if not Path(draw_img_save).exists():
+ Path(draw_img_save).mkdir(parents=True,
+ exist_ok=True)
+
+ image_save = str(Path(draw_img_save) / f'infer_{Path(image_path).name}')
+ cv2.imwrite(image_save, draw_img[:, :, ::-1])
+ print(f'The infer result has saved in {image_save}')
class TextSystem(object):
@@ -165,8 +200,18 @@ class TextSystem(object):
_boxes[i + 1] = tmp
return _boxes
- def __call__(self, img_path):
- dt_boxes, elapse, ori_im = self.text_detector(img_path)
+ @staticmethod
+ def load_image(image_path):
+ img, flag = check_and_read_gif(image_path)
+ if not flag:
+ img = cv2.imread(image_path)
+ if img is None:
+ raise ValueError(f"error in loading image:{image_path}")
+ return img
+
+ def __call__(self, image_path):
+ img = self.load_image(image_path)
+ dt_boxes, elapse = self.text_detector(img)
print("dt_boxes num : {}, elapse : {}".format(
len(dt_boxes), elapse))
if dt_boxes is None:
@@ -177,7 +222,7 @@ class TextSystem(object):
for bno in range(len(dt_boxes)):
tmp_box = copy.deepcopy(dt_boxes[bno])
- img_crop = self.get_rotate_crop_image(ori_im, tmp_box)
+ img_crop = self.get_rotate_crop_image(img, tmp_box)
img_crop_list.append(img_crop)
if self.use_angle_cls:
img_crop_list, angle_list, elapse = self.text_classifier(
@@ -199,16 +244,14 @@ class TextSystem(object):
if __name__ == '__main__':
- # test_text_det()
+ test_text_det()
# test_text_rec()
- # 联合测试
- det_model_path = 'models\ch_mobile_v1.1_det.onnx'
- rec_model_path = 'models\ch_ppocr_mobile_v2.0_rec_pre_infer.onnx'
- image_path = r'test_images\1.jpg'
- text_sys = TextSystem(det_model_path, rec_model_path)
- dt_boxes, rec_res = text_sys(image_path)
- print(dt_boxes)
- print(rec_res)
- img = cv2.imread(image_path)
- visualize(img, dt_boxes, rec_res, image_path)
+ # 文本检测+文本识别
+ # det_model_path = 'models\ch_ppocr_mobile_v2_det_train.onnx'
+ # rec_model_path = 'models\ch_ppocr_mobile_v2.0_rec_pre_infer.onnx'
+ # image_path = r'test_images\2021-01-23_12-30-56.png'
+
+ # text_sys = TextSystem(det_model_path, rec_model_path)
+ # dt_boxes, rec_res = text_sys(image_path)
+ # visualize(image_path, dt_boxes, rec_res)
diff --git a/python/ch_ppocr_mobile_v1_det/db_process.py b/python/ch_ppocr_mobile_v1_det/db_process.py
deleted file mode 100644
index 1259590..0000000
--- a/python/ch_ppocr_mobile_v1_det/db_process.py
+++ /dev/null
@@ -1,277 +0,0 @@
-# !/usr/bin/env python
-# -*- encoding: utf-8 -*-
-# @File: db_process.py
-# @Time: 2021/01/16 12:00:18
-# @Author: Max
-import sys
-from copy import deepcopy
-
-import cv2
-import numpy as np
-import pyclipper
-from shapely.geometry import Polygon
-
-
-class DBPreProcess(object):
- def __init__(self):
- super(DBPreProcess, self).__init__()
- self.max_side_len = 2400
-
- def resize_image(self, im):
- """
- 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)
- """
- max_side_len = self.max_side_len
- h, w, _ = im.shape
-
- resize_w = w
- resize_h = h
-
- # limit the max side
- if max(resize_h, resize_w) > max_side_len:
- if resize_h > resize_w:
- ratio = float(max_side_len) / resize_h
- else:
- ratio = float(max_side_len) / resize_w
- else:
- ratio = 1.
- resize_h = int(resize_h * ratio)
- resize_w = int(resize_w * ratio)
- if resize_h % 32 == 0:
- resize_h = resize_h
- elif resize_h // 32 <= 1:
- resize_h = 32
- else:
- resize_h = (resize_h // 32) * 32
- if resize_w % 32 == 0:
- resize_w = resize_w
- elif resize_w // 32 <= 1:
- resize_w = 32
- else:
- resize_w = (resize_w // 32) * 32
- try:
- if int(resize_w) <= 0 or int(resize_h) <= 0:
- return None, (None, None)
- im = cv2.resize(im, (int(resize_w), int(resize_h)))
- except:
- print(im.shape, resize_w, resize_h)
- sys.exit(0)
- ratio_h = resize_h / float(h)
- ratio_w = resize_w / float(w)
- return im, (ratio_h, ratio_w)
-
- def normalize(self, im):
- """
- Normalize image
- :param im: input image
- :return: Normalized image
- """
- img_mean = [0.485, 0.456, 0.406]
- img_std = [0.229, 0.224, 0.225]
- im = im.astype(np.float32, copy=False)
- im = im / 255
- im[:, :, 0] -= img_mean[0]
- im[:, :, 1] -= img_mean[1]
- im[:, :, 2] -= img_mean[2]
- im[:, :, 0] /= img_std[0]
- im[:, :, 1] /= img_std[1]
- im[:, :, 2] /= img_std[2]
- channel_swap = (2, 0, 1)
- im = im.transpose(channel_swap)
- return im
-
- def __call__(self, im):
- im, (ratio_h, ratio_w) = self.resize_image(im)
- im = self.normalize(im)
- im = im[np.newaxis, :]
- return [im, (ratio_h, ratio_w)]
-
-
-class DBPostProcess(object):
- def __init__(self):
- self.thresh = 0.3
- self.box_thresh = 0.5
- self.max_candidates = 1000
- self.unclip_ratio = 1.6
- self.min_size = 3
- self.dilation_kernel = np.array([[1, 1], [1, 1]])
-
- def boxes_from_bitmap(self, pred, mask):
- """
- Get boxes from the binarized image predicted by DB.
- :param pred: the binarized image predicted by DB.
- :param mask: new 'pred' after threshold filtering.
- :return: (boxes, the score of each boxes)
- """
- dest_height, dest_width = pred.shape[-2:]
- bitmap = deepcopy(mask)
- 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 = np.zeros((num_contours, 4, 2), dtype=np.int16)
- scores = np.zeros((num_contours, ), dtype=np.float32)
-
- 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)
- if not isinstance(dest_width, int):
- dest_width = dest_width.item()
- dest_height = dest_height.item()
-
- 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[index, :, :] = box.astype(np.int16)
- scores[index] = score
- return boxes, scores
-
- def unclip(self, box):
- """
- Shrink or expand the boxaccording to 'unclip_ratio'
- :param box: The predicted box.
- :return: uncliped 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):
- """
- Get boxes from the contour or box.
- :param contour: The predicted contour.
- :return: The predicted box.
- """
- 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):
- """
- Calculate the score of box.
- :param bitmap: The binarized image predicted by DB.
- :param _box: The predicted box
- :return: score
- """
- h, w = bitmap.shape[:2]
- box = _box.copy()
- xmin = np.clip(np.floor(box[:, 0].min()).astype(np.int), 0, w - 1)
- xmax = np.clip(np.ceil(box[:, 0].max()).astype(np.int), 0, w - 1)
- ymin = np.clip(np.floor(box[:, 1].min()).astype(np.int), 0, h - 1)
- ymax = np.clip(np.ceil(box[:, 1].max()).astype(np.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]
-
- @staticmethod
- def order_points_clockwise(pts):
- """
- reference from: https://github.com/jrosebr1/imutils/blob/master/imutils/perspective.py
- # sort the points based on their x-coordinates
- """
- x_sorted = pts[np.argsort(pts[:, 0]), :]
-
- # grab the left-most and right-most points from the sorted
- # x-roodinate points
- left_most = x_sorted[:2, :]
- right_most = x_sorted[2:, :]
-
- # now, sort the left-most coordinates according to their
- # y-coordinates so we can grab the top-left and bottom-left
- # points, respectively
- left_most = left_most[np.argsort(left_most[:, 1]), :]
- (tl, bl) = left_most
-
- right_most = right_most[np.argsort(right_most[:, 1]), :]
- (tr, br) = right_most
-
- rect = np.array([tl, tr, br, bl], dtype="float32")
- return rect
-
- @staticmethod
- def clip_det_res(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[0: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)
- dt_boxes_new.append(box)
- return dt_boxes
-
- def __call__(self, pred, ratio_list, ori_im_shape):
- pred = pred[:, 0, :, :]
- segmentation = pred > self.thresh
- boxes_batch = []
- for batch_index in range(pred.shape[0]):
-
- mask = cv2.dilate(
- np.array(segmentation[batch_index]).astype(np.uint8),
- self.dilation_kernel)
- tmp_boxes, tmp_scores = self.boxes_from_bitmap(pred[batch_index],
- mask)
- boxes = []
- for k in range(len(tmp_boxes)):
- if tmp_scores[k] > self.box_thresh:
- boxes.append(tmp_boxes[k])
- if len(boxes) > 0:
- boxes = np.array(boxes)
- ratio_h, ratio_w = ratio_list[batch_index]
- boxes[:, :, 0] = boxes[:, :, 0] / ratio_w
- boxes[:, :, 1] = boxes[:, :, 1] / ratio_h
- boxes_batch.append(boxes)
- dt_boxes = self.filter_tag_det_res(boxes_batch[0], ori_im_shape)
- return dt_boxes
diff --git a/python/ch_ppocr_mobile_v1_det/text_detect.py b/python/ch_ppocr_mobile_v1_det/text_detect.py
index e171071..90ad525 100644
--- a/python/ch_ppocr_mobile_v1_det/text_detect.py
+++ b/python/ch_ppocr_mobile_v1_det/text_detect.py
@@ -23,17 +23,7 @@ class TextDetector(object):
self.session = onnxruntime.InferenceSession(det_model_path)
self.postprocess_op = DBPostProcess()
- @staticmethod
- def load_image(image_path):
- img, flag = check_and_read_gif(image_path)
- if not flag:
- img = cv2.imread(image_path)
- if img is None:
- raise ValueError('图像有问题')
- return img
-
- def __call__(self, image_path):
- img = self.load_image(image_path)
+ def __call__(self, img):
ori_im = img.copy()
im, ratio_list = self.preprocess_op(img)
if im is None:
@@ -43,20 +33,28 @@ class TextDetector(object):
outputs = self.session.run(None, inputs)[0]
dt_boxes = self.postprocess_op(outputs, [ratio_list], ori_im.shape)
- # plot_img = draw_text_det_res(dt_boxes, img)
elapse = time.time() - starttime
- return dt_boxes, elapse, ori_im
+ return dt_boxes, elapse
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('image_path', type=str,
- default='images/1.jpg', help='image_path|image_dir')
+ default=None, help='image_path|image_dir')
parser.add_argument('model_path', type=str, default=None,
help='model_path')
args = parser.parse_args()
text_detector = TextDetector(args.model_path)
- dt_boxes, plot_img = text_detector(args.image_path)
+
+ img, flag = check_and_read_gif(args.image_path)
+ if not flag:
+ img = cv2.imread(args.image_path)
+ if img is None:
+ raise ValueError(f"error in loading image:{args.image_path}")
+
+ dt_boxes, elapse = text_detector(img)
+
+ plot_img = draw_text_det_res(dt_boxes, img)
cv2.imwrite('det_results.jpg', plot_img)
- print('图像已经保存在det_results.jpg了')
+ print('图像已经保存为det_results.jpg了')
diff --git a/python/ch_ppocr_mobile_v1_det/utils.py b/python/ch_ppocr_mobile_v1_det/utils.py
index 0120a3a..419d98d 100644
--- a/python/ch_ppocr_mobile_v1_det/utils.py
+++ b/python/ch_ppocr_mobile_v1_det/utils.py
@@ -17,7 +17,7 @@ from shapely.geometry import Polygon
class DBPreProcess(object):
def __init__(self):
super(DBPreProcess, self).__init__()
- self.max_side_len = 2400
+ self.max_side_len = 1000
def resize_image(self, im):
"""
diff --git a/python/ch_ppocr_mobile_v2_det_train/__init__.py b/python/ch_ppocr_mobile_v2_det_train/__init__.py
new file mode 100644
index 0000000..d7a3e0b
--- /dev/null
+++ b/python/ch_ppocr_mobile_v2_det_train/__init__.py
@@ -0,0 +1,6 @@
+# !/usr/bin/env python
+# -*- encoding: utf-8 -*-
+# @File: __init__.py
+# @Time: 2021/01/23 15:24:27
+# @Author: Max
+from .text_detect import TextDetector
\ No newline at end of file
diff --git a/python/ch_ppocr_mobile_v2_det_train/text_detect.py b/python/ch_ppocr_mobile_v2_det_train/text_detect.py
new file mode 100644
index 0000000..eebeee7
--- /dev/null
+++ b/python/ch_ppocr_mobile_v2_det_train/text_detect.py
@@ -0,0 +1,164 @@
+# 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.
+# !/usr/bin/env python
+# -*- encoding: utf-8 -*-
+import time
+from pathlib import Path
+import argparse
+
+import cv2
+import numpy as np
+import onnxruntime
+
+try:
+ from .utils import (DBPostProcess, check_and_read_gif, create_operators,
+ draw_text_det_res, transform)
+except:
+ from utils import (DBPostProcess, check_and_read_gif, create_operators,
+ draw_text_det_res, transform)
+
+
+class TextDetector(object):
+ def __init__(self, det_model_path):
+ pre_process_list = [{
+ 'DetResizeForTest': {
+ 'limit_side_len': 960,
+ 'limit_type': 'max'
+ }
+ }, {
+ 'NormalizeImage': {
+ 'std': [0.229, 0.224, 0.225],
+ 'mean': [0.485, 0.456, 0.406],
+ 'scale': '1./255.',
+ 'order': 'hwc'
+ }
+ }, {
+ 'ToCHWImage': None
+ }, {
+ 'KeepKeys': {
+ 'keep_keys': ['image', 'shape']
+ }
+ }]
+
+ self.preprocess_op = create_operators(pre_process_list)
+ self.postprocess_op = DBPostProcess(thresh=0.3,
+ box_thresh=0.5,
+ max_candidates=1000,
+ unclip_ratio=1.6,
+ use_dilation=True)
+ self.session = onnxruntime.InferenceSession(det_model_path)
+ self.input_name = self.session.get_inputs()[0].name
+ self.output_name = self.session.get_outputs()[0].name
+
+ 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[0: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)
+ dt_boxes = np.array(dt_boxes_new)
+ return dt_boxes
+
+ def filter_tag_det_res_only_clip(self, dt_boxes, image_shape):
+ img_height, img_width = image_shape[0:2]
+ dt_boxes_new = []
+ for box in dt_boxes:
+ box = self.clip_det_res(box, img_height, img_width)
+ dt_boxes_new.append(box)
+ dt_boxes = np.array(dt_boxes_new)
+ return dt_boxes
+
+ @staticmethod
+ def load_image(image_path):
+
+ return img
+
+ def __call__(self, img):
+ ori_im = img.copy()
+ 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)
+ img = img.astype(np.float32)
+ shape_list = np.expand_dims(shape_list, axis=0)
+
+ starttime = time.time()
+ preds = self.session.run([self.output_name],
+ {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)
+ elapse = time.time() - starttime
+ return dt_boxes, elapse
+
+
+if __name__ == "__main__":
+ parser = argparse.ArgumentParser()
+ parser.add_argument('image_path', type=str, default=None,
+ help='image_path|image_dir')
+ parser.add_argument('model_path', type=str, default=None,
+ help='model_path')
+ args = parser.parse_args()
+
+ text_detector = TextDetector(args.model_path)
+
+ img, flag = check_and_read_gif(args.image_path)
+ if not flag:
+ img = cv2.imread(args.image_path)
+ if img is None:
+ raise ValueError(f"error in loading image:{args.image_path}")
+
+ dt_boxes, elapse = text_detector(img)
+
+ src_im = draw_text_det_res(dt_boxes, args.image_path)
+ cv2.imwrite('det_results.jpg', src_im)
+ print('图像已经保存为det_results.jpg了')
diff --git a/python/ch_ppocr_mobile_v2_det_train/utils.py b/python/ch_ppocr_mobile_v2_det_train/utils.py
new file mode 100644
index 0000000..dfbea6c
--- /dev/null
+++ b/python/ch_ppocr_mobile_v2_det_train/utils.py
@@ -0,0 +1,414 @@
+"""
+# 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.
+"""
+# coding:utf-8
+from __future__ import (absolute_import, division, print_function,
+ unicode_literals)
+
+import os
+import sys
+
+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, **kwargs):
+ 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, 'invalid shape of image[%s]' % (
+ 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', **kwargs):
+ if isinstance(scale, str):
+ scale = eval(scale)
+ 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 = data['image']
+ from PIL import Image
+ if isinstance(img, Image.Image):
+ img = np.array(img)
+
+ assert isinstance(img,
+ np.ndarray), "invalid input 'img' in NormalizeImage"
+ data['image'] = (
+ img.astype('float32') * self.scale - self.mean) / self.std
+ return data
+
+
+class ToCHWImage(object):
+ """ convert hwc image to chw image
+ """
+
+ def __init__(self, **kwargs):
+ pass
+
+ def __call__(self, data):
+ img = data['image']
+ from PIL import Image
+ if isinstance(img, Image.Image):
+ img = np.array(img)
+ data['image'] = img.transpose((2, 0, 1))
+ return data
+
+
+class KeepKeys(object):
+ def __init__(self, keep_keys, **kwargs):
+ 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')
+
+ if '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.
+ 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.
+ 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 check_and_read_gif(img_path):
+ if os.path.basename(img_path)[-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 create_operators(op_param_list, global_config=None):
+ """
+ create operators based on the config
+
+ Args:
+ params(list): a dict list, used to create some operators
+ """
+ assert isinstance(
+ op_param_list, list), ('operator config should be a list')
+ ops = []
+ for operator in op_param_list:
+ assert isinstance(operator,
+ dict) and len(operator) == 1, "yaml format error"
+ op_name = list(operator)[0]
+ param = {} if operator[op_name] is None else operator[op_name]
+ if global_config is not None:
+ param.update(global_config)
+ op = eval(op_name)(**param)
+ ops.append(op)
+ 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,
+ **kwargs):
+ self.thresh = thresh
+ self.box_thresh = box_thresh
+ self.max_candidates = max_candidates
+ self.unclip_ratio = unclip_ratio
+ self.min_size = 3
+ self.dilation_kernel = None if not use_dilation else np.array(
+ [[1, 1], [1, 1]])
+
+ 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(np.int), 0, w - 1)
+ xmax = np.clip(np.ceil(box[:, 0].max()).astype(np.int), 0, w - 1)
+ ymin = np.clip(np.floor(box[:, 1].min()).astype(np.int), 0, h - 1)
+ ymax = np.clip(np.ceil(box[:, 1].max()).astype(np.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
diff --git a/python/ch_ppocr_mobile_v2_rec/text_recognize.py b/python/ch_ppocr_mobile_v2_rec/text_recognize.py
index 1727ed4..42a63db 100644
--- a/python/ch_ppocr_mobile_v2_rec/text_recognize.py
+++ b/python/ch_ppocr_mobile_v2_rec/text_recognize.py
@@ -19,7 +19,6 @@ from pathlib import Path
import cv2
import numpy as np
import onnxruntime
-from numpy.lib.arraysetops import isin
try:
from .utils import CTCLabelDecode, check_and_read_gif, get_image_file_list
@@ -129,9 +128,9 @@ class TextRecognizer(object):
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('image_dir', type=str, help='image_dir|image_path')
- parser.add_argument('rec_model_path', type=str, help='rec_model_path')
+ parser.add_argument('model_path', type=str, help='rec_model_path')
args = parser.parse_args()
- text_recognizer = TextRecognizer(args.rec_model_path)
+ text_recognizer = TextRecognizer(args.model_path)
rec_res, predict_time = text_recognizer(args.image_dir)
print(f'识别结果: {rec_res}\t cost: {predict_time}s')
diff --git a/python/ch_ppocr_mobile_v2_rec/utils.py b/python/ch_ppocr_mobile_v2_rec/utils.py
index be700e6..8836d71 100644
--- a/python/ch_ppocr_mobile_v2_rec/utils.py
+++ b/python/ch_ppocr_mobile_v2_rec/utils.py
@@ -16,33 +16,17 @@ class BaseRecLabelDecode(object):
character_dict_path=None,
character_type='ch',
use_space_char=False):
- support_character_type = [
- 'ch', 'en', 'en_sensitive', 'french', 'german', 'japan', 'korean'
- ]
- assert character_type in support_character_type, "Only {} are supported now but get {}".format(
- support_character_type, character_type)
-
- if character_type == "en":
- self.character_str = "0123456789abcdefghijklmnopqrstuvwxyz"
- dict_character = list(self.character_str)
- elif character_type in ["ch", "french", "german", "japan", "korean"]:
- self.character_str = ""
- assert character_dict_path is not None, "character_dict_path should not be None when character_type is ch"
- with open(character_dict_path, "rb") as fin:
- lines = fin.readlines()
- for line in lines:
- line = line.decode('utf-8').strip("\n").strip("\r\n")
- self.character_str += line
- if use_space_char:
- self.character_str += " "
- dict_character = list(self.character_str)
- elif character_type == "en_sensitive":
- # same with ASTER setting (use 94 char).
- import string
- self.character_str = string.printable[:-6]
- dict_character = list(self.character_str)
- else:
- raise NotImplementedError
+ self.character_str = ""
+ assert character_dict_path is not None, "character_dict_path should not be None when character_type is ch"
+ with open(character_dict_path, "rb") as fin:
+ lines = fin.readlines()
+ for line in lines:
+ line = line.decode('utf-8').strip("\n").strip("\r\n")
+ self.character_str += line
+ if use_space_char:
+ self.character_str += " "
+ dict_character = list(self.character_str)
+
self.character_type = character_type
dict_character = self.add_special_char(dict_character)
self.dict = {}
@@ -108,17 +92,6 @@ class CTCLabelDecode(BaseRecLabelDecode):
return dict_character
-def get_check_global_params(mode):
- check_params = ['use_gpu', 'max_text_length', 'image_shape', \
- 'image_shape', 'character_type', 'loss_type']
- if mode == "train_eval":
- check_params = check_params + [ \
- 'train_batch_size_per_card', 'test_batch_size_per_card']
- elif mode == "test":
- check_params = check_params + ['test_batch_size_per_card']
- return check_params
-
-
def get_image_file_list(img_file):
imgs_lists = []
if img_file is None or not os.path.exists(img_file):
diff --git a/python/readme.md b/python/readme.md
index b6d3768..f59580d 100755
--- a/python/readme.md
+++ b/python/readme.md
@@ -6,47 +6,50 @@
### 文本检测+文本识别
- 具体参见`bpocr.py`
+
#### 使用方法:
```python
-det_model_path = 'models\ch_mobile_v1.1_det.onnx'
+det_model_path = 'models\ch_ppocr_mobile_v2_det_train.onnx'
rec_model_path = 'models\ch_ppocr_mobile_v2.0_rec_pre_infer.onnx'
-image_path = r'test_images\long1.jpg'
+image_path = r'test_images\2021-01-23_12-30-56.png'
+
text_sys = TextSystem(det_model_path, rec_model_path)
dt_boxes, rec_res = text_sys(image_path)
-print(dt_boxes)
-print(rec_res)
-img = cv2.imread(image_path)
-visualize(img, dt_boxes, rec_res, image_path)
+visualize(image_path, dt_boxes, rec_res)
```
+### 通用超轻量文本检测模型 ch_ppocr_mobile_v2_det_train
-### 通用超轻量文本检测模型 ch_ppocr_mobile_v1.1_det
+- **Note: 支持任意尺寸输入**
+- 详细见`ch_ppocr_mobile_v2_det_train\text_detect.py`
-**Note: 支持任意尺寸输入**
-
-#### 使用方法
+#### 简单示例
```python
-det_model_path = 'models\ch_mobile_v1.1_det.onnx'
+det_model_path = 'models\ch_ppocr_mobile_v2_det_train.onnx'
image_path = r'test_images\det_images\1.jpg'
test_detector = TextDetector(det_model_path)
+img, flag = check_and_read_gif(image_path)
+if not flag:
+ img = cv2.imread(image_path)
+if img is None:
+ raise ValueError(f"error in loading image:{image_path}")
+
# dst_boxes: 检测到图像中的文本框坐标,ndarray格式
# (10, 4, 2)→[10个,4个坐标,每个坐标两个点]
-dt_boxes, elapse, ori_im = test_detector(image_path)
-
-cv2.imwrite('det_results.jpg', im)
-print('图像已经保存在了det_results.jpg中')
+dt_boxes, elapse = test_detector(img)
+print(dt_boxes.shape)
+print(elapse)
```
-- 即可看到检测结果图(`images/det_results.jpg`),效果如下:
-
-![det_result](./test_images/det_images/det_results.jpg)
### 通用超轻量文本识别模型ch_ppocr_mobile_v2_rec
-**Note: 支持任意尺寸输入**
+- **Note: 支持任意尺寸输入**
+- 详细见`ch_ppocr_mobile_v2_rec\text_recognize.py`
-#### 使用方法:
+
+#### 简单示例:
```python
rec_model_path = r'models\ch_ppocr_mobile_v2.0_rec_pre_infer.onnx'
image_path = r'test_images\rec_images\2021-01-19_13-44-34.png'
@@ -55,3 +58,26 @@ text_recongnizer = TextRecognizer(rec_model_path)
rec_res, elapse = text_recongnizer(image_path)
print(f'识别结果:{rec_res}\tcost: {elapse}s')
```
+
+### 通用超轻量文本检测模型 ch_ppocr_mobile_v1.1_det
+
+- **Note: 支持任意尺寸输入**
+- 详细见`ch_ppocr_mobile_v1_det\text_detect.py`
+
+#### 简单示例
+
+```python
+text_detector = TextDetector(args.model_path)
+
+img, flag = check_and_read_gif(args.image_path)
+if not flag:
+ img = cv2.imread(args.image_path)
+if img is None:
+ raise ValueError(f"error in loading image:{args.image_path}")
+
+dt_boxes, elapse = text_detector(img)
+
+plot_img = draw_text_det_res(dt_boxes, img)
+cv2.imwrite('det_results.jpg', plot_img)
+print('图像已经保存为det_results.jpg了')
+```
\ No newline at end of file
diff --git a/python/test_images/det_images/det_results.jpg b/python/test_images/det_images/v1_det_results.jpg
similarity index 100%
rename from python/test_images/det_images/det_results.jpg
rename to python/test_images/det_images/v1_det_results.jpg