You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
168 lines
5.1 KiB
Python
168 lines
5.1 KiB
Python
# Copyright (c) 2021 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 numpy as np
|
|
import cv2
|
|
import time
|
|
|
|
|
|
def resize_image(im, max_side_len=512):
|
|
"""
|
|
resize image to a size multiple of max_stride which is required by the network
|
|
:param im: the resized image
|
|
:param max_side_len: limit of max image size to avoid out of memory in gpu
|
|
:return: the resized image and the resize ratio
|
|
"""
|
|
h, w, _ = im.shape
|
|
|
|
resize_w = w
|
|
resize_h = h
|
|
|
|
if resize_h > resize_w:
|
|
ratio = float(max_side_len) / resize_h
|
|
else:
|
|
ratio = float(max_side_len) / 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
|
|
im = cv2.resize(im, (int(resize_w), int(resize_h)))
|
|
ratio_h = resize_h / float(h)
|
|
ratio_w = resize_w / float(w)
|
|
|
|
return im, (ratio_h, ratio_w)
|
|
|
|
|
|
def resize_image_min(im, max_side_len=512):
|
|
""" """
|
|
h, w, _ = im.shape
|
|
|
|
resize_w = w
|
|
resize_h = h
|
|
|
|
if resize_h < resize_w:
|
|
ratio = float(max_side_len) / resize_h
|
|
else:
|
|
ratio = float(max_side_len) / 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
|
|
im = cv2.resize(im, (int(resize_w), int(resize_h)))
|
|
ratio_h = resize_h / float(h)
|
|
ratio_w = resize_w / float(w)
|
|
return im, (ratio_h, ratio_w)
|
|
|
|
|
|
def resize_image_for_totaltext(im, max_side_len=512):
|
|
""" """
|
|
h, w, _ = im.shape
|
|
|
|
resize_w = w
|
|
resize_h = h
|
|
ratio = 1.25
|
|
if h * ratio > max_side_len:
|
|
ratio = float(max_side_len) / resize_h
|
|
|
|
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
|
|
im = cv2.resize(im, (int(resize_w), int(resize_h)))
|
|
ratio_h = resize_h / float(h)
|
|
ratio_w = resize_w / float(w)
|
|
return im, (ratio_h, ratio_w)
|
|
|
|
|
|
def point_pair2poly(point_pair_list):
|
|
"""
|
|
Transfer vertical point_pairs into poly point in clockwise.
|
|
"""
|
|
pair_length_list = []
|
|
for point_pair in point_pair_list:
|
|
pair_length = np.linalg.norm(point_pair[0] - point_pair[1])
|
|
pair_length_list.append(pair_length)
|
|
pair_length_list = np.array(pair_length_list)
|
|
pair_info = (
|
|
pair_length_list.max(),
|
|
pair_length_list.min(),
|
|
pair_length_list.mean(),
|
|
)
|
|
|
|
point_num = len(point_pair_list) * 2
|
|
point_list = [0] * point_num
|
|
for idx, point_pair in enumerate(point_pair_list):
|
|
point_list[idx] = point_pair[0]
|
|
point_list[point_num - 1 - idx] = point_pair[1]
|
|
return np.array(point_list).reshape(-1, 2), pair_info
|
|
|
|
|
|
def shrink_quad_along_width(quad, begin_width_ratio=0.0, end_width_ratio=1.0):
|
|
"""
|
|
Generate shrink_quad_along_width.
|
|
"""
|
|
ratio_pair = np.array([[begin_width_ratio], [end_width_ratio]], dtype=np.float32)
|
|
p0_1 = quad[0] + (quad[1] - quad[0]) * ratio_pair
|
|
p3_2 = quad[3] + (quad[2] - quad[3]) * ratio_pair
|
|
return np.array([p0_1[0], p0_1[1], p3_2[1], p3_2[0]])
|
|
|
|
|
|
def expand_poly_along_width(poly, shrink_ratio_of_width=0.3):
|
|
"""
|
|
expand poly along width.
|
|
"""
|
|
point_num = poly.shape[0]
|
|
left_quad = np.array([poly[0], poly[1], poly[-2], poly[-1]], dtype=np.float32)
|
|
left_ratio = (
|
|
-shrink_ratio_of_width
|
|
* np.linalg.norm(left_quad[0] - left_quad[3])
|
|
/ (np.linalg.norm(left_quad[0] - left_quad[1]) + 1e-6)
|
|
)
|
|
left_quad_expand = shrink_quad_along_width(left_quad, left_ratio, 1.0)
|
|
right_quad = np.array(
|
|
[
|
|
poly[point_num // 2 - 2],
|
|
poly[point_num // 2 - 1],
|
|
poly[point_num // 2],
|
|
poly[point_num // 2 + 1],
|
|
],
|
|
dtype=np.float32,
|
|
)
|
|
right_ratio = 1.0 + shrink_ratio_of_width * np.linalg.norm(
|
|
right_quad[0] - right_quad[3]
|
|
) / (np.linalg.norm(right_quad[0] - right_quad[1]) + 1e-6)
|
|
right_quad_expand = shrink_quad_along_width(right_quad, 0.0, right_ratio)
|
|
poly[0] = left_quad_expand[0]
|
|
poly[-1] = left_quad_expand[-1]
|
|
poly[point_num // 2 - 1] = right_quad_expand[1]
|
|
poly[point_num // 2] = right_quad_expand[2]
|
|
return poly
|
|
|
|
|
|
def norm2(x, axis=None):
|
|
if axis:
|
|
return np.sqrt(np.sum(x**2, axis=axis))
|
|
return np.sqrt(np.sum(x**2))
|
|
|
|
|
|
def cos(p1, p2):
|
|
return (p1 * p2).sum() / (norm2(p1) * norm2(p2))
|