para_split_v2.py 34 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736
  1. from sklearn.cluster import DBSCAN
  2. import numpy as np
  3. from loguru import logger
  4. from magic_pdf.libs.boxbase import _is_in_or_part_overlap_with_area_ratio as is_in_layout
  5. from magic_pdf.libs.ocr_content_type import ContentType, BlockType
  6. from magic_pdf.model.magic_model import MagicModel
  7. from magic_pdf.libs.Constants import *
  8. LINE_STOP_FLAG = ['.', '!', '?', '。', '!', '?', ":", ":", ")", ")", ";"]
  9. INLINE_EQUATION = ContentType.InlineEquation
  10. INTERLINE_EQUATION = ContentType.InterlineEquation
  11. TEXT = ContentType.Text
  12. def __get_span_text(span):
  13. c = span.get('content', '')
  14. if len(c) == 0:
  15. c = span.get('image_path', '')
  16. return c
  17. def __detect_list_lines(lines, new_layout_bboxes, lang):
  18. """
  19. 探测是否包含了列表,并且把列表的行分开.
  20. 这样的段落特点是,顶格字母大写/数字,紧跟着几行缩进的。缩进的行首字母含小写的。
  21. """
  22. def find_repeating_patterns2(lst):
  23. indices = []
  24. ones_indices = []
  25. i = 0
  26. while i < len(lst): # Loop through the entire list
  27. if lst[i] == 1: # If we encounter a '1', we might be at the start of a pattern
  28. start = i
  29. ones_in_this_interval = [i]
  30. i += 1
  31. # Traverse elements that are 1, 2 or 3, until we encounter something else
  32. while i < len(lst) and lst[i] in [1, 2, 3]:
  33. if lst[i] == 1:
  34. ones_in_this_interval.append(i)
  35. i += 1
  36. if len(ones_in_this_interval) > 1 or (start < len(lst) - 1 and ones_in_this_interval and lst[start + 1] in [2, 3]):
  37. indices.append((start, i - 1))
  38. ones_indices.append(ones_in_this_interval)
  39. else:
  40. i += 1
  41. return indices, ones_indices
  42. def find_repeating_patterns(lst):
  43. indices = []
  44. ones_indices = []
  45. i = 0
  46. while i < len(lst) - 1: # 确保余下元素至少有2个
  47. if lst[i] == 1 and lst[i + 1] in [2, 3]: # 额外检查以防止连续出现的1
  48. start = i
  49. ones_in_this_interval = [i]
  50. i += 1
  51. while i < len(lst) and lst[i] in [2, 3]:
  52. i += 1
  53. # 验证下一个序列是否符合条件
  54. if i < len(lst) - 1 and lst[i] == 1 and lst[i + 1] in [2, 3] and lst[i - 1] in [2, 3]:
  55. while i < len(lst) and lst[i] in [1, 2, 3]:
  56. if lst[i] == 1:
  57. ones_in_this_interval.append(i)
  58. i += 1
  59. indices.append((start, i - 1))
  60. ones_indices.append(ones_in_this_interval)
  61. else:
  62. i += 1
  63. else:
  64. i += 1
  65. return indices, ones_indices
  66. """===================="""
  67. def split_indices(slen, index_array):
  68. result = []
  69. last_end = 0
  70. for start, end in sorted(index_array):
  71. if start > last_end:
  72. # 前一个区间结束到下一个区间开始之间的部分标记为"text"
  73. result.append(('text', last_end, start - 1))
  74. # 区间内标记为"list"
  75. result.append(('list', start, end))
  76. last_end = end + 1
  77. if last_end < slen:
  78. # 如果最后一个区间结束后还有剩余的字符串,将其标记为"text"
  79. result.append(('text', last_end, slen - 1))
  80. return result
  81. """===================="""
  82. if lang != 'en':
  83. return lines, None
  84. else:
  85. total_lines = len(lines)
  86. line_fea_encode = []
  87. """
  88. 对每一行进行特征编码,编码规则如下:
  89. 1. 如果行顶格,且大写字母开头或者数字开头,编码为1
  90. 2. 如果顶格,其他非大写开头编码为4
  91. 3. 如果非顶格,首字符大写,编码为2
  92. 4. 如果非顶格,首字符非大写编码为3
  93. """
  94. for l in lines:
  95. first_char = __get_span_text(l['spans'][0])[0]
  96. layout = __find_layout_bbox_by_line(l['bbox'], new_layout_bboxes)
  97. if not layout:
  98. line_fea_encode.append(0)
  99. else:
  100. layout_left = layout[0]
  101. if l['bbox'][0] == layout_left:
  102. # if first_char.isupper() or first_char.isdigit() or not first_char.isalnum():
  103. if not first_char.isalnum():
  104. line_fea_encode.append(1)
  105. else:
  106. line_fea_encode.append(4)
  107. else:
  108. if first_char.isupper():
  109. line_fea_encode.append(2)
  110. else:
  111. line_fea_encode.append(3)
  112. # 然后根据编码进行分段, 选出来 1,2,3连续出现至少2次的行,认为是列表。
  113. list_indice, list_start_idx = find_repeating_patterns2(line_fea_encode)
  114. if len(list_indice) > 0:
  115. logger.info(f"发现了列表,列表行数:{list_indice}, {list_start_idx}")
  116. # TODO check一下这个特列表里缩进的行左侧是不是对齐的。
  117. segments = []
  118. for start, end in list_indice:
  119. for i in range(start, end + 1):
  120. if i > 0:
  121. if line_fea_encode[i] == 4:
  122. logger.info(f"列表行的第{i}行不是顶格的")
  123. break
  124. else:
  125. logger.info(f"列表行的第{start}到第{end}行是列表")
  126. return split_indices(total_lines, list_indice), list_start_idx
  127. def __valign_lines(blocks, layout_bboxes):
  128. """
  129. 在一个layoutbox内对齐行的左侧和右侧。
  130. 扫描行的左侧和右侧,如果x0, x1差距不超过一个阈值,就强行对齐到所处layout的左右两侧(和layout有一段距离)。
  131. 3是个经验值,TODO,计算得来,可以设置为1.5个正文字符。
  132. """
  133. min_distance = 3
  134. min_sample = 2
  135. new_layout_bboxes = []
  136. for layout_box in layout_bboxes:
  137. blocks_in_layoutbox = [b for b in blocks if b["type"] == BlockType.Text and is_in_layout(b['bbox'], layout_box['layout_bbox'])]
  138. if len(blocks_in_layoutbox) == 0 or len(blocks_in_layoutbox[0]["lines"]) == 0:
  139. new_layout_bboxes.append(layout_box['layout_bbox'])
  140. continue
  141. x0_lst = np.array([[line['bbox'][0], 0] for block in blocks_in_layoutbox for line in block['lines']])
  142. x1_lst = np.array([[line['bbox'][2], 0] for block in blocks_in_layoutbox for line in block['lines']])
  143. x0_clusters = DBSCAN(eps=min_distance, min_samples=min_sample).fit(x0_lst)
  144. x1_clusters = DBSCAN(eps=min_distance, min_samples=min_sample).fit(x1_lst)
  145. x0_uniq_label = np.unique(x0_clusters.labels_)
  146. x1_uniq_label = np.unique(x1_clusters.labels_)
  147. x0_2_new_val = {} # 存储旧值对应的新值映射
  148. x1_2_new_val = {}
  149. for label in x0_uniq_label:
  150. if label == -1:
  151. continue
  152. x0_index_of_label = np.where(x0_clusters.labels_ == label)
  153. x0_raw_val = x0_lst[x0_index_of_label][:, 0]
  154. x0_new_val = np.min(x0_lst[x0_index_of_label][:, 0])
  155. x0_2_new_val.update({idx: x0_new_val for idx in x0_raw_val})
  156. for label in x1_uniq_label:
  157. if label == -1:
  158. continue
  159. x1_index_of_label = np.where(x1_clusters.labels_ == label)
  160. x1_raw_val = x1_lst[x1_index_of_label][:, 0]
  161. x1_new_val = np.max(x1_lst[x1_index_of_label][:, 0])
  162. x1_2_new_val.update({idx: x1_new_val for idx in x1_raw_val})
  163. for block in blocks_in_layoutbox:
  164. for line in block['lines']:
  165. x0, x1 = line['bbox'][0], line['bbox'][2]
  166. if x0 in x0_2_new_val:
  167. line['bbox'][0] = int(x0_2_new_val[x0])
  168. if x1 in x1_2_new_val:
  169. line['bbox'][2] = int(x1_2_new_val[x1])
  170. # 其余对不齐的保持不动
  171. # 由于修改了block里的line长度,现在需要重新计算block的bbox
  172. for block in blocks_in_layoutbox:
  173. if len(block["lines"]) > 0:
  174. block['bbox'] = [min([line['bbox'][0] for line in block['lines']]),
  175. min([line['bbox'][1] for line in block['lines']]),
  176. max([line['bbox'][2] for line in block['lines']]),
  177. max([line['bbox'][3] for line in block['lines']])]
  178. """新计算layout的bbox,因为block的bbox变了。"""
  179. layout_x0 = min([block['bbox'][0] for block in blocks_in_layoutbox])
  180. layout_y0 = min([block['bbox'][1] for block in blocks_in_layoutbox])
  181. layout_x1 = max([block['bbox'][2] for block in blocks_in_layoutbox])
  182. layout_y1 = max([block['bbox'][3] for block in blocks_in_layoutbox])
  183. new_layout_bboxes.append([layout_x0, layout_y0, layout_x1, layout_y1])
  184. return new_layout_bboxes
  185. def __align_text_in_layout(blocks, layout_bboxes):
  186. """
  187. 由于ocr出来的line,有时候会在前后有一段空白,这个时候需要对文本进行对齐,超出的部分被layout左右侧截断。
  188. """
  189. for layout in layout_bboxes:
  190. lb = layout['layout_bbox']
  191. blocks_in_layoutbox = [block for block in blocks if block["type"] == BlockType.Text and is_in_layout(block['bbox'], lb)]
  192. if len(blocks_in_layoutbox) == 0:
  193. continue
  194. for block in blocks_in_layoutbox:
  195. for line in block.get("lines", []):
  196. x0, x1 = line['bbox'][0], line['bbox'][2]
  197. if x0 < lb[0]:
  198. line['bbox'][0] = lb[0]
  199. if x1 > lb[2]:
  200. line['bbox'][2] = lb[2]
  201. def __common_pre_proc(blocks, layout_bboxes):
  202. """
  203. 不分语言的,对文本进行预处理
  204. """
  205. # __add_line_period(blocks, layout_bboxes)
  206. __align_text_in_layout(blocks, layout_bboxes)
  207. aligned_layout_bboxes = __valign_lines(blocks, layout_bboxes)
  208. return aligned_layout_bboxes
  209. def __pre_proc_zh_blocks(blocks, layout_bboxes):
  210. """
  211. 对中文文本进行分段预处理
  212. """
  213. pass
  214. def __pre_proc_en_blocks(blocks, layout_bboxes):
  215. """
  216. 对英文文本进行分段预处理
  217. """
  218. pass
  219. def __group_line_by_layout(blocks, layout_bboxes):
  220. """
  221. 每个layout内的行进行聚合
  222. """
  223. # 因为只是一个block一行目前, 一个block就是一个段落
  224. blocks_group = []
  225. for lyout in layout_bboxes:
  226. blocks_in_layout = [block for block in blocks if is_in_layout(block['bbox'], lyout['layout_bbox'])]
  227. blocks_group.append(blocks_in_layout)
  228. return blocks_group
  229. def __split_para_in_layoutbox(blocks_group, new_layout_bbox, lang="en"):
  230. """
  231. lines_group 进行行分段——layout内部进行分段。lines_group内每个元素是一个Layoutbox内的所有行。
  232. 1. 先计算每个group的左右边界。
  233. 2. 然后根据行末尾特征进行分段。
  234. 末尾特征:以句号等结束符结尾。并且距离右侧边界有一定距离。
  235. 且下一行开头不留空白。
  236. """
  237. list_info = [] # 这个layout最后是不是列表,记录每一个layout里是不是列表开头,列表结尾
  238. for blocks in blocks_group:
  239. is_start_list = None
  240. is_end_list = None
  241. if len(blocks) == 0:
  242. list_info.append([False, False])
  243. continue
  244. if blocks[0]["type"] != BlockType.Text and blocks[-1]["type"] != BlockType.Text:
  245. list_info.append([False, False])
  246. continue
  247. if blocks[0]["type"] != BlockType.Text:
  248. is_start_list = False
  249. if blocks[-1]["type"] != BlockType.Text:
  250. is_end_list = False
  251. lines = [line for block in blocks if
  252. block["type"] == BlockType.Text for line in
  253. block['lines']]
  254. total_lines = len(lines)
  255. if total_lines == 1:
  256. list_info.append([False, False])
  257. continue
  258. """在进入到真正的分段之前,要对文字块从统计维度进行对齐方式的探测,
  259. 对齐方式分为以下:
  260. 1. 左对齐的文本块(特点是左侧顶格,或者左侧不顶格但是右侧顶格的行数大于非顶格的行数,顶格的首字母有大写也有小写)
  261. 1) 右侧对齐的行,单独成一段
  262. 2) 中间对齐的行,按照字体/行高聚合成一段
  263. 2. 左对齐的列表块(其特点是左侧顶格的行数小于等于非顶格的行数,非定格首字母会有小写,顶格90%是大写。并且左侧顶格行数大于1,大于1是为了这种模式连续出现才能称之为列表)
  264. 这样的文本块,顶格的为一个段落开头,紧随其后非顶格的行属于这个段落。
  265. """
  266. text_segments, list_start_line = __detect_list_lines(lines, new_layout_bbox, lang)
  267. """根据list_range,把lines分成几个部分
  268. """
  269. for list_start in list_start_line:
  270. if len(list_start) > 1:
  271. for i in range(1, len(list_start)):
  272. index = list_start[i] - 1
  273. if "content" in lines[index]["spans"][-1]:
  274. lines[index]["spans"][-1]["content"] += '\n\n'
  275. layout_list_info = [False, False] # 这个layout最后是不是列表,记录每一个layout里是不是列表开头,列表结尾
  276. for content_type, start, end in text_segments:
  277. if content_type == 'list':
  278. if start == 0 and is_start_list is None:
  279. layout_list_info[0] = True
  280. if end == total_lines - 1 and is_end_list is None:
  281. layout_list_info[1] = True
  282. list_info.append(layout_list_info)
  283. return list_info
  284. def __split_para_lines(lines: list, text_blocks: list) -> list:
  285. text_paras = []
  286. other_paras = []
  287. text_lines = []
  288. for line in lines:
  289. spans_types = [span["type"] for span in line]
  290. if ContentType.Table in spans_types:
  291. other_paras.append([line])
  292. continue
  293. if ContentType.Image in spans_types:
  294. other_paras.append([line])
  295. continue
  296. if ContentType.InterlineEquation in spans_types:
  297. other_paras.append([line])
  298. continue
  299. text_lines.append(line)
  300. for block in text_blocks:
  301. block_bbox = block["bbox"]
  302. para = []
  303. for line in text_lines:
  304. bbox = line["bbox"]
  305. if is_in_layout(bbox, block_bbox):
  306. para.append(line)
  307. if len(para) > 0:
  308. text_paras.append(para)
  309. paras = other_paras.extend(text_paras)
  310. paras_sorted = sorted(paras, key = lambda x: x[0]["bbox"][1])
  311. return paras_sorted
  312. def __connect_list_inter_layout(blocks_group, new_layout_bbox, layout_list_info, page_num, lang):
  313. """
  314. 如果上个layout的最后一个段落是列表,下一个layout的第一个段落也是列表,那么将他们连接起来。 TODO 因为没有区分列表和段落,所以这个方法暂时不实现。
  315. 根据layout_list_info判断是不是列表。,下个layout的第一个段如果不是列表,那么看他们是否有几行都有相同的缩进。
  316. """
  317. if len(blocks_group) == 0 or len(blocks_group) == 0: # 0的时候最后的return 会出错
  318. return blocks_group, [False, False]
  319. for i in range(1, len(blocks_group)):
  320. if len(blocks_group[i]) == 0 or len(blocks_group[i-1]) == 0:
  321. continue
  322. pre_layout_list_info = layout_list_info[i - 1]
  323. next_layout_list_info = layout_list_info[i]
  324. pre_last_para = blocks_group[i - 1][-1].get("lines", [])
  325. next_paras = blocks_group[i]
  326. next_first_para = next_paras[0]
  327. if pre_layout_list_info[1] and not next_layout_list_info[0] and next_first_para["type"] == BlockType.Text: # 前一个是列表结尾,后一个是非列表开头,此时检测是否有相同的缩进
  328. logger.info(f"连接page {page_num} 内的list")
  329. # 向layout_paras[i] 寻找开头具有相同缩进的连续的行
  330. may_list_lines = []
  331. for j in range(len(next_paras)):
  332. lines = next_paras[j].get("lines", [])
  333. if len(lines) == 1: # 只可能是一行,多行情况再需要分析了
  334. if lines[0]['bbox'][0] > __find_layout_bbox_by_line(lines[0]['bbox'], new_layout_bbox)[0]:
  335. may_list_lines.append(lines[0])
  336. else:
  337. break
  338. else:
  339. break
  340. # 如果这些行的缩进是相等的,那么连到上一个layout的最后一个段落上。
  341. if len(may_list_lines) > 0 and len(set([x['bbox'][0] for x in may_list_lines])) == 1:
  342. pre_last_para.extend(may_list_lines)
  343. blocks_group[i] = blocks_group[i][len(may_list_lines):]
  344. # layout_paras[i] = layout_paras[i][len(may_list_lines):]
  345. return blocks_group, [layout_list_info[0][0], layout_list_info[-1][1]] # 同时还返回了这个页面级别的开头、结尾是不是列表的信息
  346. def __connect_list_inter_page(pre_page_paras, next_page_paras, pre_page_layout_bbox, next_page_layout_bbox,
  347. pre_page_list_info, next_page_list_info, page_num, lang):
  348. """
  349. 如果上个layout的最后一个段落是列表,下一个layout的第一个段落也是列表,那么将他们连接起来。 TODO 因为没有区分列表和段落,所以这个方法暂时不实现。
  350. 根据layout_list_info判断是不是列表。,下个layout的第一个段如果不是列表,那么看他们是否有几行都有相同的缩进。
  351. """
  352. if len(pre_page_paras) == 0 or len(next_page_paras) == 0: # 0的时候最后的return 会出错
  353. return False
  354. if len(pre_page_paras[-1]) == 0 or len(next_page_paras[0]) == 0:
  355. return False
  356. if pre_page_paras[-1][-1]["type"] != BlockType.Text or next_page_paras[0][0]["type"] != BlockType.Text:
  357. return False
  358. if pre_page_list_info[1] and not next_page_list_info[0]: # 前一个是列表结尾,后一个是非列表开头,此时检测是否有相同的缩进
  359. logger.info(f"连接page {page_num} 内的list")
  360. # 向layout_paras[i] 寻找开头具有相同缩进的连续的行
  361. may_list_lines = []
  362. for j in range(len(next_page_paras[0])):
  363. next_page_block_j = next_page_paras[0][j]
  364. if next_page_block_j["type"] != BlockType.Text:
  365. break
  366. lines = next_page_block_j["lines"]
  367. if len(lines) == 1: # 只可能是一行,多行情况再需要分析了
  368. if lines[0]['bbox'][0] > __find_layout_bbox_by_line(lines[0]['bbox'], next_page_layout_bbox)[0]:
  369. may_list_lines.append(lines[0])
  370. else:
  371. break
  372. else:
  373. break
  374. # 如果这些行的缩进是相等的,那么连到上一个layout的最后一个段落上。
  375. if len(may_list_lines) > 0 and len(set([x['bbox'][0] for x in may_list_lines])) == 1:
  376. #pre_page_paras[-1].append(may_list_lines)
  377. # 下一页合并到上一页最后一段,打一个cross_page的标签
  378. for line in may_list_lines:
  379. for span in line["spans"]:
  380. span[CROSS_PAGE] = True
  381. pre_page_paras[-1][-1]["lines"].extend(may_list_lines)
  382. next_page_paras[0] = next_page_paras[0][len(may_list_lines):]
  383. return True
  384. return False
  385. def __find_layout_bbox_by_line(line_bbox, layout_bboxes):
  386. """
  387. 根据line找到所在的layout
  388. """
  389. for layout in layout_bboxes:
  390. if is_in_layout(line_bbox, layout):
  391. return layout
  392. return None
  393. def __connect_para_inter_layoutbox(blocks_group, new_layout_bbox):
  394. """
  395. layout之间进行分段。
  396. 主要是计算前一个layOut的最后一行和后一个layout的第一行是否可以连接。
  397. 连接的条件需要同时满足:
  398. 1. 上一个layout的最后一行沾满整个行。并且没有结尾符号。
  399. 2. 下一行开头不留空白。
  400. """
  401. connected_layout_blocks = []
  402. if len(blocks_group) == 0:
  403. return connected_layout_blocks
  404. #connected_layout_paras.append(layout_paras[0])
  405. connected_layout_blocks.append(blocks_group[0])
  406. for i in range(1, len(blocks_group)):
  407. try:
  408. if len(blocks_group[i]) == 0:
  409. continue
  410. if len(blocks_group[i - 1]) == 0: # TODO 考虑连接问题,
  411. connected_layout_blocks.append(blocks_group[i])
  412. continue
  413. # text类型的段才需要考虑layout间的合并
  414. if blocks_group[i - 1][-1]["type"] != BlockType.Text or blocks_group[i][0]["type"] != BlockType.Text:
  415. connected_layout_blocks.append(blocks_group[i])
  416. continue
  417. pre_last_line = blocks_group[i - 1][-1]["lines"][-1]
  418. next_first_line = blocks_group[i][0]["lines"][0]
  419. except Exception as e:
  420. logger.error(f"page layout {i} has no line")
  421. continue
  422. pre_last_line_text = ''.join([__get_span_text(span) for span in pre_last_line['spans']])
  423. pre_last_line_type = pre_last_line['spans'][-1]['type']
  424. next_first_line_text = ''.join([__get_span_text(span) for span in next_first_line['spans']])
  425. next_first_line_type = next_first_line['spans'][0]['type']
  426. if pre_last_line_type not in [TEXT, INLINE_EQUATION] or next_first_line_type not in [TEXT, INLINE_EQUATION]:
  427. #connected_layout_paras.append(layout_paras[i])
  428. connected_layout_blocks.append(blocks_group[i])
  429. continue
  430. pre_layout = __find_layout_bbox_by_line(pre_last_line['bbox'], new_layout_bbox)
  431. next_layout = __find_layout_bbox_by_line(next_first_line['bbox'], new_layout_bbox)
  432. pre_x2_max = pre_layout[2] if pre_layout else -1
  433. next_x0_min = next_layout[0] if next_layout else -1
  434. pre_last_line_text = pre_last_line_text.strip()
  435. next_first_line_text = next_first_line_text.strip()
  436. if pre_last_line['bbox'][2] == pre_x2_max and pre_last_line_text[-1] not in LINE_STOP_FLAG and \
  437. next_first_line['bbox'][0] == next_x0_min: # 前面一行沾满了整个行,并且没有结尾符号.下一行没有空白开头。
  438. """连接段落条件成立,将前一个layout的段落和后一个layout的段落连接。"""
  439. #connected_layout_paras[-1][-1].extend(layout_paras[i][0])
  440. connected_layout_blocks[-1][-1]["lines"].extend(blocks_group[i][0]["lines"])
  441. #layout_paras[i].pop(0) # 删除后一个layout的第一个段落, 因为他已经被合并到前一个layout的最后一个段落了。
  442. blocks_group[i][0]["lines"] = [] #删除后一个layout第一个段落中的lines,因为他已经被合并到前一个layout的最后一个段落了
  443. blocks_group[i][0][LINES_DELETED] = True
  444. # if len(layout_paras[i]) == 0:
  445. # layout_paras.pop(i)
  446. # else:
  447. # connected_layout_paras.append(layout_paras[i])
  448. connected_layout_blocks.append(blocks_group[i])
  449. else:
  450. """连接段落条件不成立,将前一个layout的段落加入到结果中。"""
  451. #connected_layout_paras.append(layout_paras[i])
  452. connected_layout_blocks.append(blocks_group[i])
  453. return connected_layout_blocks
  454. def __connect_para_inter_page(pre_page_paras, next_page_paras, pre_page_layout_bbox, next_page_layout_bbox, page_num,
  455. lang):
  456. """
  457. 连接起来相邻两个页面的段落——前一个页面最后一个段落和后一个页面的第一个段落。
  458. 是否可以连接的条件:
  459. 1. 前一个页面的最后一个段落最后一行沾满整个行。并且没有结尾符号。
  460. 2. 后一个页面的第一个段落第一行没有空白开头。
  461. """
  462. # 有的页面可能压根没有文字
  463. if len(pre_page_paras) == 0 or len(next_page_paras) == 0 or len(pre_page_paras[0]) == 0 or len(
  464. next_page_paras[0]) == 0: # TODO [[]]为什么出现在pre_page_paras里?
  465. return False
  466. pre_last_block = pre_page_paras[-1][-1]
  467. next_first_block = next_page_paras[0][0]
  468. if pre_last_block["type"] != BlockType.Text or next_first_block["type"] != BlockType.Text:
  469. return False
  470. if len(pre_last_block["lines"]) == 0 or len(next_first_block["lines"]) == 0:
  471. return False
  472. pre_last_para = pre_last_block["lines"]
  473. next_first_para = next_first_block["lines"]
  474. pre_last_line = pre_last_para[-1]
  475. next_first_line = next_first_para[0]
  476. pre_last_line_text = ''.join([__get_span_text(span) for span in pre_last_line['spans']])
  477. pre_last_line_type = pre_last_line['spans'][-1]['type']
  478. next_first_line_text = ''.join([__get_span_text(span) for span in next_first_line['spans']])
  479. next_first_line_type = next_first_line['spans'][0]['type']
  480. if pre_last_line_type not in [TEXT, INLINE_EQUATION] or next_first_line_type not in [TEXT,
  481. INLINE_EQUATION]: # TODO,真的要做好,要考虑跨table, image, 行间的情况
  482. # 不是文本,不连接
  483. return False
  484. pre_x2_max = __find_layout_bbox_by_line(pre_last_line['bbox'], pre_page_layout_bbox)[2]
  485. next_x0_min = __find_layout_bbox_by_line(next_first_line['bbox'], next_page_layout_bbox)[0]
  486. pre_last_line_text = pre_last_line_text.strip()
  487. next_first_line_text = next_first_line_text.strip()
  488. if pre_last_line['bbox'][2] == pre_x2_max and pre_last_line_text[-1] not in LINE_STOP_FLAG and \
  489. next_first_line['bbox'][0] == next_x0_min: # 前面一行沾满了整个行,并且没有结尾符号.下一行没有空白开头。
  490. """连接段落条件成立,将前一个layout的段落和后一个layout的段落连接。"""
  491. # 下一页合并到上一页最后一段,打一个cross_page的标签
  492. for line in next_first_para:
  493. for span in line["spans"]:
  494. span[CROSS_PAGE] = True
  495. pre_last_para.extend(next_first_para)
  496. #next_page_paras[0].pop(0) # 删除后一个页面的第一个段落, 因为他已经被合并到前一个页面的最后一个段落了。
  497. next_page_paras[0][0]["lines"] = []
  498. next_page_paras[0][0][LINES_DELETED] = True
  499. return True
  500. else:
  501. return False
  502. def find_consecutive_true_regions(input_array):
  503. start_index = None # 连续True区域的起始索引
  504. regions = [] # 用于保存所有连续True区域的起始和结束索引
  505. for i in range(len(input_array)):
  506. # 如果我们找到了一个True值,并且当前并没有在连续True区域中
  507. if input_array[i] and start_index is None:
  508. start_index = i # 记录连续True区域的起始索引
  509. # 如果我们找到了一个False值,并且当前在连续True区域中
  510. elif not input_array[i] and start_index is not None:
  511. # 如果连续True区域长度大于1,那么将其添加到结果列表中
  512. if i - start_index > 1:
  513. regions.append((start_index, i - 1))
  514. start_index = None # 重置起始索引
  515. # 如果最后一个元素是True,那么需要将最后一个连续True区域加入到结果列表中
  516. if start_index is not None and len(input_array) - start_index > 1:
  517. regions.append((start_index, len(input_array) - 1))
  518. return regions
  519. def __connect_middle_align_text(page_paras, new_layout_bbox, page_num, lang, debug_mode):
  520. """
  521. 找出来中间对齐的连续单行文本,如果连续行高度相同,那么合并为一个段落。
  522. 一个line居中的条件是:
  523. 1. 水平中心点跨越layout的中心点。
  524. 2. 左右两侧都有空白
  525. """
  526. for layout_i, layout_para in enumerate(page_paras):
  527. layout_box = new_layout_bbox[layout_i]
  528. single_line_paras_tag = []
  529. for i in range(len(layout_para)):
  530. #single_line_paras_tag.append(len(layout_para[i]) == 1 and layout_para[i][0]['spans'][0]['type'] == TEXT)
  531. single_line_paras_tag.append(layout_para[i]['type'] == BlockType.Text and len(layout_para[i]["lines"]) == 1)
  532. """找出来连续的单行文本,如果连续行高度相同,那么合并为一个段落。"""
  533. consecutive_single_line_indices = find_consecutive_true_regions(single_line_paras_tag)
  534. if len(consecutive_single_line_indices) > 0:
  535. #index_offset = 0
  536. """检查这些行是否是高度相同的,居中的"""
  537. for start, end in consecutive_single_line_indices:
  538. #start += index_offset
  539. #end += index_offset
  540. line_hi = np.array([block["lines"][0]['bbox'][3] - block["lines"][0]['bbox'][1] for block in layout_para[start:end + 1]])
  541. first_line_text = ''.join([__get_span_text(span) for span in layout_para[start]["lines"][0]['spans']])
  542. if "Table" in first_line_text or "Figure" in first_line_text:
  543. pass
  544. if debug_mode:
  545. logger.info(line_hi.std())
  546. if line_hi.std() < 2:
  547. """行高度相同,那么判断是否居中"""
  548. all_left_x0 = [block["lines"][0]['bbox'][0] for block in layout_para[start:end + 1]]
  549. all_right_x1 = [block["lines"][0]['bbox'][2] for block in layout_para[start:end + 1]]
  550. layout_center = (layout_box[0] + layout_box[2]) / 2
  551. if all([x0 < layout_center < x1 for x0, x1 in zip(all_left_x0, all_right_x1)]) \
  552. and not all([x0 == layout_box[0] for x0 in all_left_x0]) \
  553. and not all([x1 == layout_box[2] for x1 in all_right_x1]):
  554. merge_para = [block["lines"][0] for block in layout_para[start:end + 1]]
  555. para_text = ''.join([__get_span_text(span) for line in merge_para for span in line['spans']])
  556. if debug_mode:
  557. logger.info(para_text)
  558. layout_para[start]["lines"] = merge_para
  559. for i_para in range(start+1, end+1):
  560. layout_para[i_para]["lines"] = []
  561. layout_para[i_para][LINES_DELETED] = True
  562. #layout_para[start:end + 1] = [merge_para]
  563. #index_offset -= end - start
  564. return
  565. def __merge_signle_list_text(page_paras, new_layout_bbox, page_num, lang):
  566. """
  567. 找出来连续的单行文本,如果首行顶格,接下来的几个单行段落缩进对齐,那么合并为一个段落。
  568. """
  569. pass
  570. def __do_split_page(blocks, layout_bboxes, new_layout_bbox, page_num, lang):
  571. """
  572. 根据line和layout情况进行分段
  573. 先实现一个根据行末尾特征分段的简单方法。
  574. """
  575. """
  576. 算法思路:
  577. 1. 扫描layout里每一行,找出来行尾距离layout有边界有一定距离的行。
  578. 2. 从上述行中找到末尾是句号等可作为断行标志的行。
  579. 3. 参照上述行尾特征进行分段。
  580. 4. 图、表,目前独占一行,不考虑分段。
  581. """
  582. blocks_group = __group_line_by_layout(blocks, layout_bboxes) # block内分段
  583. layout_list_info = __split_para_in_layoutbox(blocks_group, new_layout_bbox, lang) # layout内分段
  584. blocks_group, page_list_info = __connect_list_inter_layout(blocks_group, new_layout_bbox, layout_list_info,
  585. page_num, lang) # layout之间连接列表段落
  586. connected_layout_blocks = __connect_para_inter_layoutbox(blocks_group, new_layout_bbox) # layout间链接段落
  587. return connected_layout_blocks, page_list_info
  588. def para_split(pdf_info_dict, debug_mode, lang="en"):
  589. new_layout_of_pages = [] # 数组的数组,每个元素是一个页面的layoutS
  590. all_page_list_info = [] # 保存每个页面开头和结尾是否是列表
  591. for page_num, page in pdf_info_dict.items():
  592. blocks = page['preproc_blocks']
  593. layout_bboxes = page['layout_bboxes']
  594. new_layout_bbox = __common_pre_proc(blocks, layout_bboxes)
  595. new_layout_of_pages.append(new_layout_bbox)
  596. splited_blocks, page_list_info = __do_split_page(blocks, layout_bboxes, new_layout_bbox, page_num, lang)
  597. all_page_list_info.append(page_list_info)
  598. page['para_blocks'] = splited_blocks
  599. """连接页面与页面之间的可能合并的段落"""
  600. pdf_infos = list(pdf_info_dict.values())
  601. for page_num, page in enumerate(pdf_info_dict.values()):
  602. if page_num == 0:
  603. continue
  604. pre_page_paras = pdf_infos[page_num - 1]['para_blocks']
  605. next_page_paras = pdf_infos[page_num]['para_blocks']
  606. pre_page_layout_bbox = new_layout_of_pages[page_num - 1]
  607. next_page_layout_bbox = new_layout_of_pages[page_num]
  608. is_conn = __connect_para_inter_page(pre_page_paras, next_page_paras, pre_page_layout_bbox,
  609. next_page_layout_bbox, page_num, lang)
  610. if debug_mode:
  611. if is_conn:
  612. logger.info(f"连接了第{page_num - 1}页和第{page_num}页的段落")
  613. is_list_conn = __connect_list_inter_page(pre_page_paras, next_page_paras, pre_page_layout_bbox,
  614. next_page_layout_bbox, all_page_list_info[page_num - 1],
  615. all_page_list_info[page_num], page_num, lang)
  616. if debug_mode:
  617. if is_list_conn:
  618. logger.info(f"连接了第{page_num - 1}页和第{page_num}页的列表段落")
  619. """接下来可能会漏掉一些特别的一些可以合并的内容,对他们进行段落连接
  620. 1. 正文中有时出现一个行顶格,接下来几行缩进的情况。
  621. 2. 居中的一些连续单行,如果高度相同,那么可能是一个段落。
  622. """
  623. for page_num, page in enumerate(pdf_info_dict.values()):
  624. page_paras = page['para_blocks']
  625. new_layout_bbox = new_layout_of_pages[page_num]
  626. __connect_middle_align_text(page_paras, new_layout_bbox, page_num, lang, debug_mode=debug_mode)
  627. __merge_signle_list_text(page_paras, new_layout_bbox, page_num, lang)
  628. # layout展平
  629. for page_num, page in enumerate(pdf_info_dict.values()):
  630. page_paras = page['para_blocks']
  631. page_blocks = [block for layout in page_paras for block in layout]
  632. page["para_blocks"] = page_blocks