|
|
import math |
|
|
from shapely.geometry import Polygon |
|
|
from functools import cmp_to_key |
|
|
|
|
|
|
|
|
def calc_main_angle(pts_list): |
|
|
if len(pts_list) == 0: |
|
|
return 0 |
|
|
good_angles, other_angles = [], [] |
|
|
for pts in pts_list: |
|
|
d_x_1, d_y_1 = pts[2] - pts[0], pts[3] - pts[1] |
|
|
d_x_2, d_y_2 = pts[4] - pts[2], pts[5] - pts[3] |
|
|
|
|
|
width = math.sqrt(d_x_1 ** 2 + d_y_1 ** 2) |
|
|
height = math.sqrt(d_x_2 ** 2 + d_y_2 ** 2) |
|
|
angle = math.atan2(d_y_1, d_x_1) |
|
|
|
|
|
if width > height * 3: |
|
|
good_angles.append(angle) |
|
|
else: |
|
|
other_angles.append(angle) |
|
|
|
|
|
if len(good_angles) > 0: |
|
|
good_angles.sort() |
|
|
return good_angles[len(good_angles) // 2] |
|
|
else: |
|
|
other_angles.sort() |
|
|
return other_angles[len(other_angles) // 2] |
|
|
|
|
|
|
|
|
def calc_x_type(a, b): |
|
|
x_type = 0 |
|
|
minx_a, maxx_a = a[0], a[0] + a[2] |
|
|
minx_b, maxx_b = b[0], b[0] + b[2] |
|
|
|
|
|
start_left = 0 |
|
|
if minx_a < minx_b: |
|
|
start_left = 1 |
|
|
elif minx_a > minx_b: |
|
|
start_left = -1 |
|
|
end_right = 0 |
|
|
if maxx_a > maxx_b: |
|
|
end_right = 1 |
|
|
elif maxx_a < maxx_b: |
|
|
end_right = -1 |
|
|
|
|
|
if maxx_a < minx_b + 1e-4 and maxx_a < maxx_b - 1e-4: |
|
|
x_type = 1 |
|
|
elif minx_a > maxx_b - 1e-4 and minx_a > minx_b + 1e-4: |
|
|
x_type = 2 |
|
|
elif start_left == 1 and end_right == -1: |
|
|
x_type = 3 |
|
|
elif start_left == -1 and end_right == 1: |
|
|
x_type = 4 |
|
|
elif start_left >= 0 and end_right >= 0: |
|
|
x_type = 5 |
|
|
elif start_left <= 0 and end_right <= 0: |
|
|
x_type = 6 |
|
|
else: |
|
|
x_type = 0 |
|
|
|
|
|
return x_type |
|
|
|
|
|
|
|
|
def calc_y_type(a, b): |
|
|
y_type = 0 |
|
|
miny_a, maxy_a = a[1], a[1] + a[3] |
|
|
miny_b, maxy_b = b[1], b[1] + b[3] |
|
|
|
|
|
start_up = 0 |
|
|
if miny_a < miny_b: |
|
|
start_up = 1 |
|
|
elif miny_a > miny_b: |
|
|
start_up = -1 |
|
|
end_down = 0 |
|
|
if maxy_a > maxy_b: |
|
|
end_down = 1 |
|
|
elif maxy_a < maxy_b: |
|
|
end_down = -1 |
|
|
|
|
|
if maxy_a < miny_b + 1e-4 and maxy_a < maxy_b - 1e-4: |
|
|
y_type = 1 |
|
|
elif miny_a > maxy_b - 1e-4 and miny_a > miny_b + 1e-4: |
|
|
y_type = 2 |
|
|
elif start_up == 1 and end_down == -1: |
|
|
y_type = 3 |
|
|
elif start_up == -1 and end_down == 1: |
|
|
y_type = 4 |
|
|
elif start_up >= 0 and end_down >= 0: |
|
|
y_type = 5 |
|
|
elif start_up <= 0 and end_down <= 0: |
|
|
y_type = 6 |
|
|
else: |
|
|
y_type = 0 |
|
|
|
|
|
return y_type |
|
|
|
|
|
|
|
|
def sort_pts(blocks): |
|
|
main_angle = calc_main_angle([blk['pts'] for blk in blocks]) |
|
|
main_sin, main_cos = math.sin(main_angle), math.cos(main_angle) |
|
|
|
|
|
def pts2rect(pts): |
|
|
xs, ys = [], [] |
|
|
for k in range(0, len(pts), 2): |
|
|
x0 = pts[k] * main_cos + pts[k + 1] * main_sin |
|
|
y0 = pts[k + 1] * main_cos - pts[k] * main_sin |
|
|
xs.append(x0) |
|
|
ys.append(y0) |
|
|
minx, maxx, miny, maxy = min(xs), max(xs), min(ys), max(ys) |
|
|
rect = [minx, miny, maxx - minx, maxy - miny] |
|
|
|
|
|
return rect |
|
|
|
|
|
def cmp_pts_udlr(a, b, thres=0.5): |
|
|
rect_a, rect_b = pts2rect(a['pts']), pts2rect(b['pts']) |
|
|
minx_a, miny_a, maxx_a, maxy_a = ( |
|
|
rect_a[0], |
|
|
rect_a[1], |
|
|
rect_a[0] + rect_a[2], |
|
|
rect_a[1] + rect_a[3], |
|
|
) |
|
|
minx_b, miny_b, maxx_b, maxy_b = ( |
|
|
rect_b[0], |
|
|
rect_b[1], |
|
|
rect_b[0] + rect_b[2], |
|
|
rect_b[1] + rect_b[3], |
|
|
) |
|
|
|
|
|
x_type, y_type = calc_x_type(rect_a, rect_b), calc_y_type(rect_a, rect_b) |
|
|
|
|
|
y_near_rate = 0.0 |
|
|
if y_type == 3: |
|
|
y_near_rate = (maxy_a - miny_b) / min(maxy_a - miny_a, maxy_b - miny_b) |
|
|
elif y_type == 4: |
|
|
y_near_rate = (maxy_b - miny_a) / min(maxy_a - miny_a, maxy_b - miny_b) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if y_type == 1: |
|
|
return -1 |
|
|
elif y_type == 2: |
|
|
return 1 |
|
|
elif y_type == 3: |
|
|
if x_type in [2, 4]: |
|
|
if y_near_rate < thres: |
|
|
return -1 |
|
|
else: |
|
|
return 1 |
|
|
else: |
|
|
return -1 |
|
|
elif y_type == 4: |
|
|
if x_type in [1, 3]: |
|
|
if y_near_rate < thres: |
|
|
return 1 |
|
|
else: |
|
|
return -1 |
|
|
else: |
|
|
return 1 |
|
|
else: |
|
|
if x_type == 1 or x_type == 3: |
|
|
return -1 |
|
|
elif x_type == 2 or x_type == 4: |
|
|
return 1 |
|
|
else: |
|
|
center_y_diff = abs(0.5 * (miny_a + maxy_a) - 0.5 * (miny_b + maxy_b)) |
|
|
max_h = max(maxy_a - miny_a, maxy_b - miny_b) |
|
|
if center_y_diff / max_h < 0.1: |
|
|
if (minx_a + maxx_a) < (minx_b + maxx_b): |
|
|
return -1 |
|
|
elif (minx_a + maxx_a) > (minx_b + maxx_b): |
|
|
return 1 |
|
|
else: |
|
|
return 0 |
|
|
else: |
|
|
if (miny_a + maxy_a) < (miny_b + maxy_b): |
|
|
return -1 |
|
|
elif (miny_a + maxy_a) > (miny_b + maxy_b): |
|
|
return 1 |
|
|
else: |
|
|
return 0 |
|
|
|
|
|
|
|
|
|
|
|
blocks.sort(key=cmp_to_key(cmp_pts_udlr)) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def pts2poly(pts): |
|
|
new_pts = [(pts[k], pts[k + 1]) for k in range(0, len(pts), 2)] |
|
|
return Polygon(new_pts) |
|
|
|
|
|
|
|
|
def pts_intersection_rate(src, tgt): |
|
|
src_poly, tgt_poly = pts2poly(src), pts2poly(tgt) |
|
|
src_area = src_poly.area |
|
|
inter_area = src_poly.intersection(tgt_poly).area |
|
|
return inter_area / src_area |
|
|
|
|
|
|
|
|
def wrap_result(layout_detection_info, subfield_detection_info, category_map): |
|
|
if layout_detection_info is None or subfield_detection_info is None: |
|
|
return {} |
|
|
|
|
|
|
|
|
|
|
|
info = {'subfields': []} |
|
|
for itm in subfield_detection_info: |
|
|
subfield = { |
|
|
'category': category_map[itm['category_id']], |
|
|
'pts': itm['poly'], |
|
|
'confidence': itm['score'], |
|
|
'layouts': [], |
|
|
} |
|
|
info['subfields'].append(subfield) |
|
|
sort_pts(info['subfields']) |
|
|
|
|
|
if len(info['subfields']) > 0: |
|
|
other_subfield = { |
|
|
'category': '其他', |
|
|
'pts': [0, 0, 0, 0, 0, 0, 0, 0], |
|
|
'confidence': 0, |
|
|
'layouts': [], |
|
|
} |
|
|
for itm in layout_detection_info: |
|
|
layout = { |
|
|
'category': category_map[itm['category_id']], |
|
|
'pts': itm['poly'], |
|
|
'confidence': itm['score'], |
|
|
} |
|
|
best_rate, best_idx = 0.0, -1 |
|
|
for k in range(len(info['subfields'])): |
|
|
inter_rate = pts_intersection_rate( |
|
|
layout['pts'], info['subfields'][k]['pts'] |
|
|
) |
|
|
if inter_rate > best_rate: |
|
|
best_rate = inter_rate |
|
|
best_idx = k |
|
|
if best_idx >= 0 and best_rate > 0.1: |
|
|
info['subfields'][best_idx]['layouts'].append(layout) |
|
|
else: |
|
|
other_subfield['layouts'].append(layout) |
|
|
if len(other_subfield['layouts']) > 0: |
|
|
info['subfields'].append(other_subfield) |
|
|
else: |
|
|
subfield = { |
|
|
'category': '其他', |
|
|
'pts': [0, 0, 0, 0, 0, 0, 0, 0], |
|
|
'confidence': 0, |
|
|
'layouts': [], |
|
|
} |
|
|
info['subfields'].append(subfield) |
|
|
for itm in layout_detection_info: |
|
|
layout = { |
|
|
'category': category_map[itm['category_id']], |
|
|
'pts': itm['poly'], |
|
|
'confidence': itm['score'], |
|
|
} |
|
|
info['subfields'][0]['layouts'].append(layout) |
|
|
|
|
|
for subfield in info['subfields']: |
|
|
sort_pts(subfield['layouts']) |
|
|
|
|
|
new_subfields = [] |
|
|
for subfield in info['subfields']: |
|
|
if subfield['category'] != '其他': |
|
|
new_subfields.append(subfield) |
|
|
else: |
|
|
for layout in subfield['layouts']: |
|
|
layout_subfield = { |
|
|
'category': layout['category'], |
|
|
'pts': layout['pts'], |
|
|
'confidence': layout['confidence'], |
|
|
'layouts': [layout], |
|
|
} |
|
|
new_subfields.append(layout_subfield) |
|
|
sort_pts(new_subfields) |
|
|
info['layouts'] = [] |
|
|
for subfield in new_subfields: |
|
|
for layout in subfield['layouts']: |
|
|
info['layouts'].append(layout) |
|
|
|
|
|
return info |
|
|
|
