File size: 6,170 Bytes
ce0144c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 | from typing import Tuple, Sequence, Union, Optional
import numpy as np
from shapely.geometry import Polygon, JOIN_STYLE
import cv2
from mmocr.utils.polygon_utils import poly_make_valid, offset_polygon
def iou(poly1, poly2):
poly1 = Polygon(poly1)
poly2 = Polygon(poly2)
return poly1.intersection(poly2).area / poly1.union(poly2).area
def get_distance(polygon: np.ndarray,
shrink_ratio: float,
) -> float:
"""
Compute the shrinkage distance of a polygon with respect to a given
shrink ratio. This function is in reference to the PSENet approach.
ALERT! distance is compute by A(1-r)/L not A(1-r^2)/L
Args:
polygon (np.ndarray): An array representing the vertices of the polygon.
The shape of the array should be (num_points, 2), where each row represents
the (x, y) coordinates of a vertex.
shrink_ratio (float): The ratio by which the polygon is to be shrunk.
It's a value less than 1, where 1 means no shrinkage.
Returns:
distance(float): The calculated distance by which the polygon should
be shrunk.
"""
poly = polygon.reshape(-1, 2)
poly_obj = Polygon(poly)
area = poly_obj.area
peri = poly_obj.length
distance = area * (1 - shrink_ratio) / (peri + 1e-5)
return distance
def expand_poly(
polygon: np.ndarray,
shrink_ratio: float,
stretch_ratio: float,
) -> np.ndarray:
"""Generate text instance kernels according to a shrink ratio.
Args:
polygon (np.ndarray): array of text polygons.
Returns:
polygon after expansion by TKS.
"""
poly = polygon.copy().reshape(-1, 2).astype(np.float32)
distance = get_distance(poly, shrink_ratio)
# stretching on horizental
poly[:, 0] *= stretch_ratio
# no splits happen in expansion
poly = poly_make_valid(Polygon(poly))
expand_poly = np.array(poly.buffer(distance,
).exterior.coords)
expand_poly = expand_poly.reshape(-1, 2).astype(np.float32)
expand_poly[:, 0] /= stretch_ratio
return expand_poly
def stretch_kernel(
polygon: np.ndarray,
shrink_ratio: float,
stretch_ratio: float,
) -> np.ndarray:
poly = polygon.copy().reshape(-1, 2).astype(np.float32)
# get shrink distance before stretching
distance = get_distance(poly, shrink_ratio)
# stretch on x-axis
poly[:, 0] *= stretch_ratio
# shrink poly
shrunk_poly = Polygon(poly).buffer(-distance)
# if splits into multiple parts
if not isinstance(shrunk_poly, Polygon):
return np.array([]).reshape(0,2)
shrunk_poly = np.array(shrunk_poly.exterior.coords)
# shrink to NULL
if len(shrunk_poly) == 0:
return shrunk_poly
shrunk_poly = shrunk_poly.reshape(-1, 2).astype(np.float32)
shrunk_poly[:, 0] /= stretch_ratio
return shrunk_poly
def unstretch_kernel(poly_pts: np.ndarray,
shrink_ratio: float,
stretch_ratio: float,
refinement: bool = True,
unclip_ratio: float = 0,
refine_epoch: int = 30,
step_size: float = 1.0,
tolerance: float = 0.4) -> np.ndarray:
"""Unclip a polygon either adaptively or by fixed ratio.
Only used in postprocessor.
Args:
poly_pts (np.ndarray): The polygon points.
shrink_ratio(float): r used in module loss.
refinement(bool): whether doing refinement, if `refinement=false`,
then unclip polygons by fixed ratio `unclip_ratio`.
Returns:
np.ndarray: The expanded polygon points.
"""
poly_pts = poly_pts.copy().reshape(-1, 2)
poly = poly_pts.astype(np.float32)
if refinement:
# unclip adaptively
_, (_x, _y), _ = cv2.minAreaRect(poly)
poly[:, 0] *= stretch_ratio
_, (_kx, _ky), _ = cv2.minAreaRect(poly)
# adaptive distance: distance nearly same as shrink
# b is approximate (Maintaining rotation symmetry)
a = 4 * (1 / stretch_ratio + 1) - 4 / stretch_ratio * (1 - shrink_ratio)
b = 2 * (_x + _y) - 2 / stretch_ratio * (_kx + _ky) * (1 - shrink_ratio)
c = - _x * _y * (1 - shrink_ratio)
distance = (- b + np.sqrt(b ** 2 - 4 * a * c)) / (2 * a)
assert distance >= 0, 'dilate should have d > 0'
step_size = max(distance / 2, step_size)
else:
# by fixed ratio
p = Polygon(poly)
distance = p.area * unclip_ratio / p.length
poly[:, 0] *= stretch_ratio
refine_epoch = 0
poly = poly_make_valid(Polygon(poly))
expand_poly = poly.buffer(distance, )
expand_poly = np.array(expand_poly.exterior.coords)
expand_poly[:, 0] /= stretch_ratio
greater = None
for _ in range(refine_epoch):
# get shrink distance from newly recovered polygon
distance_0 = get_distance(expand_poly, shrink_ratio)
if distance_0 > distance + tolerance:
if greater is not None and not greater:
# scale step
step_size /= 2
greater = True
distance += step_size
elif distance_0 < distance - tolerance:
if greater:
# scale step
step_size /= 2
greater = False
distance -= step_size
distance = max(distance, 0)
else:
break
expand_poly = poly.buffer(distance)
expand_poly = np.array(expand_poly.exterior.coords)
expand_poly[:, 0] /= stretch_ratio
return expand_poly
def align_polygon(polygon: np.ndarray, stride: int) -> np.ndarray:
return (polygon / stride) - (stride - 1) / (2 * stride)
def fill_hole(binary_image):
floodfilled = binary_image.copy()
h, w = binary_image.shape[:2]
mask = np.zeros((h+2, w+2), np.uint8)
cv2.floodFill(floodfilled, mask, (0, 0), 255)
floodfilled_inv = cv2.bitwise_not(floodfilled)
out_image = binary_image | floodfilled_inv
return out_image
|