utility.py 23.9 KB
Newer Older
LDOUBLEV's avatar
LDOUBLEV committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 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
WenmuZhou's avatar
WenmuZhou committed
16
import os
WenmuZhou's avatar
WenmuZhou committed
17
import sys
LDOUBLEV's avatar
LDOUBLEV committed
18
19
import cv2
import numpy as np
zhoujun's avatar
zhoujun committed
20
import paddle
LDOUBLEV's avatar
LDOUBLEV committed
21
from PIL import Image, ImageDraw, ImageFont
22
import math
WenmuZhou's avatar
WenmuZhou committed
23
from paddle import inference
LDOUBLEV's avatar
LDOUBLEV committed
24
25
import time
from ppocr.utils.logging import get_logger
WenmuZhou's avatar
WenmuZhou committed
26

LDOUBLEV's avatar
LDOUBLEV committed
27

28
29
def str2bool(v):
    return v.lower() in ("true", "t", "1")
LDOUBLEV's avatar
LDOUBLEV committed
30
31


WenmuZhou's avatar
WenmuZhou committed
32
def init_args():
LDOUBLEV's avatar
LDOUBLEV committed
33
    parser = argparse.ArgumentParser()
WenmuZhou's avatar
WenmuZhou committed
34
    # params for prediction engine
LDOUBLEV's avatar
LDOUBLEV committed
35
36
37
    parser.add_argument("--use_gpu", type=str2bool, default=True)
    parser.add_argument("--ir_optim", type=str2bool, default=True)
    parser.add_argument("--use_tensorrt", type=str2bool, default=False)
LDOUBLEV's avatar
LDOUBLEV committed
38
    parser.add_argument("--min_subgraph_size", type=int, default=15)
LDOUBLEV's avatar
LDOUBLEV committed
39
    parser.add_argument("--precision", type=str, default="fp32")
40
    parser.add_argument("--gpu_mem", type=int, default=500)
LDOUBLEV's avatar
LDOUBLEV committed
41

WenmuZhou's avatar
WenmuZhou committed
42
    # params for text detector
LDOUBLEV's avatar
LDOUBLEV committed
43
44
45
    parser.add_argument("--image_dir", type=str)
    parser.add_argument("--det_algorithm", type=str, default='DB')
    parser.add_argument("--det_model_dir", type=str)
WenmuZhou's avatar
WenmuZhou committed
46
47
    parser.add_argument("--det_limit_side_len", type=float, default=960)
    parser.add_argument("--det_limit_type", type=str, default='max')
LDOUBLEV's avatar
LDOUBLEV committed
48

WenmuZhou's avatar
WenmuZhou committed
49
    # DB parmas
LDOUBLEV's avatar
LDOUBLEV committed
50
    parser.add_argument("--det_db_thresh", type=float, default=0.3)
LDOUBLEV's avatar
LDOUBLEV committed
51
52
    parser.add_argument("--det_db_box_thresh", type=float, default=0.6)
    parser.add_argument("--det_db_unclip_ratio", type=float, default=1.5)
LDOUBLEV's avatar
LDOUBLEV committed
53
    parser.add_argument("--max_batch_size", type=int, default=10)
littletomatodonkey's avatar
littletomatodonkey committed
54
    parser.add_argument("--use_dilation", type=str2bool, default=False)
littletomatodonkey's avatar
littletomatodonkey committed
55
    parser.add_argument("--det_db_score_mode", type=str, default="fast")
WenmuZhou's avatar
WenmuZhou committed
56
    # EAST parmas
LDOUBLEV's avatar
LDOUBLEV committed
57
58
59
60
    parser.add_argument("--det_east_score_thresh", type=float, default=0.8)
    parser.add_argument("--det_east_cover_thresh", type=float, default=0.1)
    parser.add_argument("--det_east_nms_thresh", type=float, default=0.2)

WenmuZhou's avatar
WenmuZhou committed
61
    # SAST parmas
licx's avatar
licx committed
62
63
    parser.add_argument("--det_sast_score_thresh", type=float, default=0.5)
    parser.add_argument("--det_sast_nms_thresh", type=float, default=0.2)
littletomatodonkey's avatar
littletomatodonkey committed
64
    parser.add_argument("--det_sast_polygon", type=str2bool, default=False)
licx's avatar
licx committed
65

WenmuZhou's avatar
WenmuZhou committed
66
67
68
69
    # PSE parmas
    parser.add_argument("--det_pse_thresh", type=float, default=0)
    parser.add_argument("--det_pse_box_thresh", type=float, default=0.85)
    parser.add_argument("--det_pse_min_area", type=float, default=16)
WenmuZhou's avatar
WenmuZhou committed
70
    parser.add_argument("--det_pse_box_type", type=str, default='box')
WenmuZhou's avatar
WenmuZhou committed
71
72
    parser.add_argument("--det_pse_scale", type=int, default=1)

WenmuZhou's avatar
WenmuZhou committed
73
    # params for text recognizer
LDOUBLEV's avatar
LDOUBLEV committed
74
75
    parser.add_argument("--rec_algorithm", type=str, default='CRNN')
    parser.add_argument("--rec_model_dir", type=str)
tink2123's avatar
fix bug  
tink2123 committed
76
    parser.add_argument("--rec_image_shape", type=str, default="3, 32, 320")
77
    parser.add_argument("--rec_batch_num", type=int, default=6)
tink2123's avatar
fix bug  
tink2123 committed
78
    parser.add_argument("--max_text_length", type=int, default=25)
LDOUBLEV's avatar
LDOUBLEV committed
79
80
81
82
    parser.add_argument(
        "--rec_char_dict_path",
        type=str,
        default="./ppocr/utils/ppocr_keys_v1.txt")
WenmuZhou's avatar
WenmuZhou committed
83
84
    parser.add_argument("--use_space_char", type=str2bool, default=True)
    parser.add_argument(
tink2123's avatar
tink2123 committed
85
        "--vis_font_path", type=str, default="./doc/fonts/simfang.ttf")
WenmuZhou's avatar
WenmuZhou committed
86
    parser.add_argument("--drop_score", type=float, default=0.5)
WenmuZhou's avatar
WenmuZhou committed
87

Jethong's avatar
Jethong committed
88
89
90
91
92
93
94
95
96
    # params for e2e
    parser.add_argument("--e2e_algorithm", type=str, default='PGNet')
    parser.add_argument("--e2e_model_dir", type=str)
    parser.add_argument("--e2e_limit_side_len", type=float, default=768)
    parser.add_argument("--e2e_limit_type", type=str, default='max')

    # PGNet parmas
    parser.add_argument("--e2e_pgnet_score_thresh", type=float, default=0.5)
    parser.add_argument(
Jethong's avatar
Jethong committed
97
        "--e2e_char_dict_path", type=str, default="./ppocr/utils/ic15_dict.txt")
Jethong's avatar
Jethong committed
98
    parser.add_argument("--e2e_pgnet_valid_set", type=str, default='totaltext')
Jethong's avatar
Jethong committed
99
    parser.add_argument("--e2e_pgnet_mode", type=str, default='fast')
Jethong's avatar
Jethong committed
100

WenmuZhou's avatar
WenmuZhou committed
101
102
103
104
105
    # params for text classifier
    parser.add_argument("--use_angle_cls", type=str2bool, default=False)
    parser.add_argument("--cls_model_dir", type=str)
    parser.add_argument("--cls_image_shape", type=str, default="3, 48, 192")
    parser.add_argument("--label_list", type=list, default=['0', '180'])
106
    parser.add_argument("--cls_batch_num", type=int, default=6)
WenmuZhou's avatar
WenmuZhou committed
107
108
109
    parser.add_argument("--cls_thresh", type=float, default=0.9)

    parser.add_argument("--enable_mkldnn", type=str2bool, default=False)
LDOUBLEV's avatar
LDOUBLEV committed
110
    parser.add_argument("--cpu_threads", type=int, default=10)
WenmuZhou's avatar
WenmuZhou committed
111
    parser.add_argument("--use_pdserving", type=str2bool, default=False)
112
113
114
115
116
117
118
    parser.add_argument("--warmup", type=str2bool, default=False)

    #
    parser.add_argument(
        "--draw_img_save_dir", type=str, default="./inference_results")
    parser.add_argument("--save_crop_res", type=str2bool, default=False)
    parser.add_argument("--crop_res_save_dir", type=str, default="./output")
WenmuZhou's avatar
WenmuZhou committed
119

LDOUBLEV's avatar
LDOUBLEV committed
120
    # multi-process
littletomatodonkey's avatar
littletomatodonkey committed
121
    parser.add_argument("--use_mp", type=str2bool, default=False)
122
123
    parser.add_argument("--total_process_num", type=int, default=1)
    parser.add_argument("--process_id", type=int, default=0)
WenmuZhou's avatar
WenmuZhou committed
124

littletomatodonkey's avatar
littletomatodonkey committed
125
    parser.add_argument("--benchmark", type=str2bool, default=False)
LDOUBLEV's avatar
LDOUBLEV committed
126
    parser.add_argument("--save_log_path", type=str, default="./log_output/")
Double_V's avatar
Double_V committed
127

WenmuZhou's avatar
WenmuZhou committed
128
    parser.add_argument("--show_log", type=str2bool, default=True)
tink2123's avatar
tink2123 committed
129
    parser.add_argument("--use_onnx", type=str2bool, default=False)
WenmuZhou's avatar
WenmuZhou committed
130
    return parser
WenmuZhou's avatar
WenmuZhou committed
131

132

133
def parse_args():
WenmuZhou's avatar
WenmuZhou committed
134
    parser = init_args()
LDOUBLEV's avatar
LDOUBLEV committed
135
136
137
    return parser.parse_args()


WenmuZhou's avatar
WenmuZhou committed
138
139
140
141
142
def create_predictor(args, mode, logger):
    if mode == "det":
        model_dir = args.det_model_dir
    elif mode == 'cls':
        model_dir = args.cls_model_dir
Jethong's avatar
Jethong committed
143
    elif mode == 'rec':
WenmuZhou's avatar
WenmuZhou committed
144
        model_dir = args.rec_model_dir
WenmuZhou's avatar
WenmuZhou committed
145
146
    elif mode == 'table':
        model_dir = args.table_model_dir
Jethong's avatar
Jethong committed
147
148
    else:
        model_dir = args.e2e_model_dir
WenmuZhou's avatar
WenmuZhou committed
149
150
151
152

    if model_dir is None:
        logger.info("not find {} model file path {}".format(mode, model_dir))
        sys.exit(0)
tink2123's avatar
tink2123 committed
153
154
155
156
157
158
159
160
    if args.use_onnx:
        import onnxruntime as ort
        model_file_path = model_dir
        if not os.path.exists(model_file_path):
            raise ValueError("not find model file path {}".format(
                model_file_path))
        sess = ort.InferenceSession(model_file_path)
        return sess, sess.get_inputs()[0], None, None
LDOUBLEV's avatar
LDOUBLEV committed
161

LDOUBLEV's avatar
LDOUBLEV committed
162
    else:
tink2123's avatar
tink2123 committed
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
        model_file_path = model_dir + "/inference.pdmodel"
        params_file_path = model_dir + "/inference.pdiparams"
        if not os.path.exists(model_file_path):
            raise ValueError("not find model file path {}".format(
                model_file_path))
        if not os.path.exists(params_file_path):
            raise ValueError("not find params file path {}".format(
                params_file_path))

        config = inference.Config(model_file_path, params_file_path)

        if hasattr(args, 'precision'):
            if args.precision == "fp16" and args.use_tensorrt:
                precision = inference.PrecisionType.Half
            elif args.precision == "int8":
                precision = inference.PrecisionType.Int8
            else:
                precision = inference.PrecisionType.Float32
LDOUBLEV's avatar
LDOUBLEV committed
181
        else:
tink2123's avatar
tink2123 committed
182
183
184
185
186
            precision = inference.PrecisionType.Float32

        if args.use_gpu:
            gpu_id = get_infer_gpuid()
            if gpu_id is None:
LDOUBLEV's avatar
LDOUBLEV committed
187
                logger.warning(
LDOUBLEV's avatar
LDOUBLEV committed
188
                    "GPU is not found in current device by nvidia-smi. Please check your device or ignore it if run on jeston."
tink2123's avatar
tink2123 committed
189
190
191
192
                )
            config.enable_use_gpu(args.gpu_mem, 0)
            if args.use_tensorrt:
                config.enable_tensorrt_engine(
LDOUBLEV's avatar
LDOUBLEV committed
193
                    workspace_size=1 << 30,
tink2123's avatar
tink2123 committed
194
195
196
197
                    precision_mode=precision,
                    max_batch_size=args.max_batch_size,
                    min_subgraph_size=args.min_subgraph_size)
                # skip the minmum trt subgraph
LDOUBLEV's avatar
fix trt  
LDOUBLEV committed
198
            use_dynamic_shape = True
LDOUBLEV's avatar
fix  
LDOUBLEV committed
199
            if mode == "det":
tink2123's avatar
tink2123 committed
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
                min_input_shape = {
                    "x": [1, 3, 50, 50],
                    "conv2d_92.tmp_0": [1, 120, 20, 20],
                    "conv2d_91.tmp_0": [1, 24, 10, 10],
                    "conv2d_59.tmp_0": [1, 96, 20, 20],
                    "nearest_interp_v2_1.tmp_0": [1, 256, 10, 10],
                    "nearest_interp_v2_2.tmp_0": [1, 256, 20, 20],
                    "conv2d_124.tmp_0": [1, 256, 20, 20],
                    "nearest_interp_v2_3.tmp_0": [1, 64, 20, 20],
                    "nearest_interp_v2_4.tmp_0": [1, 64, 20, 20],
                    "nearest_interp_v2_5.tmp_0": [1, 64, 20, 20],
                    "elementwise_add_7": [1, 56, 2, 2],
                    "nearest_interp_v2_0.tmp_0": [1, 256, 2, 2]
                }
                max_input_shape = {
LDOUBLEV's avatar
fix trt  
LDOUBLEV committed
215
                    "x": [1, 3, 1536, 1536],
tink2123's avatar
tink2123 committed
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
                    "conv2d_92.tmp_0": [1, 120, 400, 400],
                    "conv2d_91.tmp_0": [1, 24, 200, 200],
                    "conv2d_59.tmp_0": [1, 96, 400, 400],
                    "nearest_interp_v2_1.tmp_0": [1, 256, 200, 200],
                    "conv2d_124.tmp_0": [1, 256, 400, 400],
                    "nearest_interp_v2_2.tmp_0": [1, 256, 400, 400],
                    "nearest_interp_v2_3.tmp_0": [1, 64, 400, 400],
                    "nearest_interp_v2_4.tmp_0": [1, 64, 400, 400],
                    "nearest_interp_v2_5.tmp_0": [1, 64, 400, 400],
                    "elementwise_add_7": [1, 56, 400, 400],
                    "nearest_interp_v2_0.tmp_0": [1, 256, 400, 400]
                }
                opt_input_shape = {
                    "x": [1, 3, 640, 640],
                    "conv2d_92.tmp_0": [1, 120, 160, 160],
                    "conv2d_91.tmp_0": [1, 24, 80, 80],
                    "conv2d_59.tmp_0": [1, 96, 160, 160],
                    "nearest_interp_v2_1.tmp_0": [1, 256, 80, 80],
                    "nearest_interp_v2_2.tmp_0": [1, 256, 160, 160],
                    "conv2d_124.tmp_0": [1, 256, 160, 160],
                    "nearest_interp_v2_3.tmp_0": [1, 64, 160, 160],
                    "nearest_interp_v2_4.tmp_0": [1, 64, 160, 160],
                    "nearest_interp_v2_5.tmp_0": [1, 64, 160, 160],
                    "elementwise_add_7": [1, 56, 40, 40],
                    "nearest_interp_v2_0.tmp_0": [1, 256, 40, 40]
                }
                min_pact_shape = {
                    "nearest_interp_v2_26.tmp_0": [1, 256, 20, 20],
                    "nearest_interp_v2_27.tmp_0": [1, 64, 20, 20],
                    "nearest_interp_v2_28.tmp_0": [1, 64, 20, 20],
                    "nearest_interp_v2_29.tmp_0": [1, 64, 20, 20]
                }
                max_pact_shape = {
                    "nearest_interp_v2_26.tmp_0": [1, 256, 400, 400],
                    "nearest_interp_v2_27.tmp_0": [1, 64, 400, 400],
                    "nearest_interp_v2_28.tmp_0": [1, 64, 400, 400],
                    "nearest_interp_v2_29.tmp_0": [1, 64, 400, 400]
                }
                opt_pact_shape = {
                    "nearest_interp_v2_26.tmp_0": [1, 256, 160, 160],
                    "nearest_interp_v2_27.tmp_0": [1, 64, 160, 160],
                    "nearest_interp_v2_28.tmp_0": [1, 64, 160, 160],
                    "nearest_interp_v2_29.tmp_0": [1, 64, 160, 160]
                }
                min_input_shape.update(min_pact_shape)
                max_input_shape.update(max_pact_shape)
                opt_input_shape.update(opt_pact_shape)
            elif mode == "rec":
LDOUBLEV's avatar
fix trt  
LDOUBLEV committed
264
265
                if args.rec_algorithm != "CRNN":
                    use_dynamic_shape = False
tink2123's avatar
tink2123 committed
266
                min_input_shape = {"x": [1, 3, 32, 10]}
LDOUBLEV's avatar
LDOUBLEV committed
267
                max_input_shape = {"x": [args.rec_batch_num, 3, 32, 1536]}
tink2123's avatar
tink2123 committed
268
269
270
                opt_input_shape = {"x": [args.rec_batch_num, 3, 32, 320]}
            elif mode == "cls":
                min_input_shape = {"x": [1, 3, 48, 10]}
LDOUBLEV's avatar
LDOUBLEV committed
271
                max_input_shape = {"x": [args.rec_batch_num, 3, 48, 1024]}
tink2123's avatar
tink2123 committed
272
273
                opt_input_shape = {"x": [args.rec_batch_num, 3, 48, 320]}
            else:
LDOUBLEV's avatar
fix trt  
LDOUBLEV committed
274
275
                use_dynamic_shape = False
            if use_dynamic_shape:
andyjpaddle's avatar
andyjpaddle committed
276
277
                config.set_trt_dynamic_shape_info(
                    min_input_shape, max_input_shape, opt_input_shape)
LDOUBLEV's avatar
LDOUBLEV committed
278

LDOUBLEV's avatar
LDOUBLEV committed
279
        else:
tink2123's avatar
tink2123 committed
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
            config.disable_gpu()
            if hasattr(args, "cpu_threads"):
                config.set_cpu_math_library_num_threads(args.cpu_threads)
            else:
                # default cpu threads as 10
                config.set_cpu_math_library_num_threads(10)
            if args.enable_mkldnn:
                # cache 10 different shapes for mkldnn to avoid memory leak
                config.set_mkldnn_cache_capacity(10)
                config.enable_mkldnn()
                if args.precision == "fp16":
                    config.enable_mkldnn_bfloat16()
        # enable memory optim
        config.enable_memory_optim()
        config.disable_glog_info()

        config.delete_pass("conv_transpose_eltwiseadd_bn_fuse_pass")
        if mode == 'table':
            config.delete_pass("fc_fuse_pass")  # not supported for table
        config.switch_use_feed_fetch_ops(False)
        config.switch_ir_optim(True)

        # create predictor
        predictor = inference.create_predictor(config)
        input_names = predictor.get_input_names()
        for name in input_names:
            input_tensor = predictor.get_input_handle(name)
        output_names = predictor.get_output_names()
        output_tensors = []
        for output_name in output_names:
            output_tensor = predictor.get_output_handle(output_name)
            output_tensors.append(output_tensor)
        return predictor, input_tensor, output_tensors, config
WenmuZhou's avatar
WenmuZhou committed
313
314


LDOUBLEV's avatar
LDOUBLEV committed
315
def get_infer_gpuid():
ronny1996's avatar
ronny1996 committed
316
317
318
319
    if not paddle.fluid.core.is_compiled_with_rocm():
        cmd = "env | grep CUDA_VISIBLE_DEVICES"
    else:
        cmd = "env | grep HIP_VISIBLE_DEVICES"
LDOUBLEV's avatar
LDOUBLEV committed
320
321
322
323
324
325
326
327
    env_cuda = os.popen(cmd).readlines()
    if len(env_cuda) == 0:
        return 0
    else:
        gpu_id = env_cuda[0].strip().split("=")[1]
        return int(gpu_id[0])


Jethong's avatar
Jethong committed
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
def draw_e2e_res(dt_boxes, strs, img_path):
    src_im = cv2.imread(img_path)
    for box, str in zip(dt_boxes, strs):
        box = box.astype(np.int32).reshape((-1, 1, 2))
        cv2.polylines(src_im, [box], True, color=(255, 255, 0), thickness=2)
        cv2.putText(
            src_im,
            str,
            org=(int(box[0, 0, 0]), int(box[0, 0, 1])),
            fontFace=cv2.FONT_HERSHEY_COMPLEX,
            fontScale=0.7,
            color=(0, 255, 0),
            thickness=1)
    return src_im


LDOUBLEV's avatar
LDOUBLEV committed
344
def draw_text_det_res(dt_boxes, img_path):
LDOUBLEV's avatar
LDOUBLEV committed
345
346
347
348
    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)
LDOUBLEV's avatar
LDOUBLEV committed
349
    return src_im
LDOUBLEV's avatar
LDOUBLEV committed
350
351


LDOUBLEV's avatar
LDOUBLEV committed
352
353
def resize_img(img, input_size=600):
    """
LDOUBLEV's avatar
LDOUBLEV committed
354
    resize img and limit the longest side of the image to input_size
LDOUBLEV's avatar
LDOUBLEV committed
355
356
357
358
359
    """
    img = np.array(img)
    im_shape = img.shape
    im_size_max = np.max(im_shape[0:2])
    im_scale = float(input_size) / float(im_size_max)
WenmuZhou's avatar
WenmuZhou committed
360
361
    img = cv2.resize(img, None, None, fx=im_scale, fy=im_scale)
    return img
LDOUBLEV's avatar
LDOUBLEV committed
362
363


WenmuZhou's avatar
WenmuZhou committed
364
365
366
367
368
def draw_ocr(image,
             boxes,
             txts=None,
             scores=None,
             drop_score=0.5,
LDOUBLEV's avatar
LDOUBLEV committed
369
             font_path="./doc/fonts/simfang.ttf"):
370
371
372
    """
    Visualize the results of OCR detection and recognition
    args:
LDOUBLEV's avatar
LDOUBLEV committed
373
        image(Image|array): RGB image
374
375
376
377
        boxes(list): boxes with shape(N, 4, 2)
        txts(list): the texts
        scores(list): txxs corresponding scores
        drop_score(float): only scores greater than drop_threshold will be visualized
WenmuZhou's avatar
WenmuZhou committed
378
        font_path: the path of font which is used to draw text
379
380
381
    return(array):
        the visualized img
    """
LDOUBLEV's avatar
LDOUBLEV committed
382
383
    if scores is None:
        scores = [1] * len(boxes)
WenmuZhou's avatar
WenmuZhou committed
384
385
386
387
    box_num = len(boxes)
    for i in range(box_num):
        if scores is not None and (scores[i] < drop_score or
                                   math.isnan(scores[i])):
LDOUBLEV's avatar
LDOUBLEV committed
388
            continue
WenmuZhou's avatar
WenmuZhou committed
389
        box = np.reshape(np.array(boxes[i]), [-1, 1, 2]).astype(np.int64)
LDOUBLEV's avatar
LDOUBLEV committed
390
        image = cv2.polylines(np.array(image), [box], True, (255, 0, 0), 2)
WenmuZhou's avatar
WenmuZhou committed
391
    if txts is not None:
LDOUBLEV's avatar
LDOUBLEV committed
392
        img = np.array(resize_img(image, input_size=600))
393
        txt_img = text_visual(
WenmuZhou's avatar
WenmuZhou committed
394
395
396
397
398
399
            txts,
            scores,
            img_h=img.shape[0],
            img_w=600,
            threshold=drop_score,
            font_path=font_path)
400
        img = np.concatenate([np.array(img), np.array(txt_img)], axis=1)
LDOUBLEV's avatar
LDOUBLEV committed
401
402
        return img
    return image
403
404


WenmuZhou's avatar
WenmuZhou committed
405
406
407
408
409
410
def draw_ocr_box_txt(image,
                     boxes,
                     txts,
                     scores=None,
                     drop_score=0.5,
                     font_path="./doc/simfang.ttf"):
411
412
413
    h, w = image.height, image.width
    img_left = image.copy()
    img_right = Image.new('RGB', (w, h), (255, 255, 255))
414
415

    import random
LDOUBLEV's avatar
LDOUBLEV committed
416

417
418
419
    random.seed(0)
    draw_left = ImageDraw.Draw(img_left)
    draw_right = ImageDraw.Draw(img_right)
WenmuZhou's avatar
WenmuZhou committed
420
421
422
    for idx, (box, txt) in enumerate(zip(boxes, txts)):
        if scores is not None and scores[idx] < drop_score:
            continue
tink2123's avatar
tink2123 committed
423
424
        color = (random.randint(0, 255), random.randint(0, 255),
                 random.randint(0, 255))
425
        draw_left.polygon(box, fill=color)
tink2123's avatar
tink2123 committed
426
427
428
429
430
431
432
433
434
435
        draw_right.polygon(
            [
                box[0][0], box[0][1], box[1][0], box[1][1], box[2][0],
                box[2][1], box[3][0], box[3][1]
            ],
            outline=color)
        box_height = math.sqrt((box[0][0] - box[3][0])**2 + (box[0][1] - box[3][
            1])**2)
        box_width = math.sqrt((box[0][0] - box[1][0])**2 + (box[0][1] - box[1][
            1])**2)
436
437
        if box_height > 2 * box_width:
            font_size = max(int(box_width * 0.9), 10)
WenmuZhou's avatar
WenmuZhou committed
438
            font = ImageFont.truetype(font_path, font_size, encoding="utf-8")
439
440
441
            cur_y = box[0][1]
            for c in txt:
                char_size = font.getsize(c)
tink2123's avatar
tink2123 committed
442
443
                draw_right.text(
                    (box[0][0] + 3, cur_y), c, fill=(0, 0, 0), font=font)
444
445
446
                cur_y += char_size[1]
        else:
            font_size = max(int(box_height * 0.8), 10)
WenmuZhou's avatar
WenmuZhou committed
447
            font = ImageFont.truetype(font_path, font_size, encoding="utf-8")
tink2123's avatar
tink2123 committed
448
449
            draw_right.text(
                [box[0][0], box[0][1]], txt, fill=(0, 0, 0), font=font)
450
451
452
453
    img_left = Image.blend(image, img_left, 0.5)
    img_show = Image.new('RGB', (w * 2, h), (255, 255, 255))
    img_show.paste(img_left, (0, 0, w, h))
    img_show.paste(img_right, (w, 0, w * 2, h))
454
455
456
    return np.array(img_show)


457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
def str_count(s):
    """
    Count the number of Chinese characters,
    a single English character and a single number
    equal to half the length of Chinese characters.
    args:
        s(string): the input of string
    return(int):
        the number of Chinese characters
    """
    import string
    count_zh = count_pu = 0
    s_len = len(s)
    en_dg_count = 0
    for c in s:
        if c in string.ascii_letters or c.isdigit() or c.isspace():
            en_dg_count += 1
        elif c.isalpha():
            count_zh += 1
        else:
            count_pu += 1
    return s_len - math.ceil(en_dg_count / 2)


WenmuZhou's avatar
WenmuZhou committed
481
482
483
484
485
486
def text_visual(texts,
                scores,
                img_h=400,
                img_w=600,
                threshold=0.,
                font_path="./doc/simfang.ttf"):
487
488
489
490
491
492
493
    """
    create new blank img and draw txt on it
    args:
        texts(list): the text will be draw
        scores(list|None): corresponding score of each txt
        img_h(int): the height of blank img
        img_w(int): the width of blank img
WenmuZhou's avatar
WenmuZhou committed
494
        font_path: the path of font which is used to draw text
495
496
497
498
499
500
501
502
503
    return(array):
    """
    if scores is not None:
        assert len(texts) == len(
            scores), "The number of txts and corresponding scores must match"

    def create_blank_img():
        blank_img = np.ones(shape=[img_h, img_w], dtype=np.int8) * 255
        blank_img[:, img_w - 1:] = 0
LDOUBLEV's avatar
LDOUBLEV committed
504
505
        blank_img = Image.fromarray(blank_img).convert("RGB")
        draw_txt = ImageDraw.Draw(blank_img)
506
        return blank_img, draw_txt
LDOUBLEV's avatar
LDOUBLEV committed
507

508
509
510
511
    blank_img, draw_txt = create_blank_img()

    font_size = 20
    txt_color = (0, 0, 0)
WenmuZhou's avatar
WenmuZhou committed
512
    font = ImageFont.truetype(font_path, font_size, encoding="utf-8")
513
514
515

    gap = font_size + 5
    txt_img_list = []
LDOUBLEV's avatar
LDOUBLEV committed
516
    count, index = 1, 0
517
518
    for idx, txt in enumerate(texts):
        index += 1
LDOUBLEV's avatar
LDOUBLEV committed
519
        if scores[idx] < threshold or math.isnan(scores[idx]):
520
521
522
523
524
525
526
527
528
529
530
            index -= 1
            continue
        first_line = True
        while str_count(txt) >= img_w // font_size - 4:
            tmp = txt
            txt = tmp[:img_w // font_size - 4]
            if first_line:
                new_txt = str(index) + ': ' + txt
                first_line = False
            else:
                new_txt = '    ' + txt
LDOUBLEV's avatar
LDOUBLEV committed
531
            draw_txt.text((0, gap * count), new_txt, txt_color, font=font)
532
533
534
535
536
            txt = tmp[img_w // font_size - 4:]
            if count >= img_h // gap - 1:
                txt_img_list.append(np.array(blank_img))
                blank_img, draw_txt = create_blank_img()
                count = 0
LDOUBLEV's avatar
LDOUBLEV committed
537
            count += 1
538
539
540
        if first_line:
            new_txt = str(index) + ': ' + txt + '   ' + '%.3f' % (scores[idx])
        else:
LDOUBLEV's avatar
LDOUBLEV committed
541
            new_txt = "  " + txt + "  " + '%.3f' % (scores[idx])
LDOUBLEV's avatar
LDOUBLEV committed
542
        draw_txt.text((0, gap * count), new_txt, txt_color, font=font)
543
        # whether add new blank img or not
LDOUBLEV's avatar
LDOUBLEV committed
544
        if count >= img_h // gap - 1 and idx + 1 < len(texts):
545
546
547
            txt_img_list.append(np.array(blank_img))
            blank_img, draw_txt = create_blank_img()
            count = 0
LDOUBLEV's avatar
LDOUBLEV committed
548
        count += 1
549
550
551
552
553
554
    txt_img_list.append(np.array(blank_img))
    if len(txt_img_list) == 1:
        blank_img = np.array(txt_img_list[0])
    else:
        blank_img = np.concatenate(txt_img_list, axis=1)
    return np.array(blank_img)
LDOUBLEV's avatar
LDOUBLEV committed
555
556


dyning's avatar
dyning committed
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
def base64_to_cv2(b64str):
    import base64
    data = base64.b64decode(b64str.encode('utf8'))
    data = np.fromstring(data, np.uint8)
    data = cv2.imdecode(data, cv2.IMREAD_COLOR)
    return data


def draw_boxes(image, boxes, scores=None, drop_score=0.5):
    if scores is None:
        scores = [1] * len(boxes)
    for (box, score) in zip(boxes, scores):
        if score < drop_score:
            continue
        box = np.reshape(np.array(box), [-1, 1, 2]).astype(np.int64)
        image = cv2.polylines(np.array(image), [box], True, (255, 0, 0), 2)
    return image


WenmuZhou's avatar
WenmuZhou committed
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
def get_rotate_crop_image(img, points):
    '''
    img_height, img_width = img.shape[0:2]
    left = int(np.min(points[:, 0]))
    right = int(np.max(points[:, 0]))
    top = int(np.min(points[:, 1]))
    bottom = int(np.max(points[:, 1]))
    img_crop = img[top:bottom, left:right, :].copy()
    points[:, 0] = points[:, 0] - left
    points[:, 1] = points[:, 1] - top
    '''
    assert len(points) == 4, "shape of points must be 4*2"
    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]])
    M = cv2.getPerspectiveTransform(points, pts_std)
    dst_img = cv2.warpPerspective(
        img,
        M, (img_crop_width, img_crop_height),
        borderMode=cv2.BORDER_REPLICATE,
        flags=cv2.INTER_CUBIC)
    dst_img_height, dst_img_width = dst_img.shape[0:2]
    if dst_img_height * 1.0 / dst_img_width >= 1.5:
        dst_img = np.rot90(dst_img)
    return dst_img


zhoujun's avatar
zhoujun committed
611
612
613
614
615
616
617
def check_gpu(use_gpu):
    if use_gpu and not paddle.is_compiled_with_cuda():

        use_gpu = False
    return use_gpu


LDOUBLEV's avatar
LDOUBLEV committed
618
if __name__ == '__main__':
LDOUBLEV's avatar
LDOUBLEV committed
619
    pass