test_unit.py 29.8 KB
Newer Older
quyuan's avatar
quyuan committed
1
import os
drunkpig's avatar
drunkpig committed
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import pytest

from magic_pdf.libs.boxbase import (__is_overlaps_y_exceeds_threshold,
                                    _is_bottom_full_overlap, _is_in,
                                    _is_in_or_part_overlap,
                                    _is_in_or_part_overlap_with_area_ratio,
                                    _is_left_overlap, _is_part_overlap,
                                    _is_vertical_full_overlap, _left_intersect,
                                    _right_intersect, bbox_distance,
                                    bbox_relative_pos, calculate_iou,
                                    calculate_overlap_area_2_minbox_area_ratio,
                                    calculate_overlap_area_in_bbox1_area_ratio,
                                    find_bottom_nearest_text_bbox,
                                    find_left_nearest_text_bbox,
                                    find_right_nearest_text_bbox,
                                    find_top_nearest_text_bbox,
                                    get_bbox_in_boundary,
                                    get_minbox_if_overlap_by_ratio)
from magic_pdf.libs.commons import get_top_percent_list, join_path, mymax
renpengli's avatar
renpengli committed
22
from magic_pdf.libs.config_reader import get_s3_config
renpengli's avatar
renpengli committed
23
from magic_pdf.libs.path_utils import parse_s3path
renpengli's avatar
renpengli committed
24
25


renpengli's avatar
renpengli committed
26
# 输入一个列表,如果列表空返回0,否则返回最大元素
drunkpig's avatar
drunkpig committed
27
@pytest.mark.parametrize('list_input, target_num',
renpengli's avatar
renpengli committed
28
                         [
renpengli's avatar
renpengli committed
29
30
31
32
33
                             ([0, 0, 0, 0], 0),
                             ([0], 0),
                             ([1, 2, 5, 8, 4], 8),
                             ([], 0),
                             ([1.1, 7.6, 1.009, 9.9], 9.9),
renpengli's avatar
renpengli committed
34
35
36
37
38
39
40
41
42
43
                             ([1.0 * 10 ** 2, 3.5 * 10 ** 3, 0.9 * 10 ** 6], 0.9 * 10 ** 6),
                         ])
def test_list_max(list_input: list, target_num) -> None:
    """
    list_input: 输入列表元素,元素均为数字类型
    """
    assert target_num == mymax(list_input)


# 连接多个参数生成路径信息,使用"/"作为连接符,生成的结果需要是一个合法路径
drunkpig's avatar
drunkpig committed
44
@pytest.mark.parametrize('path_input, target_path', [
renpengli's avatar
renpengli committed
45
46
    (['https:', '', 'www.baidu.com'], 'https://www.baidu.com'),
    (['https:', 'www.baidu.com'], 'https:/www.baidu.com'),
renpengli's avatar
renpengli committed
47
48
49
50
51
52
53
54
55
56
    (['D:', 'file', 'pythonProject', 'demo' + '.py'], 'D:/file/pythonProject/demo.py'),
])
def test_join_path(path_input: list, target_path: str) -> None:
    """
    path_input: 输入path的列表,列表元素均为字符串
    """
    assert target_path == join_path(*path_input)


# 获取列表中前百分之多少的元素
drunkpig's avatar
drunkpig committed
57
@pytest.mark.parametrize('num_list, percent, target_num_list', [
renpengli's avatar
renpengli committed
58
59
60
    ([], 0.75, []),
    ([-5, -10, 9, 3, 7, -7, 0, 23, -1, -11], 0.8, [23, 9, 7, 3, 0, -1, -5, -7]),
    ([-5, -10, 9, 3, 7, -7, 0, 23, -1, -11], 0, []),
renpengli's avatar
renpengli committed
61
62
63
64
65
66
67
68
69
70
71
    ([-5, -10, 9, 3, 7, -7, 0, 23, -1, -11, 28], 0.8, [28, 23, 9, 7, 3, 0, -1, -5])
])
def test_get_top_percent_list(num_list: list, percent: float, target_num_list: list) -> None:
    """
    num_list: 数字列表,列表元素为数字
    percent: 占比,float, 向下取证
    """
    assert target_num_list == get_top_percent_list(num_list, percent)


# 输入一个s3路径,返回bucket名字和其余部分(key)
drunkpig's avatar
drunkpig committed
72
73
74
@pytest.mark.parametrize('s3_path, target_data', [
    ('s3://bucket/path/to/my/file.txt', 'bucket'),
    ('s3a://bucket1/path/to/my/file2.txt', 'bucket1'),
赵小蒙's avatar
赵小蒙 committed
75
76
    # ("/path/to/my/file1.txt", "path"),
    # ("bucket/path/to/my/file2.txt", "bucket"),
renpengli's avatar
renpengli committed
77
78
79
80
81
82
83
])
def test_parse_s3path(s3_path: str, target_data: str):
    """
    s3_path: s3路径
        如果为无效路径,则返回对应的bucket名字和其余部分
        如果为异常路径 例如:file2.txt,则报异常
    """
赵小蒙's avatar
赵小蒙 committed
84
85
    bucket_name, key = parse_s3path(s3_path)
    assert target_data == bucket_name
renpengli's avatar
renpengli committed
86
87
88
89
90


# 2个box是否处于包含或者部分重合关系。
# 如果某边界重合算重合。
# 部分边界重合,其他在内部也算包含
drunkpig's avatar
drunkpig committed
91
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
92
    ((120, 133, 223, 248), (128, 168, 269, 295), True),
renpengli's avatar
renpengli committed
93
94
95
96
97
98
99
100
101
102
103
104
    ((137, 53, 245, 157), (134, 11, 200, 147), True),  # 部分重合
    ((137, 56, 211, 116), (140, 66, 202, 199), True),  # 部分重合
    ((42, 34, 69, 65), (42, 34, 69, 65), True),  # 部分重合
    ((39, 63, 87, 106), (37, 66, 85, 109), True),  # 部分重合
    ((13, 37, 55, 66), (7, 46, 49, 75), True),  # 部分重合
    ((56, 83, 85, 104), (64, 85, 93, 106), True),  # 部分重合
    ((12, 53, 48, 94), (14, 53, 50, 94), True),  # 部分重合
    ((43, 54, 93, 131), (55, 82, 77, 106), True),  # 包含
    ((63, 2, 134, 71), (72, 43, 104, 78), True),  # 包含
    ((25, 57, 109, 127), (26, 73, 49, 95), True),  # 包含
    ((24, 47, 111, 115), (34, 81, 58, 106), True),  # 包含
    ((34, 8, 105, 83), (76, 20, 116, 45), True),  # 包含
renpengli's avatar
renpengli committed
105
106
107
108
109
110
111
112
113
114
115
])
def test_is_in_or_part_overlap(box1: tuple, box2: tuple, target_bool: bool) -> None:
    """
    box1: 坐标数组
    box2: 坐标数组
    """
    assert target_bool == _is_in_or_part_overlap(box1, box2)


# 如果box1在box2内部,返回True
#   如果是部分重合的,则重合面积占box1的比例大于阈值时候返回True
drunkpig's avatar
drunkpig committed
116
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
117
118
119
120
121
122
123
124
125
    ((35, 28, 108, 90), (47, 60, 83, 96), False),  # 包含 box1 up box2,  box2 多半,box1少半
    ((65, 151, 92, 177), (49, 99, 105, 198), True),  # 包含 box1 in box2
    ((80, 62, 112, 84), (74, 40, 144, 111), True),  # 包含 box1 in box2
    ((65, 88, 127, 144), (92, 102, 131, 139), False),  # 包含 box2 多半,box1约一半
    ((92, 102, 131, 139), (65, 88, 127, 144), True),  # 包含 box1 多半
    ((100, 93, 199, 168), (169, 126, 198, 165), False),  # 包含 box2 in box1
    ((26, 75, 106, 172), (65, 108, 90, 128), False),  # 包含 box2 in box1
    ((28, 90, 77, 126), (35, 84, 84, 120), True),  # 相交 box1多半,box2多半
    ((37, 6, 69, 52), (28, 3, 60, 49), True),  # 相交 box1多半,box2多半
renpengli's avatar
renpengli committed
126
127
128
129
130
131
132
133
    ((94, 29, 133, 60), (84, 30, 123, 61), True),  # 相交 box1多半,box2多半
])
def test_is_in_or_part_overlap_with_area_ratio(box1: tuple, box2: tuple, target_bool: bool) -> None:
    out_bool = _is_in_or_part_overlap_with_area_ratio(box1, box2)
    assert target_bool == out_bool


# box1在box2内部或者box2在box1内部返回True。如果部分边界重合也算作包含。
drunkpig's avatar
drunkpig committed
134
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
135
136
137
138
139
140
141
142
    # ((), (), "Error"),  # Error
    ((65, 151, 92, 177), (49, 99, 105, 198), True),  # 包含 box1 in box2
    ((80, 62, 112, 84), (74, 40, 144, 111), True),  # 包含 box1 in box2
    ((76, 140, 154, 277), (121, 326, 192, 384), False),  # 分离
    ((65, 88, 127, 144), (92, 102, 131, 139), False),  # 包含 box2 多半,box1约一半
    ((92, 102, 131, 139), (65, 88, 127, 144), False),  # 包含 box1 多半
    ((68, 94, 118, 120), (68, 90, 118, 122), True),  # 包含,box1 in box2 两边x相切
    ((69, 94, 118, 120), (68, 90, 118, 122), True),  # 包含,box1 in box2 一边x相切
renpengli's avatar
renpengli committed
143
144
145
146
147
148
149
150
151
152
153
154
155
    ((69, 114, 118, 122), (68, 90, 118, 122), True),  # 包含,box1 in box2 一边y相切
    # ((100, 93, 199, 168), (169, 126, 198, 165), True),  # 包含 box2 in box1  Error
    # ((26, 75, 106, 172), (65, 108, 90, 128), True),  # 包含 box2 in box1  Error
    # ((38, 94, 122, 120), (68, 94, 118, 120), True),  # 包含,box2 in box1 两边y相切 Error
    # ((68, 34, 118, 158), (68, 94, 118, 120), True),  # 包含,box2 in box1 两边x相切 Error
    # ((68, 34, 118, 158), (68, 94, 84, 120), True),  # 包含,box2 in box1 一边x相切 Error
    # ((27, 94, 118, 158), (68, 94, 84, 120), True),  # 包含,box2 in box1 一边y相切 Error
])
def test_is_in(box1: tuple, box2: tuple, target_bool: bool) -> None:
    assert target_bool == _is_in(box1, box2)


# 仅仅是部分包含关系,返回True,如果是完全包含关系则返回False
drunkpig's avatar
drunkpig committed
156
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
157
    ((65, 151, 92, 177), (49, 99, 105, 198), False),  # 包含 box1 in box2
renpengli's avatar
renpengli committed
158
    ((80, 62, 112, 84), (74, 40, 144, 111), False),  # 包含 box1 in box2
renpengli's avatar
renpengli committed
159
    # ((76, 140, 154, 277), (121, 326, 192, 384), False),  # 分离  Error
renpengli's avatar
renpengli committed
160
    ((76, 140, 154, 277), (121, 277, 192, 384), True),  # 外相切
renpengli's avatar
renpengli committed
161
162
163
164
165
    ((65, 88, 127, 144), (92, 102, 131, 139), True),  # 包含 box2 多半,box1约一半
    ((92, 102, 131, 139), (65, 88, 127, 144), True),  # 包含 box1 多半
    ((68, 94, 118, 120), (68, 90, 118, 122), False),  # 包含,box1 in box2 两边x相切
    ((69, 94, 118, 120), (68, 90, 118, 122), False),  # 包含,box1 in box2 一边x相切
    ((69, 114, 118, 122), (68, 90, 118, 122), False),  # 包含,box1 in box2 一边y相切
renpengli's avatar
renpengli committed
166
167
168
169
170
171
172
173
174
175
    # ((26, 75, 106, 172), (65, 108, 90, 128), False),  # 包含 box2 in box1  Error
    # ((38, 94, 122, 120), (68, 94, 118, 120), False),  # 包含,box2 in box1 两边y相切 Error
    # ((68, 34, 118, 158), (68, 94, 84, 120), False),  # 包含,box2 in box1 一边x相切 Error

])
def test_is_part_overlap(box1: tuple, box2: tuple, target_bool: bool) -> None:
    assert target_bool == _is_part_overlap(box1, box2)


# left_box右侧是否和right_box左侧有部分重叠
drunkpig's avatar
drunkpig committed
176
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
177
178
179
    (None, None, False),
    ((88, 81, 222, 173), (60, 221, 123, 358), False),  # 分离
    ((121, 149, 184, 289), (172, 130, 230, 268), True),  # box1 left bottom box2 相交
renpengli's avatar
renpengli committed
180
    ((172, 130, 230, 268), (121, 149, 184, 289), False),  # box2 left bottom box1 相交
renpengli's avatar
renpengli committed
181
182
183
184
185
186
    ((109, 68, 182, 146), (215, 188, 277, 253), False),  # box1 top left box2 分离
    ((117, 53, 222, 176), (174, 142, 298, 276), True),  # box1 left top box2 相交
    ((174, 142, 298, 276), (117, 53, 222, 176), False),  # box2 left top box1 相交
    ((65, 88, 127, 144), (92, 102, 131, 139), True),  # box1 left box2 y:box2 in box1
    ((92, 102, 131, 139), (65, 88, 127, 144), False),  # box2 left box1 y:box1 in box2
    ((182, 130, 230, 268), (121, 149, 174, 289), False),  # box2 left box1 分离
renpengli's avatar
renpengli committed
187
188
189
190
191
192
193
    ((1, 10, 26, 45), (3, 4, 20, 39), True),  # box1 bottom box2 x:box2 in box1
])
def test_left_intersect(box1: tuple, box2: tuple, target_bool: bool) -> None:
    assert target_bool == _left_intersect(box1, box2)


# left_box左侧是否和right_box右侧部分重叠
drunkpig's avatar
drunkpig committed
194
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
195
196
197
198
199
200
201
202
    (None, None, False),
    ((88, 81, 222, 173), (60, 221, 123, 358), False),  # 分离
    ((121, 149, 184, 289), (172, 130, 230, 268), False),  # box1 left bottom box2 相交
    ((172, 130, 230, 268), (121, 149, 184, 289), True),  # box2 left bottom box1 相交
    ((109, 68, 182, 146), (215, 188, 277, 253), False),  # box1 top left box2 分离
    ((117, 53, 222, 176), (174, 142, 298, 276), False),  # box1 left top box2 相交
    ((174, 142, 298, 276), (117, 53, 222, 176), True),  # box2 left top box1 相交
    ((65, 88, 127, 144), (92, 102, 131, 139), False),  # box1 left box2 y:box2 in box1
renpengli's avatar
renpengli committed
203
204
205
206
207
208
209
210
211
212
    # ((92, 102, 131, 139), (65, 88, 127, 144), True),  # box2 left box1 y:box1 in box2 Error
    ((182, 130, 230, 268), (121, 149, 174, 289), False),  # box2 left box1 分离
    # ((1, 10, 26, 45), (3, 4, 20, 39), False),  # box1 bottom box2 x:box2 in box1 Error
])
def test_right_intersect(box1: tuple, box2: tuple, target_bool: bool) -> None:
    assert target_bool == _right_intersect(box1, box2)


# x方向上:要么box1包含box2, 要么box2包含box1。不能部分包含
# y方向上:box1和box2有重叠
drunkpig's avatar
drunkpig committed
213
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
214
    # (None, None, False),  # Error
renpengli's avatar
renpengli committed
215
216
217
    ((35, 28, 108, 90), (47, 60, 83, 96), True),  # box1 top box2, x:box2 in box1, y:有重叠
    ((35, 28, 98, 90), (27, 60, 103, 96), True),  # box1 top box2, x:box1 in box2, y:有重叠
    ((57, 77, 130, 210), (59, 219, 119, 293), False),  # box1 top box2, x: box2 in box1, y:无重叠
renpengli's avatar
renpengli committed
218
    ((47, 60, 83, 96), (35, 28, 108, 90), True),  # box2 top box1, x:box1 in box2, y:有重叠
renpengli's avatar
renpengli committed
219
220
221
    ((27, 60, 103, 96), (35, 28, 98, 90), True),  # box2 top box1, x:box2 in box1, y:有重叠
    ((59, 219, 119, 293), (57, 77, 130, 210), False),  # box2 top box1, x: box1 in box2, y:无重叠
    ((35, 28, 55, 90), (57, 60, 83, 96), False),  # box1 top box2, x:无重叠, y:有重叠
renpengli's avatar
renpengli committed
222
223
224
225
226
227
228
    ((47, 60, 63, 96), (65, 28, 108, 90), False),  # box2 top box1, x:无重叠, y:有重叠
])
def test_is_vertical_full_overlap(box1: tuple, box2: tuple, target_bool: bool) -> None:
    assert target_bool == _is_vertical_full_overlap(box1, box2)


# 检查box1下方和box2的上方有轻微的重叠,轻微程度收到y_tolerance的限制
drunkpig's avatar
drunkpig committed
229
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
230
231
232
233
234
235
    (None, None, False),
    ((35, 28, 108, 90), (47, 89, 83, 116), True),  # box1 top box2, y:有重叠
    ((35, 28, 108, 90), (47, 60, 83, 96), False),  # box1 top box2, y:有重叠且过多
    ((57, 77, 130, 210), (59, 219, 119, 293), False),  # box1 top box2, y:无重叠
    ((47, 60, 83, 96), (35, 28, 108, 90), False),  # box2 top box1, y:有重叠且过多
    ((27, 89, 103, 116), (35, 28, 98, 90), False),  # box2 top box1, y:有重叠
renpengli's avatar
renpengli committed
236
237
238
239
240
241
242
    ((59, 219, 119, 293), (57, 77, 130, 210), False),  # box2 top box1, y:无重叠
])
def test_is_bottom_full_overlap(box1: tuple, box2: tuple, target_bool: bool) -> None:
    assert target_bool == _is_bottom_full_overlap(box1, box2)


# 检查box1的左侧是否和box2有重叠
drunkpig's avatar
drunkpig committed
243
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
244
245
    (None, None, False),
    ((88, 81, 222, 173), (60, 221, 123, 358), False),  # 分离
renpengli's avatar
renpengli committed
246
247
    # ((121, 149, 184, 289), (172, 130, 230, 268), False),  # box1 left bottom box2 相交  Error
    # ((172, 130, 230, 268), (121, 149, 184, 289), True),  # box2 left bottom box1 相交 Error
renpengli's avatar
renpengli committed
248
249
    ((109, 68, 182, 146), (215, 188, 277, 253), False),  # box1 top left box2 分离
    ((117, 53, 222, 176), (174, 142, 298, 276), False),  # box1 left top box2 相交
renpengli's avatar
renpengli committed
250
251
252
253
254
255
256
257
258
259
    # ((174, 142, 298, 276), (117, 53, 222, 176), True),  # box2 left top box1 相交  Error
    # ((65, 88, 127, 144), (92, 102, 131, 139), False),  # box1 left box2 y:box2 in box1 Error
    ((1, 10, 26, 45), (3, 4, 20, 39), True),  # box1 middle bottom box2 x:box2 in box1

])
def test_is_left_overlap(box1: tuple, box2: tuple, target_bool: bool) -> None:
    assert target_bool == _is_left_overlap(box1, box2)


# 查两个bbox在y轴上是否有重叠,并且该重叠区域的高度占两个bbox高度更低的那个超过阈值
drunkpig's avatar
drunkpig committed
260
@pytest.mark.parametrize('box1, box2, target_bool', [
renpengli's avatar
renpengli committed
261
    # (None, None, "Error"),  # Error
renpengli's avatar
renpengli committed
262
263
264
265
266
267
    ((51, 69, 192, 147), (75, 48, 132, 187), True),  # y: box1 in box2
    ((51, 39, 192, 197), (75, 48, 132, 187), True),  # y: box2 in box1
    ((88, 81, 222, 173), (60, 221, 123, 358), False),  # y: box1 top box2
    ((109, 68, 182, 196), (215, 188, 277, 253), False),  # y: box1 top box2 little
    ((109, 68, 182, 196), (215, 78, 277, 253), True),  # y: box1 top box2 more
    ((109, 68, 182, 196), (215, 138, 277, 213), False),  # y: box1 top box2 more but lower overlap_ratio_threshold
renpengli's avatar
renpengli committed
268
269
270
271
272
273
274
    ((109, 68, 182, 196), (215, 138, 277, 203), True),  # y: box1 top box2 more and more overlap_ratio_threshold
])
def test_is_overlaps_y_exceeds_threshold(box1: tuple, box2: tuple, target_bool: bool) -> None:
    assert target_bool == __is_overlaps_y_exceeds_threshold(box1, box2)


# Determine the coordinates of the intersection rectangle
drunkpig's avatar
drunkpig committed
275
@pytest.mark.parametrize('box1, box2, target_num', [
renpengli's avatar
renpengli committed
276
    # (None, None, "Error"),  # Error
renpengli's avatar
renpengli committed
277
278
279
280
281
282
283
    ((88, 81, 222, 173), (60, 221, 123, 358), 0.0),  # 分离
    ((76, 140, 154, 277), (121, 326, 192, 384), 0.0),  # 分离
    ((142, 109, 238, 164), (134, 211, 224, 270), 0.0),  # 分离
    ((109, 68, 182, 196), (175, 138, 277, 213), 0.024475524475524476),  # 相交
    ((56, 90, 170, 219), (103, 212, 171, 304), 0.02288586346557361),  # 相交
    ((109, 126, 204, 245), (130, 127, 232, 186), 0.33696071621517326),  # 相交
    ((109, 126, 204, 245), (110, 127, 232, 206), 0.5493822593770807),  # 相交
renpengli's avatar
renpengli committed
284
285
286
287
288
289
290
    ((76, 140, 154, 277), (121, 277, 192, 384), 0.0)  # 相切
])
def test_calculate_iou(box1: tuple, box2: tuple, target_num: float) -> None:
    assert target_num == calculate_iou(box1, box2)


# 计算box1和box2的重叠面积占最小面积的box的比例
drunkpig's avatar
drunkpig committed
291
@pytest.mark.parametrize('box1, box2, target_num', [
renpengli's avatar
renpengli committed
292
    # (None, None, "Error"),  # Error
renpengli's avatar
renpengli committed
293
    ((142, 109, 238, 164), (134, 211, 224, 270), 0.0),  # 分离
renpengli's avatar
renpengli committed
294
    ((88, 81, 222, 173), (60, 221, 123, 358), 0.0),  # 分离
renpengli's avatar
renpengli committed
295
296
297
298
299
300
301
302
303
    ((76, 140, 154, 277), (121, 326, 192, 384), 0.0),  # 分离
    ((76, 140, 154, 277), (121, 277, 192, 384), 0.0),  # 相切
    ((109, 126, 204, 245), (110, 127, 232, 206), 0.7704918032786885),  # 相交
    ((56, 90, 170, 219), (103, 212, 171, 304), 0.07496803069053709),  # 相交
    ((121, 149, 184, 289), (172, 130, 230, 268), 0.17841079460269865),  # 相交
    ((51, 69, 192, 147), (75, 48, 132, 187), 0.5611510791366906),  # 相交
    ((117, 53, 222, 176), (174, 142, 298, 276), 0.12636469221835075),  # 相交
    ((102, 60, 233, 203), (70, 190, 220, 319), 0.08188757807078417),  # 相交
    ((109, 126, 204, 245), (130, 127, 232, 186), 0.7254901960784313),  # 相交
renpengli's avatar
renpengli committed
304
305
306
307
308
309
])
def test_calculate_overlap_area_2_minbox_area_ratio(box1: tuple, box2: tuple, target_num: float) -> None:
    assert target_num == calculate_overlap_area_2_minbox_area_ratio(box1, box2)


# 计算box1和box2的重叠面积占bbox1的比例
drunkpig's avatar
drunkpig committed
310
@pytest.mark.parametrize('box1, box2, target_num', [
renpengli's avatar
renpengli committed
311
    # (None, None, "Error"),  # Error
renpengli's avatar
renpengli committed
312
313
314
315
316
317
318
319
320
321
322
    ((142, 109, 238, 164), (134, 211, 224, 270), 0.0),  # 分离
    ((88, 81, 222, 173), (60, 221, 123, 358), 0.0),  # 分离
    ((76, 140, 154, 277), (121, 326, 192, 384), 0.0),  # 分离
    ((76, 140, 154, 277), (121, 277, 192, 384), 0.0),  # 相切
    ((142, 109, 238, 164), (134, 164, 224, 270), 0.0),  # 相切
    ((109, 126, 204, 245), (110, 127, 232, 206), 0.6568774878372402),  # 相交
    ((56, 90, 170, 219), (103, 212, 171, 304), 0.03189174486604107),  # 相交
    ((121, 149, 184, 289), (172, 130, 230, 268), 0.1619047619047619),  # 相交
    ((51, 69, 192, 147), (75, 48, 132, 187), 0.40425531914893614),  # 相交
    ((117, 53, 222, 176), (174, 142, 298, 276), 0.12636469221835075),  # 相交
    ((102, 60, 233, 203), (70, 190, 220, 319), 0.08188757807078417),  # 相交
renpengli's avatar
renpengli committed
323
324
325
326
327
328
329
    ((109, 126, 204, 245), (130, 127, 232, 186), 0.38620079610791685),  # 相交
])
def test_calculate_overlap_area_in_bbox1_area_ratio(box1: tuple, box2: tuple, target_num: float) -> None:
    assert target_num == calculate_overlap_area_in_bbox1_area_ratio(box1, box2)


# 计算两个bbox重叠的面积占最小面积的box的比例,如果比例大于ratio,则返回小的那个bbox,否则返回None
drunkpig's avatar
drunkpig committed
330
@pytest.mark.parametrize('box1, box2, ratio, target_box', [
renpengli's avatar
renpengli committed
331
332
    # (None, None, 0.8, "Error"),  # Error
    ((142, 109, 238, 164), (134, 211, 224, 270), 0.0, None),  # 分离
renpengli's avatar
renpengli committed
333
334
335
336
337
338
339
    ((109, 126, 204, 245), (110, 127, 232, 206), 0.5, (110, 127, 232, 206)),
    ((56, 90, 170, 219), (103, 212, 171, 304), 0.5, None),
    ((121, 149, 184, 289), (172, 130, 230, 268), 0.5, None),
    ((51, 69, 192, 147), (75, 48, 132, 187), 0.5, (75, 48, 132, 187)),
    ((117, 53, 222, 176), (174, 142, 298, 276), 0.5, None),
    ((102, 60, 233, 203), (70, 190, 220, 319), 0.5, None),
    ((109, 126, 204, 245), (130, 127, 232, 186), 0.5, (130, 127, 232, 186)),
renpengli's avatar
renpengli committed
340
341
342
343
344
])
def test_get_minbox_if_overlap_by_ratio(box1: tuple, box2: tuple, ratio: float, target_box: list) -> None:
    assert target_box == get_minbox_if_overlap_by_ratio(box1, box2, ratio)


renpengli's avatar
renpengli committed
345
# 根据boundry获取在这个范围内的所有的box的列表,完全包含关系
drunkpig's avatar
drunkpig committed
346
@pytest.mark.parametrize('boxes, boundary, target_boxs', [
renpengli's avatar
renpengli committed
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
    # ([], (), "Error"),  # Error
    ([], (110, 340, 209, 387), []),
    ([(142, 109, 238, 164)], (134, 211, 224, 270), []),  # 分离
    ([(109, 126, 204, 245), (110, 127, 232, 206)], (105, 116, 258, 300), [(109, 126, 204, 245), (110, 127, 232, 206)]),
    ([(109, 126, 204, 245), (110, 127, 232, 206)], (105, 116, 258, 230), [(110, 127, 232, 206)]),
    ([(81, 280, 123, 315), (282, 203, 342, 247), (183, 100, 300, 155), (46, 99, 133, 148), (33, 156, 97, 211),
      (137, 29, 287, 87)], (80, 90, 249, 200), []),
    ([(81, 280, 123, 315), (282, 203, 342, 247), (183, 100, 300, 155), (46, 99, 133, 148), (33, 156, 97, 211),
      (137, 29, 287, 87)], (30, 20, 349, 320),
     [(81, 280, 123, 315), (282, 203, 342, 247), (183, 100, 300, 155), (46, 99, 133, 148), (33, 156, 97, 211),
      (137, 29, 287, 87)]),
    ([(81, 280, 123, 315), (282, 203, 342, 247), (183, 100, 300, 155), (46, 99, 133, 148), (33, 156, 97, 211),
      (137, 29, 287, 87)], (30, 20, 200, 320),
     [(81, 280, 123, 315), (46, 99, 133, 148), (33, 156, 97, 211)]),
])
drunkpig's avatar
drunkpig committed
362
363
def test_get_bbox_in_boundary(boxes: list, boundary: tuple, target_boxs: list) -> None:
    assert target_boxs == get_bbox_in_boundary(boxes, boundary)
renpengli's avatar
renpengli committed
364
365
366


# 寻找上方距离最近的box,margin 4个单位, x方向有重合,y方向最近的
drunkpig's avatar
drunkpig committed
367
368
369
370
@pytest.mark.parametrize('pymu_blocks, obj_box, target_boxs', [
    ([{'bbox': (81, 280, 123, 315)}, {'bbox': (282, 203, 342, 247)}, {'bbox': (183, 100, 300, 155)},
      {'bbox': (46, 99, 133, 148)}, {'bbox': (33, 156, 97, 211)},
      {'bbox': (137, 29, 287, 87)}], (81, 280, 123, 315), {'bbox': (33, 156, 97, 211)}),
renpengli's avatar
renpengli committed
371
372
373
374
375
376
377
    # ([{"bbox": (168, 120, 263, 159)},
    #   {"bbox": (231, 61, 279, 159)},
    #   {"bbox": (35, 85, 136, 110)},
    #   {"bbox": (228, 193, 347, 225)},
    #   {"bbox": (144, 264, 188, 323)},
    #   {"bbox": (62, 37, 126, 64)}], (228, 193, 347, 225),
    #  [{"bbox": (168, 120, 263, 159)}, {"bbox": (231, 61, 279, 159)}]),  # y:方向最近的有两个,x: 两个均有重合 Error
drunkpig's avatar
drunkpig committed
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
    ([{'bbox': (35, 85, 136, 159)},
      {'bbox': (168, 120, 263, 159)},
      {'bbox': (231, 61, 279, 118)},
      {'bbox': (228, 193, 347, 225)},
      {'bbox': (144, 264, 188, 323)},
      {'bbox': (62, 37, 126, 64)}], (228, 193, 347, 225),
     {'bbox': (168, 120, 263, 159)},),  # y:方向最近的有两个,x:只有一个有重合
    ([{'bbox': (239, 115, 379, 167)},
      {'bbox': (33, 237, 104, 262)},
      {'bbox': (124, 288, 168, 325)},
      {'bbox': (242, 291, 379, 340)},
      {'bbox': (55, 117, 121, 154)},
      {'bbox': (266, 183, 384, 217)}, ], (124, 288, 168, 325), {'bbox': (55, 117, 121, 154)}),
    ([{'bbox': (239, 115, 379, 167)},
      {'bbox': (33, 237, 104, 262)},
      {'bbox': (124, 288, 168, 325)},
      {'bbox': (242, 291, 379, 340)},
      {'bbox': (55, 117, 119, 154)},
      {'bbox': (266, 183, 384, 217)}, ], (124, 288, 168, 325), None),  # x没有重合
    ([{'bbox': (80, 90, 249, 200)},
      {'bbox': (183, 100, 240, 155)}, ], (183, 100, 240, 155), None),  # 包含
renpengli's avatar
renpengli committed
399
400
401
402
403
404
])
def test_find_top_nearest_text_bbox(pymu_blocks: list, obj_box: tuple, target_boxs: dict) -> None:
    assert target_boxs == find_top_nearest_text_bbox(pymu_blocks, obj_box)


# 寻找下方距离自己最近的box, x方向有重合,y方向最近的
drunkpig's avatar
drunkpig committed
405
406
407
408
409
410
411
412
413
414
415
416
417
@pytest.mark.parametrize('pymu_blocks, obj_box, target_boxs', [
    ([{'bbox': (165, 96, 300, 114)},
      {'bbox': (11, 157, 139, 201)},
      {'bbox': (124, 208, 265, 262)},
      {'bbox': (124, 283, 248, 306)},
      {'bbox': (39, 267, 84, 301)},
      {'bbox': (36, 89, 114, 145)}, ], (165, 96, 300, 114), {'bbox': (124, 208, 265, 262)}),
    ([{'bbox': (187, 37, 303, 49)},
      {'bbox': (2, 227, 90, 283)},
      {'bbox': (158, 174, 200, 212)},
      {'bbox': (259, 174, 324, 228)},
      {'bbox': (205, 61, 316, 97)},
      {'bbox': (295, 248, 374, 287)}, ], (205, 61, 316, 97), {'bbox': (259, 174, 324, 228)}),  # y有两个最近的, x只有一个重合
renpengli's avatar
renpengli committed
418
419
420
421
422
423
424
    # ([{"bbox": (187, 37, 303, 49)},
    #   {"bbox": (2, 227, 90, 283)},
    #   {"bbox": (259, 174, 324, 228)},
    #   {"bbox": (205, 61, 316, 97)},
    #   {"bbox": (295, 248, 374, 287)},
    #   {"bbox": (158, 174, 209, 212)}, ], (205, 61, 316, 97),
    #  [{"bbox": (259, 174, 324, 228)}, {"bbox": (158, 174, 209, 212)}]),  # x有重合,y有两个最近的  Error
drunkpig's avatar
drunkpig committed
425
426
427
428
429
430
431
432
    ([{'bbox': (287, 132, 398, 191)},
      {'bbox': (44, 141, 163, 188)},
      {'bbox': (132, 191, 240, 241)},
      {'bbox': (81, 25, 142, 67)},
      {'bbox': (74, 297, 116, 314)},
      {'bbox': (77, 84, 224, 107)}, ], (287, 132, 398, 191), None),  # x没有重合
    ([{'bbox': (80, 90, 249, 200)},
      {'bbox': (183, 100, 240, 155)}, ], (183, 100, 240, 155), None),  # 包含
renpengli's avatar
renpengli committed
433
434
435
436
437
438
])
def test_find_bottom_nearest_text_bbox(pymu_blocks: list, obj_box: tuple, target_boxs: dict) -> None:
    assert target_boxs == find_bottom_nearest_text_bbox(pymu_blocks, obj_box)


# 寻找左侧距离自己最近的box, y方向有重叠,x方向最近
drunkpig's avatar
drunkpig committed
439
440
441
442
@pytest.mark.parametrize('pymu_blocks, obj_box, target_boxs', [
    ([{'bbox': (80, 90, 249, 200)}, {'bbox': (183, 100, 240, 155)}], (183, 100, 240, 155), None),  # 包含
    ([{'bbox': (28, 90, 77, 126)}, {'bbox': (35, 84, 84, 120)}], (35, 84, 84, 120), None),  # y:重叠,x:重叠大于2
    ([{'bbox': (28, 90, 77, 126)}, {'bbox': (75, 84, 134, 120)}], (75, 84, 134, 120), {'bbox': (28, 90, 77, 126)}),
renpengli's avatar
renpengli committed
443
    # y:重叠,x:重叠小于等于2
drunkpig's avatar
drunkpig committed
444
445
446
447
448
449
    ([{'bbox': (239, 115, 379, 167)},
      {'bbox': (33, 237, 104, 262)},
      {'bbox': (124, 288, 168, 325)},
      {'bbox': (242, 291, 379, 340)},
      {'bbox': (55, 113, 161, 154)},
      {'bbox': (266, 123, 384, 217)}], (266, 123, 384, 217), {'bbox': (55, 113, 161, 154)}),  # y重叠,x left
renpengli's avatar
renpengli committed
450
451
452
453
454
455
456
457
458
459
460
461
462
    # ([{"bbox": (136, 219, 268, 240)},
    #   {"bbox": (169, 115, 268, 181)},
    #   {"bbox": (33, 237, 104, 262)},
    #   {"bbox": (124, 288, 168, 325)},
    #   {"bbox": (55, 117, 161, 154)},
    #   {"bbox": (266, 183, 384, 217)}], (266, 183, 384, 217),
    #  [{"bbox": (136, 219, 267, 240)}, {"bbox": (169, 115, 267, 181)}]),  # y有重叠,x重叠小于2或者在left Error
])
def test_find_left_nearest_text_bbox(pymu_blocks: list, obj_box: tuple, target_boxs: dict) -> None:
    assert target_boxs == find_left_nearest_text_bbox(pymu_blocks, obj_box)


# 寻找右侧距离自己最近的box, y方向有重叠,x方向最近
drunkpig's avatar
drunkpig committed
463
464
465
466
@pytest.mark.parametrize('pymu_blocks, obj_box, target_boxs', [
    ([{'bbox': (80, 90, 249, 200)}, {'bbox': (183, 100, 240, 155)}], (183, 100, 240, 155), None),  # 包含
    ([{'bbox': (28, 90, 77, 126)}, {'bbox': (35, 84, 84, 120)}], (28, 90, 77, 126), None),  # y:重叠,x:重叠大于2
    ([{'bbox': (28, 90, 77, 126)}, {'bbox': (75, 84, 134, 120)}], (28, 90, 77, 126), {'bbox': (75, 84, 134, 120)}),
renpengli's avatar
renpengli committed
467
    # y:重叠,x:重叠小于等于2
drunkpig's avatar
drunkpig committed
468
469
470
471
472
473
    ([{'bbox': (239, 115, 379, 167)},
      {'bbox': (33, 237, 104, 262)},
      {'bbox': (124, 288, 168, 325)},
      {'bbox': (242, 291, 379, 340)},
      {'bbox': (55, 113, 161, 154)},
      {'bbox': (266, 123, 384, 217)}], (55, 113, 161, 154), {'bbox': (239, 115, 379, 167)}),  # y重叠,x right
renpengli's avatar
renpengli committed
474
475
476
477
478
479
480
481
482
483
    # ([{"bbox": (169, 115, 298, 181)},
    #   {"bbox": (169, 219, 268, 240)},
    #   {"bbox": (33, 177, 104, 262)},
    #   {"bbox": (124, 288, 168, 325)},
    #   {"bbox": (55, 117, 161, 154)},
    #   {"bbox": (266, 183, 384, 217)}], (33, 177, 104, 262),
    #  [{"bbox": (169, 115, 298, 181)}, {"bbox": (169, 219, 268, 240)}]),  # y有重叠,x重叠小于2或者在right Error
])
def test_find_right_nearest_text_bbox(pymu_blocks: list, obj_box: tuple, target_boxs: dict) -> None:
    assert target_boxs == find_right_nearest_text_bbox(pymu_blocks, obj_box)
renpengli's avatar
renpengli committed
484
485
486


# 判断两个矩形框的相对位置关系 (left, right, bottom, top)
drunkpig's avatar
drunkpig committed
487
@pytest.mark.parametrize('box1, box2, target_box', [
renpengli's avatar
renpengli committed
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
    # (None, None, "Error"),  # Error
    ((80, 90, 249, 200), (183, 100, 240, 155), (False, False, False, False)),  # 包含
    # ((124, 81, 222, 173), (60, 221, 123, 358), (False, True, False, True)),  # 分离,右上 Error
    ((142, 109, 238, 164), (134, 211, 224, 270), (False, False, False, True)),  # 分离,上
    # ((51, 69, 192, 147), (205, 198, 282, 297), (True, False, False, True)),  # 分离,左上 Error
    # ((101, 149, 164, 289), (172, 130, 230, 268), (True, False, False, False)),  # 分离,左  Error
    # ((69, 196, 124, 285), (130, 127, 232, 186), (True, False, True, False)),  # 分离,左下  Error
    ((103, 212, 171, 304), (56, 90, 170, 209), (False, False, True, False)),  # 分离,下
    # ((124, 367, 222, 415), (60, 221, 123, 358), (False, True, True, False)),  # 分离,右下 Error
    # ((172, 130, 230, 268), (101, 149, 164, 289), (False, True, False, False)),  # 分离,右  Error
])
def test_bbox_relative_pos(box1: tuple, box2: tuple, target_box: tuple) -> None:
    assert target_box == bbox_relative_pos(box1, box2)


# 计算两个矩形框的距离
"""
受bbox_relative_pos方法的影响,左右相反,这里计算结果全部受影响,在错误的基础上计算出了正确的结果
"""


drunkpig's avatar
drunkpig committed
509
@pytest.mark.parametrize('box1, box2, target_num', [
renpengli's avatar
renpengli committed
510
511
512
513
514
515
516
517
518
519
520
521
    # (None, None, "Error"),  # Error
    ((80, 90, 249, 200), (183, 100, 240, 155), 0.0),  # 包含
    ((142, 109, 238, 164), (134, 211, 224, 270), 47.0),  # 分离,上
    ((103, 212, 171, 304), (56, 90, 170, 209), 3.0),  # 分离,下
    ((101, 149, 164, 289), (172, 130, 230, 268), 8.0),  # 分离,左
    ((172, 130, 230, 268), (101, 149, 164, 289), 8.0),  # 分离,右
    ((80.3, 90.8, 249.0, 200.5), (183.8, 100.6, 240.2, 155.1), 0.0),  # 包含
    ((142.3, 109.5, 238.9, 164.2), (134.4, 211.2, 224.8, 270.1), 47.0),  # 分离,上
    ((103.5, 212.6, 171.1, 304.8), (56.1, 90.9, 170.6, 209.2), 3.4),  # 分离,下
    ((101.1, 149.3, 164.9, 289.0), (172.1, 130.1, 230.5, 268.5), 7.2),  # 分离,左
    ((172.1, 130.3, 230.1, 268.1), (101.2, 149.9, 164.3, 289.1), 7.8),  # 分离,右
    ((124.3, 81.1, 222.5, 173.8), (60.3, 221.5, 123.0, 358.9), 47.717711596429254),  # 分离,右上
renpengli's avatar
renpengli committed
522
523
524
    ((51.2, 69.31, 192.5, 147.9), (205.0, 198.1, 282.98, 297.09), 51.73287156151299),  # 分离,左上
    ((124.3, 367.1, 222.9, 415.7), (60.9, 221.4, 123.2, 358.6), 8.570880934886448),  # 分离,右下
    ((69.9, 196.2, 124.1, 285.7), (130.0, 127.3, 232.6, 186.1), 11.69700816448377),  # 分离,左下
renpengli's avatar
renpengli committed
525
526
527
528
])
def test_bbox_distance(box1: tuple, box2: tuple, target_num: float) -> None:
    assert target_num - bbox_distance(box1, box2) < 1

drunkpig's avatar
drunkpig committed
529
530

@pytest.mark.skip(reason='skip')
renpengli's avatar
renpengli committed
531
532
# 根据bucket_name获取s3配置ak,sk,endpoint
def test_get_s3_config() -> None:
drunkpig's avatar
drunkpig committed
533
    bucket_name = os.getenv('bucket_name')
quyuan's avatar
quyuan committed
534
    target_data = os.getenv('target_data')
quyuan's avatar
quyuan committed
535
536
537
    assert convert_string_to_list(target_data) == list(get_s3_config(bucket_name))


drunkpig's avatar
drunkpig committed
538
539
540
541
542
def convert_string_to_list(s):
    cleaned_s = s.strip("'")
    items = cleaned_s.split(',')
    cleaned_items = [item.strip() for item in items]
    return cleaned_items