mirror of
https://github.com/opendatalab/MinerU.git
synced 2026-03-27 11:08:32 +07:00
674 lines
31 KiB
Python
674 lines
31 KiB
Python
import io
|
||
import re
|
||
import os
|
||
import json
|
||
from libs.boxbase import _is_in_or_part_overlap, calculate_overlap_area_2_minbox_area_ratio
|
||
from libs.commons import fitz
|
||
from fitz import Point
|
||
from pprint import pprint
|
||
import pickle
|
||
import collections
|
||
from typing import List
|
||
|
||
|
||
def calculate_overlapRatio_between_rect1_and_rect2(L1: float, U1: float, R1: float, D1: float, L2: float, U2: float, R2: float, D2: float) -> (float, float):
|
||
# 计算两个rect，重叠面积各占2个rect面积的比例
|
||
if min(R1, R2) < max(L1, L2) or min(D1, D2) < max(U1, U2):
|
||
return 0, 0
|
||
square_1 = (R1 - L1) * (D1 - U1)
|
||
square_2 = (R2 - L2) * (D2 - U2)
|
||
if square_1 == 0 or square_2 == 0:
|
||
return 0, 0
|
||
square_overlap = (min(R1, R2) - max(L1, L2)) * (min(D1, D2) - max(U1, U2))
|
||
return square_overlap / square_1, square_overlap / square_2
|
||
|
||
def calculate_overlapRatio_between_line1_and_line2(L1: float, R1: float, L2: float, R2: float) -> (float, float):
|
||
# 计算两个line，重叠区间各占2个line长度的比例
|
||
if max(L1, L2) > min(R1, R2):
|
||
return 0, 0
|
||
if L1 == R1 or L2 == R2:
|
||
return 0, 0
|
||
overlap_line = min(R1, R2) - max(L1, L2)
|
||
return overlap_line / (R1 - L1), overlap_line / (R2 - L2)
|
||
|
||
|
||
def parse_footnoteLine(page_ID: int, page: fitz.Page, json_from_DocXchain_obj, exclude_bboxes):
|
||
"""
|
||
:param page_ID: int类型，当前page在当前pdf文档中是第page_D页。
|
||
:param page :fitz读取的当前页的内容
|
||
:param res_dir_path: str类型，是每一个pdf文档，在当前.py文件的目录下生成一个与pdf文档同名的文件夹，res_dir_path就是文件夹的dir
|
||
:param json_from_DocXchain_obj: dict类型，把pdf文档送入DocXChain模型中后，提取bbox，结果保存到pdf文档同名文件夹下的 page_ID.json文件中了。json_from_DocXchain_obj就是打开后的dict
|
||
"""
|
||
DPI = 72 # use this resolution
|
||
pix = page.get_pixmap(dpi=DPI)
|
||
pageL = 0
|
||
pageR = int(pix.w)
|
||
pageU = 0
|
||
pageD = int(pix.h)
|
||
|
||
#---------------------- PyMuPDF解析text --------------------#
|
||
textSize_freq = collections.defaultdict(float) # text块中，textSize的频率
|
||
textBlock_bboxs = []
|
||
textLine_bboxs = []
|
||
text_blocks = page.get_text(
|
||
"dict",
|
||
flags=fitz.TEXTFLAGS_TEXT,
|
||
#clip=clip,
|
||
)["blocks"]
|
||
totText_list = []
|
||
for i in range(len(text_blocks)):
|
||
# print(blocks[i]) #### print
|
||
bbox = text_blocks[i]['bbox']
|
||
textBlock_bboxs.append(bbox)
|
||
# print(bbox)
|
||
cur_block_text_list = []
|
||
for tt in text_blocks[i]['lines']:
|
||
# 当前line
|
||
cur_line_text_list = []
|
||
cur_line_bbox = None # 当前line，最右侧的section的bbox
|
||
for xf in tt['spans']:
|
||
L, U, R, D = xf['bbox']
|
||
L, R = min(L, R), max(L, R)
|
||
U, D = min(U, D), max(U, D)
|
||
textLine_bboxs.append((L, U, R, D))
|
||
cur_line_text_list.append(xf['text'])
|
||
textSize_freq[xf['size']] += len(xf['text'])
|
||
cur_lines_text = ' '.join(cur_line_text_list)
|
||
cur_block_text_list.append(cur_lines_text)
|
||
totText_list.append('\n'.join(cur_block_text_list))
|
||
totText = '\n'.join(totText_list)
|
||
# print(totText) # 打印Text
|
||
|
||
textLine_bboxs.sort(key = lambda LURD: (LURD[0], LURD[1]))
|
||
textBlock_bboxs.sort(key = lambda LURD: (LURD[0], LURD[1]))
|
||
|
||
# print('------------ textSize_freq -----------')
|
||
max_sizeFreq = 0 # 出现频率最高的textSize
|
||
textSize_withMaxFreq = 0
|
||
for x, f in textSize_freq.items():
|
||
# print(x, f)
|
||
if f > max_sizeFreq:
|
||
max_sizeFreq = f
|
||
textSize_withMaxFreq = x
|
||
#**********************************************************#
|
||
|
||
#------------------ PyMuPDF读取drawings -----------------#
|
||
horizon_lines = []
|
||
drawings = page.get_cdrawings()
|
||
for drawing in drawings:
|
||
try:
|
||
rect = drawing['rect']
|
||
L, U, R, D = rect
|
||
# if (L, U, R, D) in exclude_bboxes:
|
||
# continue # 如果是Fiugre, Table, Equation。注释掉是因为，可以暂时先不消，先自我对消。最后再判读需不需要排除。
|
||
# 如果是水平线
|
||
if U <= D and D - U <= 3:
|
||
# 如果长度够
|
||
if (pageR - pageL) / 15 <= R - L:
|
||
if not(80/800 * pageD <= U <= 750/800 * pageD):
|
||
continue # 很可能是页眉和页脚的线
|
||
horizon_lines.append((L, U, R, D))
|
||
# print((L, U, R, D))
|
||
except:
|
||
pass
|
||
horizon_lines.sort(key = lambda LURD: (LURD[1]))
|
||
#********************************************************#
|
||
|
||
#----------------- 两条线可能是在表格中 ------------------#
|
||
def has_text_below_line(L: float, U: float, R: float, D: float, inLowerArea: bool) -> bool:
|
||
"""
|
||
检查线下是否紧挨着text
|
||
"""
|
||
Uu, Du = U - textSize_withMaxFreq, U # 线上的一个矩形
|
||
Lu, Ru = L, R
|
||
Ud, Dd = U, U + textSize_withMaxFreq # 线下的一个矩形
|
||
Ld, Rd = L, R
|
||
find = 0 # 在线下的文字。统计面积。
|
||
leftTextCnt = 0 # 不在线底下的文字（整体在线左侧的文字），说明不是个脚注线。统计面积。
|
||
English_alpha_cnt = 0 # 英文字母个数
|
||
nonEnglish_alpha_cnt = 0 # 非英文字母个数
|
||
punctuation_mark_cnt = 0 # 常见标点符号个数
|
||
digit_cnt = 0 # 数字个数
|
||
|
||
distance_nearest_up_line = None
|
||
distance_nearest_down_line = None
|
||
|
||
for i in range(len(text_blocks)):
|
||
# print(blocks[i]) #### print
|
||
bbox = text_blocks[i]['bbox']
|
||
L0, U0, R0, D0 = bbox
|
||
if 0< (R0 - L0) < pageR / 6 and (D0 - U0) / (R0 - L0) > 10 :
|
||
continue # 一个很窄的，竖直的长条。比如，arXiv预印本，左侧的arXiv标志信息。
|
||
textBlock_bboxs.append(bbox)
|
||
# print(bbox)
|
||
cur_block_text_list = []
|
||
for tt in text_blocks[i]['lines']:
|
||
# 当前line
|
||
cur_line_text_list = []
|
||
cur_line_bbox = None # 当前line，最右侧的section的bbox
|
||
for xf in tt['spans']:
|
||
L2, U2, R2, D2 = xf['bbox']
|
||
L2, R2 = min(L2, R2), max(L2, R2)
|
||
U2, D2 = min(U2, D2), max(U2, D2)
|
||
textLine = xf['text']
|
||
if L>0 and L2 < L and (L - L2) / L > 0.2:
|
||
leftTextCnt += abs(R2 - L2) * abs(D2 - U2)
|
||
else:
|
||
## 线下的部分
|
||
ratio_1, ratio_2 = calculate_overlapRatio_between_line1_and_line2(Ud, Dd, U2, D2)
|
||
ratio_3, ratio_4 = calculate_overlapRatio_between_line1_and_line2(Ld, Rd, L2, R2)
|
||
if U < (U2 + D2) / 2 and ratio_1 > 0 and ratio_2 > 0:
|
||
if max(ratio_3, ratio_4) > 0.8:
|
||
# if 444 <= U1 < 445 and 55 <= L2 < 56:
|
||
# print('匹配的框', L2, U2, R2, D2)
|
||
# if xf['size'] > 1.2 * textSize_withMaxFreq:
|
||
# return False # 可能是个标题。不能这样卡
|
||
find += abs(R2 - L2) * abs(D2 - U2)
|
||
distance_nearest_down_line = (U2 + D2) / 2 - U
|
||
for c in textLine:
|
||
if c == ' ':
|
||
continue
|
||
elif c.isdigit() == True:
|
||
digit_cnt += 1
|
||
elif c in ',.:!?[]()%，。、！？：【】（）《》-':
|
||
punctuation_mark_cnt += 1
|
||
elif c.isalpha() == True:
|
||
English_alpha_cnt += 1
|
||
else:
|
||
nonEnglish_alpha_cnt += 1
|
||
## 线上的部分
|
||
ratio_5, ratio_6 = calculate_overlapRatio_between_line1_and_line2(Uu, Du, U2, D2)
|
||
ratio_7, ratio_8 = calculate_overlapRatio_between_line1_and_line2(Lu, Ru, L2, R2)
|
||
if (U2 + D2) / 2 < U and ratio_5 > 0 and ratio_6 > 0:
|
||
if max(ratio_7, ratio_8) > 0.8:
|
||
distance_nearest_up_line = U - (U2 + D2) / 2
|
||
# if distance_nearest_up_line < 0:
|
||
# print(Lu, Uu, Ru, Du, L2, U2, R2, D2)
|
||
# print(distance_nearest_up_line, distance_nearest_down_line)
|
||
if distance_nearest_up_line != None and distance_nearest_down_line != None:
|
||
if distance_nearest_up_line * 1.5 < distance_nearest_down_line:
|
||
return False # 如果，一根线。距离上面的文字line更近。说明是个下划线，而不是footnoteLine
|
||
|
||
## 在上面的线条，要考虑左侧的text块儿。在很靠下的线条，就暂时不考虑左侧text块儿了。
|
||
if inLowerArea == False:
|
||
if leftTextCnt >= 2000/500000 * pageR * pageD:
|
||
return False
|
||
return find >= 0 and (English_alpha_cnt + nonEnglish_alpha_cnt + digit_cnt) >= 10
|
||
## 最下面区域的线条，判断时。
|
||
# print(English_alpha_cnt, nonEnglish_alpha_cnt, digit_cnt)
|
||
if (English_alpha_cnt + nonEnglish_alpha_cnt + digit_cnt) == 0:
|
||
return False
|
||
if (English_alpha_cnt + digit_cnt) / (English_alpha_cnt + nonEnglish_alpha_cnt + digit_cnt) > 0.5:
|
||
if nonEnglish_alpha_cnt / (English_alpha_cnt + nonEnglish_alpha_cnt + digit_cnt) > 0.4:
|
||
return False
|
||
else:
|
||
return True
|
||
return True
|
||
|
||
|
||
visited = [False for _ in range(len(horizon_lines))]
|
||
for i, b1 in enumerate(horizon_lines):
|
||
for j in range(i + 1, len(horizon_lines)):
|
||
L1, U1, R1, D1 = horizon_lines[i]
|
||
L2, U2, R2, D2 = horizon_lines[j]
|
||
|
||
## 在一条水平线，且挨着
|
||
if L1 > L2:
|
||
L1, U1, R1, D1, L2, U2, R2, D2 = L2, U2, R2, D2, L1, U1, R1, D1
|
||
in_horizontal_line_flag = (max(U1, D1, U2, D2) - min(U1, D1, U2, D2) <= 5) and (L2 - R1 <= pageR/10)
|
||
if in_horizontal_line_flag == True:
|
||
visited[i] = True
|
||
visited[j] = True
|
||
|
||
## 在竖直方向上是一致的。(表格，或者有的文章就是喜欢划线）
|
||
L1, U1, R1, D1 = horizon_lines[i]
|
||
L2, U2, R2, D2 = horizon_lines[j]
|
||
ratio_1, ratio_2 = calculate_overlapRatio_between_line1_and_line2(L1, R1, L2, R2)
|
||
# print(L1, U1, R1, D1, L2, U2, R2, D2, ratio_1, ratio_2)
|
||
in_vertical_line_flag = (ratio_1 > 0.9 and ratio_2 > 0.9) or (max(ratio_1, ratio_2) > 0.95)
|
||
if in_vertical_line_flag == True:
|
||
visited[i] = True
|
||
# if (U2 < pageD * 0.8 or (U2 - U1) < pageD * 0.3) and has_text_below_line(L2, U2, R2, D2, False) == False:
|
||
# visited[j] = True # 最最底下的线先不要动
|
||
else:
|
||
if ratio_1 > 0 and (R2 - L2) / (R1 - L1) > 1:
|
||
visited[i] = True
|
||
# print(horizon_lines)
|
||
horizon_lines = [horizon_lines[i] for i in range(len(horizon_lines)) if visited[i] == False]
|
||
# print(horizon_lines)
|
||
#*****************************************************************#
|
||
|
||
#------- 靠上的，就不是脚注。用一个THRESHOLD直接卡掉位于上半页的 -------#
|
||
visited = [False for _ in range(len(horizon_lines))]
|
||
THRESHOLD = (pageD - pageU) * 0.5
|
||
for i, (L, U, R, D) in enumerate(horizon_lines):
|
||
if U < THRESHOLD:
|
||
visited[i] = True
|
||
horizon_lines = [horizon_lines[i] for i in range(len(horizon_lines)) if visited[i] == False]
|
||
#******************************************************#
|
||
|
||
#--------------- 此时，还有遮挡的，上面的丢弃 ---------------#
|
||
visited = [False for _ in range(len(horizon_lines))]
|
||
for i, (L1, U1, R1, D1) in enumerate(horizon_lines):
|
||
for j in range(i + 1, len(horizon_lines)):
|
||
L2, U2, R2, D2 = horizon_lines[j]
|
||
ratio_1, ratio_2 = calculate_overlapRatio_between_line1_and_line2(L1, R1, L2, R2)
|
||
if (ratio_1 > 0.2 and ratio_2 > 0.2) or max(ratio_1, ratio_2) > 0.7:
|
||
visited[i] = True
|
||
horizon_lines = [horizon_lines[i] for i in range(len(horizon_lines)) if visited[i] == False]
|
||
#********************************************************#
|
||
# print(horizon_lines)
|
||
## 检查，线下面有没有紧挨着的text
|
||
horizon_lines = [LURD for LURD in horizon_lines if has_text_below_line(*(LURD), True) == True]
|
||
# print(horizon_lines)
|
||
## 卡一下长度
|
||
# horizon_lines = [LURD for LURD in horizon_lines if (LURD[2] - LURD[0] >= pageR / 10)]
|
||
|
||
## 上面最多保留2条
|
||
horizon_lines = horizon_lines[max(-2, -len(horizon_lines)) :]
|
||
|
||
|
||
#----------------------------------------------------- 第2段 -----------------------------------------------------------#
|
||
#----------------------------------- 最下面的情形，用距离硬卡。还有在右侧的情形就被包含了 -----------------------------------#
|
||
#------------------ PyMuPDF读取drawings -----------------#
|
||
down_horizon_lines = []
|
||
|
||
drawings = page.get_cdrawings()
|
||
for drawing in drawings:
|
||
try:
|
||
rect = drawing['rect']
|
||
L, U, R, D = rect
|
||
# if (L, U, R, D) in exclude_bboxes:
|
||
# continue # 如果是Fiugre, Table, Equation。目前是Figure识别的比较好。但是Table和Equation识别的不好
|
||
# 如果是水平线
|
||
if U <= D and D - U <= 3 and U > pageD * 0.85:
|
||
# 如果长度够
|
||
if (pageR - pageL) / 15 <= R - L:
|
||
down_horizon_lines.append((L, U, R, D))
|
||
# print((L, U, R, D))
|
||
except:
|
||
pass
|
||
|
||
down_horizon_lines.sort(key = lambda LURD: (LURD[0], LURD[2], LURD[1]))
|
||
visited = [False for _ in range(len(down_horizon_lines))]
|
||
for i in range(len(down_horizon_lines) - 1):
|
||
L1, U1, R1, D1 = down_horizon_lines[i]
|
||
L2, U2, R2, D2 = down_horizon_lines[i + 1]
|
||
ratio_1, ratio_2 = calculate_overlapRatio_between_line1_and_line2(L1, R1, L2, R2)
|
||
if ratio_1 <= 0.1 and ratio_2 <= 0.1:
|
||
if L2 - R1 <= pageR / 3:
|
||
visited[i] = True
|
||
visited[i + 1] = True
|
||
down_horizon_lines = [down_horizon_lines[i] for i in range(len(down_horizon_lines)) if visited[i] == False]
|
||
|
||
down_horizon_lines = [LURD for LURD in down_horizon_lines if has_text_below_line(*(LURD), True) == True]
|
||
# for LURD in down_horizon_lines:
|
||
# print('第2阶段，LURD是： ', LURD)
|
||
# print(has_text_below_line(*(LURD), True))
|
||
|
||
footnoteLines = horizon_lines + down_horizon_lines
|
||
footnoteLines = list(set(footnoteLines))
|
||
footnoteLines = footnoteLines[max(-2, -len(footnoteLines)) : ]
|
||
|
||
#-------------------------- 最后再检查一遍。是否在图片、表格、公式中。 ------------------------------#
|
||
def line_in_specialBboxes(L: float, U: float, R: float, D: float, specialBboxes) -> bool:
|
||
L2, U2, R2, D2 = L, U, R, D # 当前这根线
|
||
for L1, U1, R1, D1 in specialBboxes:
|
||
if U1 <= U2 <= D2 < D1:
|
||
ratio_1, ratio_2 = calculate_overlapRatio_between_line1_and_line2(L1, R1, L2, R2)
|
||
if ratio_1 > 0 and ratio_2 > 0.6:
|
||
return True
|
||
# else:
|
||
# U1 -= min(textSize_withMaxFreq * 2, 20)
|
||
# D1 += min(textSize_withMaxFreq * 2, 20)
|
||
# if U1 <= U2 <= D2 < D1:
|
||
# ratio_1, ratio_2 = calculate_overlapRatio_between_line1_and_line2(L1, R1, L2, R2)
|
||
# if ratio_1 > 0 and ratio_2 > 0.8:
|
||
# return True
|
||
return False
|
||
|
||
footnoteLines = [LURD for LURD in footnoteLines if line_in_specialBboxes(*(LURD), exclude_bboxes) == False]
|
||
|
||
#-------------------------- 检查，线，是否在当前column的左侧，而不是在一段文字的中间 （通过DocXChain识别的column或者徐超老师写的Layout识别）------------------------------#
|
||
# #--------- 通过json_from_DocXchain来获取 column ---------#
|
||
# column_bbox_from_DocXChain = []
|
||
|
||
# xf_json = json_from_DocXchain_obj
|
||
# width_from_json = xf_json['page_info']['width']
|
||
# height_from_json = xf_json['page_info']['height']
|
||
# LR_scaleRatio = width_from_json / (pageR - pageL)
|
||
# UD_scaleRatio = height_from_json / (pageD - pageU)
|
||
|
||
# # {0: 'title', # 标题
|
||
# # 1: 'figure', # 图片
|
||
# # 2: 'plain text', # 文本
|
||
# # 3: 'header', # 页眉
|
||
# # 4: 'page number', # 页码
|
||
# # 5: 'footnote', # 脚注
|
||
# # 6: 'footer', # 页脚
|
||
# # 7: 'table', # 表格
|
||
# # 8: 'table caption', # 表格描述
|
||
# # 9: 'figure caption', # 图片描述
|
||
# # 10: 'equation', # 公式
|
||
# # 11: 'full column', # 单栏
|
||
# # 12: 'sub column', # 多栏
|
||
# # 13: 'embedding', # 嵌入公式
|
||
# # 14: 'isolated'} # 单行公式
|
||
# for xf in xf_json['layout_dets']:
|
||
# L = xf['poly'][0] / LR_scaleRatio
|
||
# U = xf['poly'][1] / UD_scaleRatio
|
||
# R = xf['poly'][2] / LR_scaleRatio
|
||
# D = xf['poly'][5] / UD_scaleRatio
|
||
# # L += pageL # 有的页面，artBox偏移了。不在（0,0）
|
||
# # R += pageL
|
||
# # U += pageU
|
||
# # D += pageU
|
||
# L, R = min(L, R), max(L, R)
|
||
# U, D = min(U, D), max(U, D)
|
||
# if (xf['category_id'] == 11 or xf['category_id'] == 12) and xf['score'] >= 0.3:
|
||
# column_bbox_from_DocXChain.append((L, U, R, D))
|
||
|
||
#---------------手写，检查，线是否是与某个column的左端对齐 ------------------#
|
||
def check_isOnTheLeftOfColumn(L: float, U: float, R: float, D: float) -> bool:
|
||
LL = L - textSize_withMaxFreq
|
||
RR = LL
|
||
UU = max(pageD * 0.02, U - 100/800 * pageD)
|
||
DD = min(U + 50/800 * pageD, pageD * 0.98)
|
||
|
||
# print(LL, UU, RR, DD)
|
||
cnt = 0
|
||
for bbox in textLine_bboxs:
|
||
L2, U2, R2, D2 = bbox
|
||
ratio_1, ratio_2 = calculate_overlapRatio_between_line1_and_line2(UU, DD, U2, D2)
|
||
ratio_3, ratio_4 = calculate_overlapRatio_between_line1_and_line2(L, R, L2, R2)
|
||
if ratio_1 > 0 and ratio_2 > 0:
|
||
if max(ratio_3, ratio_4) > 0.8:
|
||
if abs(LL - L2) <= 20/700 * pageR:
|
||
cnt += 1
|
||
# else:
|
||
# if (R2 - L2) >= 30/700 * pageR:
|
||
# print(LL, UU, RR, DD, L2, U2, R2, D2)
|
||
# return False # 不能这样卡。有些注释里面，单独的特殊符号就是一个textLineBbox
|
||
# print('cnt: ', cnt)
|
||
return cnt >= 4
|
||
|
||
# def check_isOnTheLeftOfColumn_considerLayout(L0: float, U0: float, R0: float, D0: float) -> bool:
|
||
# LL = L0 - textSize_withMaxFreq * 1.5
|
||
# RR = LL
|
||
# UU = 100/800 * pageD
|
||
# DD = 700/800 * pageD
|
||
|
||
# STEP = textSize_withMaxFreq / 2
|
||
|
||
# def check_ok(L: float, U: float, R: float, D: float) -> bool:
|
||
# for bbox in textBlock_bboxs:
|
||
# L2, U2, R2, D2 = bbox
|
||
# ratio_3, ratio_4 = calculate_overlapRatio_between_line1_and_line2(L, R, L2, R2)
|
||
# if max(ratio_3, ratio_4) > 0.8:
|
||
# if (R2 - L2) > 1/4 * pageR and L2 < LL <= RR < R2:
|
||
# if abs(LL - L2) < 50/700 * pageR or abs(RR - R2) < 50/700 * pageR:
|
||
# continue
|
||
# else:
|
||
# return False
|
||
# return True
|
||
|
||
# ## 先探上面
|
||
# u = UU
|
||
# d = U0
|
||
# while u + STEP/2 < d:
|
||
# mid = (u + d) / 2
|
||
# if check_ok(L0, mid, R0, U0) == True:
|
||
# d = mid
|
||
# else:
|
||
# u = mid + STEP
|
||
# print(mid)
|
||
# dist_up = U0 - u
|
||
# print(u)
|
||
# ## 再探下面
|
||
# u = D0
|
||
# d = DD
|
||
# while u + STEP/2 < d:
|
||
# mid = (u + d) / 2
|
||
# if check_ok(L0, mid, R0, D0) == True:
|
||
# u = mid
|
||
# else:
|
||
# d = mid - STEP
|
||
# print(u)
|
||
# print('^^^^^^^^^^^^^^')
|
||
# dist_down = u - D0
|
||
|
||
# if dist_up + dist_down < textSize_withMaxFreq * 10:
|
||
# return False
|
||
# return True
|
||
|
||
|
||
footnoteLines = [LURD for LURD in footnoteLines if check_isOnTheLeftOfColumn(*(LURD)) == True]
|
||
# footnoteLines = [LURD for LURD in footnoteLines if check_isOnTheLeftOfColumn_considerLayout(*(LURD)) == True] # 不具有泛化性。不用了。
|
||
|
||
#--------------------------------- 通过footnoteLine获取bbox -------------------------------#
|
||
def get_footnoteBbox(L: float, U: float, R: float, D: float) -> (float, float, float, float):
|
||
"""
|
||
检查线下是否紧挨着text
|
||
"""
|
||
L1, U1, R1, D1 = L, U, R, D
|
||
raw_bboxes = []
|
||
for i in range(len(text_blocks)):
|
||
bbox = text_blocks[i]['bbox']
|
||
L2, U2, R2, D2 = bbox
|
||
if (D2 - U2) / (R2 - L2) > 10 and (R2 - L2) < pageR / 6:
|
||
continue # 一个很窄的，竖直的长条。比如，arXiv预印本，左侧的arXiv标志信息。
|
||
if U2 < D2 < U1:
|
||
continue # 在线上面
|
||
under_THRESHOLD = min(D1 + textSize_withMaxFreq * 20, pageD * 0.98)
|
||
if U2 < under_THRESHOLD:
|
||
ratio_1, ratio_2 = calculate_overlapRatio_between_line1_and_line2(L1, R1, L2, R2)
|
||
if max(ratio_1, ratio_2) > 0.8:
|
||
raw_bboxes.append((L2, U2, R2, D2))
|
||
# print(L1, U1, R1, D1)
|
||
# print(raw_bboxes)
|
||
if len(raw_bboxes) == 0:
|
||
return []
|
||
|
||
raw_bboxes.sort(key = lambda LURD: (LURD[1], LURD[0]))
|
||
raw_bboxes = [LURD for LURD in raw_bboxes if (abs(LURD[0] - L1) < textSize_withMaxFreq * 6 or L1 < LURD[0])] # footnote的bbox，应该都是左端对齐的
|
||
if len(raw_bboxes) == 0:
|
||
return []
|
||
#------------------ full column和sub column混合，肯定也不行 ------------------#
|
||
LL, UU, RR, DD = raw_bboxes[0]
|
||
for L, U, R, D in raw_bboxes:
|
||
LL, UU, RR, DD = min(LL, L), min(UU, U), max(RR, R), max(DD, D)
|
||
for L, U, R, D in raw_bboxes:
|
||
if (RR - LL) > pageR*0.8 and (R - L) > pageR * 0.15 and (RR - LL) / (R - L) > 2:
|
||
return []
|
||
if abs(LL - L) > textSize_withMaxFreq * 3:
|
||
return []
|
||
|
||
#-------------------- 太高了的，full column的框。不行 ----------------------#
|
||
if UU < 650/800 * pageD and (RR - LL) > 0.5 * pageR:
|
||
return []
|
||
|
||
#-------------- 第一段字数很少。后面的段字数很多，也不行 ----------------#
|
||
if len(raw_bboxes) > 1:
|
||
bbox_square = []
|
||
for L, U, R, D in raw_bboxes:
|
||
cur_s = abs(R - L) * abs(D - U)
|
||
bbox_square.append(cur_s)
|
||
|
||
s0 = bbox_square[0]
|
||
s1n = sum(bbox_square[1: ]) / len(bbox_square[1: ])
|
||
if s1n / s0 > 10 or max(bbox_square) / s0 > 15:
|
||
return []
|
||
|
||
raw_bboxes += [(LL, UU, RR, DD)]
|
||
return raw_bboxes
|
||
|
||
# print(footnoteLines)
|
||
footnoteBboxes = []
|
||
for L, U, R, D in footnoteLines:
|
||
cur = get_footnoteBbox(L, U, R, D)
|
||
if len(cur) > 0:
|
||
footnoteBboxes.append((L, U, R, D))
|
||
footnoteBboxes += cur
|
||
|
||
footnoteBboxes = list(set(footnoteBboxes))
|
||
return footnoteBboxes
|
||
|
||
|
||
def __bbox_in(box1, box2):
|
||
"""
|
||
box1是否在box2中
|
||
"""
|
||
L1, U1, R1, D1 = box1
|
||
L2, U2, R2, D2 = box2
|
||
if int(L2) <= int(L1) and int(U2) <= int(U1) and int(R1) <= int(R2) and int(D1) <= int(D2):
|
||
return True
|
||
return False
|
||
|
||
def remove_footnote_text(raw_text_block, footnote_bboxes):
|
||
"""
|
||
:param raw_text_block: str类型，是当前页的文本内容
|
||
:param footnoteBboxes: list类型，是当前页的脚注bbox
|
||
"""
|
||
footnote_text_blocks = []
|
||
for block in raw_text_block:
|
||
text_bbox = block['bbox']
|
||
# TODO 更严谨点在line级别做
|
||
if any([_is_in_or_part_overlap(text_bbox, footnote_bbox) for footnote_bbox in footnote_bboxes]):
|
||
#if any([text_bbox[3]>=footnote_bbox[1] for footnote_bbox in footnote_bboxes]):
|
||
block['tag'] = 'footnote'
|
||
footnote_text_blocks.append(block)
|
||
#raw_text_block.remove(block)
|
||
|
||
# 移除，不能再内部移除，否则会出错
|
||
for block in footnote_text_blocks:
|
||
raw_text_block.remove(block)
|
||
|
||
return raw_text_block, footnote_text_blocks
|
||
|
||
def remove_footnote_image(image_blocks, footnote_bboxes):
|
||
"""
|
||
:param image_bboxes: list类型，是当前页的图片bbox(结构体)
|
||
:param footnoteBboxes: list类型，是当前页的脚注bbox
|
||
"""
|
||
footnote_imgs_blocks = []
|
||
for image_block in image_blocks:
|
||
if any([__bbox_in(image_block['bbox'], footnote_bbox) for footnote_bbox in footnote_bboxes]):
|
||
footnote_imgs_blocks.append(image_block)
|
||
|
||
for footnote_imgs_block in footnote_imgs_blocks:
|
||
image_blocks.remove(footnote_imgs_block)
|
||
|
||
return image_blocks, footnote_imgs_blocks
|
||
|
||
|
||
def remove_headder_footer_one_page(text_raw_blocks, image_bboxes, table_bboxes, header_bboxs, footer_bboxs, page_no_bboxs, page_w, page_h):
|
||
"""
|
||
删除页眉页脚，页码
|
||
从line级别进行删除，删除之后观察这个text-block是否是空的，如果是空的，则移动到remove_list中
|
||
"""
|
||
header = []
|
||
footer = []
|
||
if len(header)==0:
|
||
model_header = header_bboxs
|
||
if model_header:
|
||
x0 = min([x for x,_,_,_ in model_header])
|
||
y0 = min([y for _,y,_,_ in model_header])
|
||
x1 = max([x1 for _,_,x1,_ in model_header])
|
||
y1 = max([y1 for _,_,_,y1 in model_header])
|
||
header = [x0, y0, x1, y1]
|
||
if len(footer)==0:
|
||
model_footer = footer_bboxs
|
||
if model_footer:
|
||
x0 = min([x for x,_,_,_ in model_footer])
|
||
y0 = min([y for _,y,_,_ in model_footer])
|
||
x1 = max([x1 for _,_,x1,_ in model_footer])
|
||
y1 = max([y1 for _,_,_,y1 in model_footer])
|
||
footer = [x0, y0, x1, y1]
|
||
|
||
|
||
header_y0 = 0 if len(header) == 0 else header[3]
|
||
footer_y0 = page_h if len(footer) == 0 else footer[1]
|
||
if page_no_bboxs:
|
||
top_part = [b for b in page_no_bboxs if b[3] < page_h/2]
|
||
btn_part = [b for b in page_no_bboxs if b[1] > page_h/2]
|
||
|
||
top_max_y0 = max([b[1] for b in top_part]) if top_part else 0
|
||
btn_min_y1 = min([b[3] for b in btn_part]) if btn_part else page_h
|
||
|
||
header_y0 = max(header_y0, top_max_y0)
|
||
footer_y0 = min(footer_y0, btn_min_y1)
|
||
|
||
content_boundry = [0, header_y0, page_w, footer_y0]
|
||
|
||
header = [0,0, page_w, header_y0]
|
||
footer = [0, footer_y0, page_w, page_h]
|
||
|
||
"""以上计算出来了页眉页脚的边界，下面开始进行删除"""
|
||
text_block_to_remove = []
|
||
# 首先检查每个textblock
|
||
for blk in text_raw_blocks:
|
||
if len(blk['lines']) > 0:
|
||
for line in blk['lines']:
|
||
line_del = []
|
||
for span in line['spans']:
|
||
span_del = []
|
||
if span['bbox'][3] < header_y0:
|
||
span_del.append(span)
|
||
elif _is_in_or_part_overlap(span['bbox'], header) or _is_in_or_part_overlap(span['bbox'], footer):
|
||
span_del.append(span)
|
||
for span in span_del:
|
||
line['spans'].remove(span)
|
||
if not line['spans']:
|
||
line_del.append(line)
|
||
|
||
for line in line_del:
|
||
blk['lines'].remove(line)
|
||
else:
|
||
# if not blk['lines']:
|
||
blk['tag'] = 'in-foot-header-area'
|
||
text_block_to_remove.append(blk)
|
||
|
||
"""有的时候由于pageNo太小了，总是会有一点和content_boundry重叠一点，被放入正文，因此对于pageNo，进行span粒度的删除"""
|
||
page_no_block_2_remove = []
|
||
if page_no_bboxs:
|
||
for pagenobox in page_no_bboxs:
|
||
for block in text_raw_blocks:
|
||
if _is_in_or_part_overlap(pagenobox, block['bbox']): # 在span级别删除页码
|
||
for line in block['lines']:
|
||
for span in line['spans']:
|
||
if _is_in_or_part_overlap(pagenobox, span['bbox']):
|
||
#span['text'] = ''
|
||
span['tag'] = "page-no"
|
||
# 检查这个block是否只有这一个span，如果是，那么就把这个block也删除
|
||
if len(line['spans']) == 1 and len(block['lines'])==1:
|
||
page_no_block_2_remove.append(block)
|
||
else:
|
||
# 测试最后一个是不是页码：规则是，最后一个block仅有1个line,一个span,且text是数字，空格，符号组成，不含字母,并且包含数字
|
||
if len(text_raw_blocks) > 0:
|
||
text_raw_blocks.sort(key=lambda x: x['bbox'][1], reverse=True)
|
||
last_block = text_raw_blocks[0]
|
||
if len(last_block['lines']) == 1:
|
||
last_line = last_block['lines'][0]
|
||
if len(last_line['spans']) == 1:
|
||
last_span = last_line['spans'][0]
|
||
if last_span['text'].strip() and not re.search('[a-zA-Z]', last_span['text']) and re.search('[0-9]', last_span['text']):
|
||
last_span['tag'] = "page-no"
|
||
page_no_block_2_remove.append(last_block)
|
||
|
||
|
||
for b in page_no_block_2_remove:
|
||
text_block_to_remove.append(b)
|
||
|
||
for blk in text_block_to_remove:
|
||
if blk in text_raw_blocks:
|
||
text_raw_blocks.remove(blk)
|
||
|
||
text_block_remain = text_raw_blocks
|
||
image_bbox_to_remove = [bbox for bbox in image_bboxes if not _is_in_or_part_overlap(bbox, content_boundry)]
|
||
|
||
image_bbox_remain = [bbox for bbox in image_bboxes if _is_in_or_part_overlap(bbox, content_boundry)]
|
||
table_bbox_to_remove = [bbox for bbox in table_bboxes if not _is_in_or_part_overlap(bbox, content_boundry)]
|
||
table_bbox_remain = [bbox for bbox in table_bboxes if _is_in_or_part_overlap(bbox, content_boundry)]
|
||
|
||
return image_bbox_remain, table_bbox_remain, text_block_remain, text_block_to_remove, image_bbox_to_remove, table_bbox_to_remove
|