magic-pdf 0.10.0__py3-none-any.whl → 0.10.2__py3-none-any.whl

magic_pdf/post_proc/pdf_post_filter.py

@@ -1,60 +0,0 @@
-from loguru import logger
-
-from magic_pdf.config.drop_reason import DropReason
-from magic_pdf.layout.layout_sort import get_columns_cnt_of_layout
-
-
-def __is_pseudo_single_column(page_info) -> bool:
-    """判断一个页面是否伪单列。
-
-    Args:
-        page_info (dict): 页面信息字典，包括'_layout_tree'和'preproc_blocks'。
-
-    Returns:
-        Tuple[bool, Optional[str]]: 如果页面伪单列返回(True, extra_info)，否则返回(False, None)。
-    """
-    layout_tree = page_info['_layout_tree']
-    layout_column_width = get_columns_cnt_of_layout(layout_tree)
-    if layout_column_width == 1:
-        text_blocks = page_info['preproc_blocks']
-        # 遍历每一个text_block
-        for text_block in text_blocks:
-            lines = text_block['lines']
-            num_lines = len(lines)
-            num_satisfying_lines = 0
-
-            for i in range(num_lines - 1):
-                current_line = lines[i]
-                next_line = lines[i + 1]
-
-                # 获取当前line和下一个line的bbox属性
-                current_bbox = current_line['bbox']
-                next_bbox = next_line['bbox']
-
-                # 检查是否满足条件
-                if next_bbox[0] > current_bbox[2] or next_bbox[2] < current_bbox[0]:
-                    num_satisfying_lines += 1
-            # 如果有一半以上的line满足条件，就drop
-            # print("num_satisfying_lines:", num_satisfying_lines, "num_lines:", num_lines)
-            if num_lines > 20:
-                radio = num_satisfying_lines / num_lines
-                if radio >= 0.5:
-                    extra_info = f'{{num_lines: {num_lines}, num_satisfying_lines: {num_satisfying_lines}}}'
-                    block_text = []
-                    for line in lines:
-                        if line['spans']:
-                            for span in line['spans']:
-                                block_text.append(span['text'])
-                    logger.warning(f'pseudo_single_column block_text: {block_text}')
-                    return True, extra_info
-
-    return False, None
-
-
-def pdf_post_filter(page_info) -> tuple:
-    """return:(True|False, err_msg) True, 如果pdf符合要求 False, 如果pdf不符合要求."""
-    bool_is_pseudo_single_column, extra_info = __is_pseudo_single_column(page_info)
-    if bool_is_pseudo_single_column:
-        return False, {'_need_drop': True, '_drop_reason': DropReason.PSEUDO_SINGLE_COLUMN, 'extra_info': extra_info}
-
-    return True, None

magic_pdf/post_proc/remove_footnote.py

@@ -1,153 +0,0 @@
-from magic_pdf.libs.boxbase import _is_in, _is_in_or_part_overlap
-import collections      # 统计库
-
-
-
-def is_below(bbox1, bbox2):
-    # 如果block1的上边y坐标大于block2的下边y坐标，那么block1在block2下面
-    return bbox1[1] > bbox2[3]
-
-
-def merge_bboxes(bboxes):
-    # 找出所有blocks的最小x0，最大y1，最大x1，最小y0，这就是合并后的bbox
-    x0 = min(bbox[0] for bbox in bboxes)
-    y0 = min(bbox[1] for bbox in bboxes)
-    x1 = max(bbox[2] for bbox in bboxes)
-    y1 = max(bbox[3] for bbox in bboxes)
-    return [x0, y0, x1, y1]
-
-
-def merge_footnote_blocks(page_info, main_text_font):
-    page_info['merged_bboxes'] = []
-    for layout in page_info['layout_bboxes']:
-        # 找出layout中的所有footnote blocks和preproc_blocks
-        footnote_bboxes = [block for block in page_info['footnote_bboxes_tmp'] if _is_in(block, layout['layout_bbox'])]
-        # 如果没有footnote_blocks，就跳过这个layout
-        if not footnote_bboxes:
-            continue
-
-        preproc_blocks = [block for block in page_info['preproc_blocks'] if _is_in(block['bbox'], layout['layout_bbox'])]
-        # preproc_bboxes = [block['bbox'] for block in preproc_blocks]
-        font_names = collections.Counter()
-        if len(preproc_blocks) > 0:
-            # 存储每一行的文本块大小的列表
-            line_sizes = []
-            # 存储每个文本块的平均行大小
-            block_sizes = []
-            for block in preproc_blocks:
-                block_line_sizes = []
-                block_fonts = collections.Counter()
-                for line in block['lines']:
-                    # 提取每个span的size属性，并计算行大小
-                    span_sizes = [span['size'] for span in line['spans'] if 'size' in span]
-                    if span_sizes:
-                        line_size = sum(span_sizes) / len(span_sizes)
-                        line_sizes.append(line_size)
-                        block_line_sizes.append(line_size)
-                    span_font = [(span['font'], len(span['text'])) for span in line['spans'] if
-                                 'font' in span and len(span['text']) > 0]
-                    if span_font:
-                        # # todo main_text_font应该用基于字数最多的字体而不是span级别的统计
-                        # font_names.append(font_name for font_name in span_font)
-                        # block_fonts.append(font_name for font_name in span_font)
-                        for font, count in span_font:
-                            # font_names.extend([font] * count)
-                            # block_fonts.extend([font] * count)
-                            font_names[font] += count
-                            block_fonts[font] += count
-                if block_line_sizes:
-                    # 计算文本块的平均行大小
-                    block_size = sum(block_line_sizes) / len(block_line_sizes)
-                    block_font = block_fonts.most_common(1)[0][0]
-                    block_sizes.append((block, block_size, block_font))
-
-            # 计算main_text_size
-            # main_text_font = font_names.most_common(1)[0][0]
-            main_text_size = collections.Counter(line_sizes).most_common(1)[0][0]
-        else:
-            continue
-
-        need_merge_bboxes = []
-        # 任何一个下面有正文block的footnote bbox都是假footnote
-        for footnote_bbox in footnote_bboxes:
-            # 检测footnote下面是否有正文block(正文block需满足，block平均size大于等于main_text_size，且block行数大于等于5)
-            main_text_bboxes_below = [block['bbox'] for block, size, block_font in block_sizes if
-                                      is_below(block['bbox'], footnote_bbox) and
-                                      sum([size >= main_text_size,
-                                           len(block['lines']) >= 5,
-                                           block_font == main_text_font])
-                                      >= 2]
-            # 如果main_text_bboxes_below不为空，说明footnote下面有正文block，这个footnote不成立，跳过
-            if len(main_text_bboxes_below) > 0:
-                continue
-            else:
-                # 否则，说明footnote下面没有正文block，这个footnote成立，添加到待merge的footnote_bboxes中
-                need_merge_bboxes.append(footnote_bbox)
-        if len(need_merge_bboxes) == 0:
-            continue
-        # 找出最靠上的footnote block
-        top_footnote_bbox = min(need_merge_bboxes, key=lambda bbox: bbox[1])
-        # 找出所有在top_footnote_block下面的preproc_blocks，并确保这些preproc_blocks的平均行大小小于main_text_size
-        bboxes_below = [block['bbox'] for block, size, block_font in block_sizes if is_below(block['bbox'], top_footnote_bbox)]
-        # # 找出所有在top_footnote_block下面的preproc_blocks
-        # bboxes_below = [bbox for bbox in preproc_bboxes if is_below(bbox, top_footnote_bbox)]
-        # 合并top_footnote_block和blocks_below
-        merged_bbox = merge_bboxes([top_footnote_bbox] + bboxes_below)
-        # 添加到新的footnote_bboxes_tmp中
-        page_info['merged_bboxes'].append(merged_bbox)
-    return page_info
-
-
-def remove_footnote_blocks(page_info):
-    if page_info.get('merged_bboxes'):
-        # 从文字中去掉footnote
-        remain_text_blocks, removed_footnote_text_blocks = remove_footnote_text(page_info['preproc_blocks'], page_info['merged_bboxes'])
-        # 从图片中去掉footnote
-        image_blocks, removed_footnote_imgs_blocks = remove_footnote_image(page_info['images'], page_info['merged_bboxes'])
-        # 更新page_info
-        page_info['preproc_blocks'] = remain_text_blocks
-        page_info['images'] = image_blocks
-        page_info['droped_text_block'].extend(removed_footnote_text_blocks)
-        page_info['droped_image_block'].extend(removed_footnote_imgs_blocks)
-        # 删除footnote_bboxes_tmp和merged_bboxes
-        del page_info['merged_bboxes']
-    del page_info['footnote_bboxes_tmp']
-    return page_info
-
-
-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([_is_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

magic_pdf/pre_proc/citationmarker_remove.py

@@ -1,161 +0,0 @@
-"""
-去掉正文的引文引用marker
-https://aicarrier.feishu.cn/wiki/YLOPwo1PGiwFRdkwmyhcZmr0n3d
-"""
-import re
-# from magic_pdf.libs.nlp_utils import NLPModels
-
-
-# __NLP_MODEL = NLPModels()
-
-def check_1(spans, cur_span_i):
-    """寻找前一个char,如果是句号，逗号，那么就是角标"""
-    if cur_span_i==0:
-        return False # 不是角标
-    pre_span = spans[cur_span_i-1]
-    pre_char = pre_span['chars'][-1]['c']
-    if pre_char in ['。', '，', '.', ',']:
-        return True
-    
-    return False
-
-
-# def check_2(spans, cur_span_i):
-#     """检查前面一个span的最后一个单词，如果长度大于5，全都是字母，并且不含大写，就是角标"""
-#     pattern = r'\b[A-Z]\.\s[A-Z][a-z]*\b' # 形如A. Bcde, L. Bcde, 人名的缩写
-#
-#     if cur_span_i==0 and len(spans)>1:
-#         next_span = spans[cur_span_i+1]
-#         next_txt = "".join([c['c'] for c in next_span['chars']])
-#         result = __NLP_MODEL.detect_entity_catgr_using_nlp(next_txt)
-#         if result in ["PERSON", "GPE", "ORG"]:
-#             return True
-#
-#         if re.findall(pattern, next_txt):
-#             return True
-#
-#         return False # 不是角标
-#     elif cur_span_i==0 and len(spans)==1: # 角标占用了整行？谨慎删除
-#         return False
-#
-#     # 如果这个span是最后一个span,
-#     if cur_span_i==len(spans)-1:
-#         pre_span = spans[cur_span_i-1]
-#         pre_txt = "".join([c['c'] for c in pre_span['chars']])
-#         pre_word = pre_txt.split(' ')[-1]
-#         result = __NLP_MODEL.detect_entity_catgr_using_nlp(pre_txt)
-#         if result in ["PERSON", "GPE", "ORG"]:
-#             return True
-#
-#         if re.findall(pattern, pre_txt):
-#             return True
-#
-#         return len(pre_word) > 5 and pre_word.isalpha() and pre_word.islower()
-#     else: # 既不是第一个span，也不是最后一个span，那么此时检查一下这个角标距离前后哪个单词更近就属于谁的角标
-#         pre_span = spans[cur_span_i-1]
-#         next_span = spans[cur_span_i+1]
-#         cur_span = spans[cur_span_i]
-#         # 找到前一个和后一个span里的距离最近的单词
-#         pre_distance = 10000 # 一个很大的数
-#         next_distance = 10000 # 一个很大的数
-#         for c in pre_span['chars'][::-1]:
-#             if c['c'].isalpha():
-#                 pre_distance = cur_span['bbox'][0] - c['bbox'][2]
-#                 break
-#         for c in next_span['chars']:
-#             if c['c'].isalpha():
-#                 next_distance = c['bbox'][0] - cur_span['bbox'][2]
-#                 break
-#
-#         if pre_distance<next_distance:
-#             belong_to_span = pre_span
-#         else:
-#             belong_to_span = next_span
-#
-#         txt = "".join([c['c'] for c in belong_to_span['chars']])
-#         pre_word = txt.split(' ')[-1]
-#         result = __NLP_MODEL.detect_entity_catgr_using_nlp(txt)
-#         if result in ["PERSON", "GPE", "ORG"]:
-#             return True
-#
-#         if re.findall(pattern, txt):
-#             return True
-#
-#         return len(pre_word) > 5 and pre_word.isalpha() and pre_word.islower()
-
-
-def check_3(spans, cur_span_i):
-    """上标里有[], 有*， 有-， 有逗号"""
-    # 如[2-3],[22]  
-    # 如 2,3,4
-    cur_span_txt = ''.join(c['c'] for c in spans[cur_span_i]['chars']).strip()
-    bad_char = ['[', ']', '*', ',']
-
-    if any([c in cur_span_txt for c in bad_char]) and any(character.isdigit() for character in cur_span_txt):
-        return True
-
-    # 如2-3, a-b
-    patterns = [r'\d+-\d+', r'[a-zA-Z]-[a-zA-Z]', r'[a-zA-Z],[a-zA-Z]']
-    for pattern in patterns:  
-        match = re.match(pattern, cur_span_txt)
-        if match is not None:
-            return True
-
-    return False
-
-
-def remove_citation_marker(with_char_text_blcoks):
-    for blk in with_char_text_blcoks:
-        for line in blk['lines']:
-            # 如果span里的个数少于2个，那只能忽略，角标不可能自己独占一行
-            if len(line['spans'])<=1:
-                continue
-
-            # 找到高度最高的span作为位置比较的基准
-            max_hi_span = line['spans'][0]['bbox']
-            min_font_sz = 10000 # line里最小的字体
-            max_font_sz = 0   # line里最大的字体
-                
-            for s in line['spans']:
-                if max_hi_span[3]-max_hi_span[1]<s['bbox'][3]-s['bbox'][1]:
-                    max_hi_span = s['bbox']
-                if min_font_sz>s['size']:
-                    min_font_sz = s['size']
-                if max_font_sz<s['size']:
-                    max_font_sz = s['size']
-                        
-            base_span_mid_y = (max_hi_span[3]+max_hi_span[1])/2
-            
-            
-            span_to_del = []
-            for i, span in enumerate(line['spans']):
-                span_hi = span['bbox'][3]-span['bbox'][1]
-                span_mid_y = (span['bbox'][3]+span['bbox'][1])/2
-                span_font_sz = span['size']
-                
-                if max_font_sz-span_font_sz<1: # 先以字体过滤正文，如果是正文就不再继续判断了
-                    continue
-
-                # 对被除数为0的情况进行过滤
-                if span_hi==0 or min_font_sz==0:
-                    continue
-
-                if (base_span_mid_y-span_mid_y)/span_hi>0.2 or (base_span_mid_y-span_mid_y>0 and abs(span_font_sz-min_font_sz)/min_font_sz<0.1):
-                    """
-                    1. 它的前一个char如果是句号或者逗号的话，那么肯定是角标而不是公式
-                    2. 如果这个角标的前面是一个单词（长度大于5）而不是任何大写或小写的短字母的话 应该也是角标
-                    3. 上标里有数字和逗号或者数字+星号的组合，方括号，一般肯定就是角标了
-                    4. 这个角标属于前文还是后文要根据距离来判断，如果距离前面的文本太近，那么就是前面的角标，否则就是后面的角标
-                    """
-                    if (check_1(line['spans'], i) or
-                        # check_2(line['spans'], i) or
-                        check_3(line['spans'], i)
-                    ):
-                        """删除掉这个角标：删除这个span, 同时还要更新line的text"""
-                        span_to_del.append(span)
-            if len(span_to_del)>0:
-                for span in span_to_del:
-                    line['spans'].remove(span)
-                line['text'] = ''.join([c['c'] for s in line['spans'] for c in s['chars']])
-    
-    return with_char_text_blcoks

magic_pdf/pre_proc/detect_equation.py

@@ -1,134 +0,0 @@
-from magic_pdf.libs.boxbase import _is_in, calculate_overlap_area_2_minbox_area_ratio              # 正则
-from magic_pdf.libs.commons import fitz             # pyMuPDF库
-
-
-def __solve_contain_bboxs(all_bbox_list: list):
-
-    """将两个公式的bbox做判断是否有包含关系，若有的话则删掉较小的bbox"""
-
-    dump_list = []
-    for i in range(len(all_bbox_list)):
-        for j in range(i + 1, len(all_bbox_list)):
-            # 获取当前两个值
-            bbox1 = all_bbox_list[i][:4]
-            bbox2 = all_bbox_list[j][:4]
-            
-            # 删掉较小的框
-            if _is_in(bbox1, bbox2):
-                dump_list.append(all_bbox_list[i])
-            elif _is_in(bbox2, bbox1):
-                dump_list.append(all_bbox_list[j])
-            else:
-                ratio = calculate_overlap_area_2_minbox_area_ratio(bbox1, bbox2)
-                if ratio > 0.7:
-                    s1 = (bbox1[2] - bbox1[0]) * (bbox1[3] - bbox1[1]) 
-                    s2 = (bbox2[2] - bbox2[0]) * (bbox2[3] - bbox2[1])
-                    if s2 > s1:  
-                        dump_list.append(all_bbox_list[i])
-                    else:
-                        dump_list.append(all_bbox_list[i]) 
-
-    # 遍历需要删除的列表中的每个元素
-    for item in dump_list:
-        
-        while item in all_bbox_list:
-            all_bbox_list.remove(item)
-    return all_bbox_list
-
-
-def parse_equations(page_ID: int, page: fitz.Page, json_from_DocXchain_obj: dict):
-    """
-    :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)
-    
-
-    #--------- 通过json_from_DocXchain来获取 table ---------#
-    equationEmbedding_from_DocXChain_bboxs = []
-    equationIsolated_from_DocXChain_bboxs = []
-    
-    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)
-    
-    for xf in xf_json['layout_dets']:
-    # {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'}
-        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)
-        # equation
-        img_suffix = f"{page_ID}_{int(L)}_{int(U)}_{int(R)}_{int(D)}"
-        if xf['category_id'] == 13 and xf['score'] >= 0.3:      
-            latex_text = xf.get("latex", "EmptyInlineEquationResult")
-            debugable_latex_text = f"{latex_text}|{img_suffix}"
-            equationEmbedding_from_DocXChain_bboxs.append((L, U, R, D, latex_text))
-        if xf['category_id'] == 14 and xf['score'] >= 0.3:
-            latex_text = xf.get("latex", "EmptyInterlineEquationResult")
-            debugable_latex_text = f"{latex_text}|{img_suffix}"
-            equationIsolated_from_DocXChain_bboxs.append((L, U, R, D, latex_text))
-    
-    #---------------------------------------- 排序，编号，保存 -----------------------------------------#
-    equationIsolated_from_DocXChain_bboxs.sort(key = lambda LURD: (LURD[1], LURD[0]))
-    equationIsolated_from_DocXChain_bboxs.sort(key = lambda LURD: (LURD[1], LURD[0]))
-    
-    equationEmbedding_from_DocXChain_names = []
-    equationEmbedding_ID = 0
-    
-    equationIsolated_from_DocXChain_names = []
-    equationIsolated_ID = 0
-    
-    for L, U, R, D, _ in equationEmbedding_from_DocXChain_bboxs:
-        if not(L < R and U < D):
-            continue
-        try:
-            # cur_equation = page.get_pixmap(clip=(L,U,R,D))
-            new_equation_name = "equationEmbedding_{}_{}.png".format(page_ID, equationEmbedding_ID)        # 公式name
-            # cur_equation.save(res_dir_path + '/' + new_equation_name)                       # 把公式存出在新建的文件夹，并命名
-            equationEmbedding_from_DocXChain_names.append(new_equation_name)                         # 把公式的名字存在list中，方便在md中插入引用
-            equationEmbedding_ID += 1
-        except:
-            pass
-
-    for L, U, R, D, _ in equationIsolated_from_DocXChain_bboxs:
-        if not(L < R and U < D):
-            continue
-        try:
-            # cur_equation = page.get_pixmap(clip=(L,U,R,D))
-            new_equation_name = "equationEmbedding_{}_{}.png".format(page_ID, equationIsolated_ID)        # 公式name
-            # cur_equation.save(res_dir_path + '/' + new_equation_name)                       # 把公式存出在新建的文件夹，并命名
-            equationIsolated_from_DocXChain_names.append(new_equation_name)                         # 把公式的名字存在list中，方便在md中插入引用
-            equationIsolated_ID += 1
-        except:
-            pass
-    
-    equationEmbedding_from_DocXChain_bboxs.sort(key = lambda LURD: (LURD[1], LURD[0]))
-    equationIsolated_from_DocXChain_bboxs.sort(key = lambda LURD: (LURD[1], LURD[0]))
-    
-    
-    """根据pdf可视区域，调整bbox的坐标"""
-    cropbox = page.cropbox
-    if cropbox[0]!=page.rect[0] or cropbox[1]!=page.rect[1]:
-        for eq_box in equationEmbedding_from_DocXChain_bboxs:
-            eq_box = [eq_box[0]+cropbox[0], eq_box[1]+cropbox[1], eq_box[2]+cropbox[0], eq_box[3]+cropbox[1], eq_box[4]]
-        for eq_box in equationIsolated_from_DocXChain_bboxs:
-            eq_box = [eq_box[0]+cropbox[0], eq_box[1]+cropbox[1], eq_box[2]+cropbox[0], eq_box[3]+cropbox[1], eq_box[4]]
-        
-    deduped_embedding_eq_bboxes = __solve_contain_bboxs(equationEmbedding_from_DocXChain_bboxs)
-    return deduped_embedding_eq_bboxes, equationIsolated_from_DocXChain_bboxs

magic_pdf/pre_proc/detect_footer_by_model.py

@@ -1,64 +0,0 @@
-from magic_pdf.libs.commons import fitz             # pyMuPDF库
-from magic_pdf.libs.coordinate_transform import get_scale_ratio
-
-
-def parse_footers(page_ID: int, page: fitz.Page, json_from_DocXchain_obj: dict):
-    """
-    :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
-    """
-
-    #--------- 通过json_from_DocXchain来获取 footer ---------#
-    footer_bbox_from_DocXChain = []
-
-    xf_json = json_from_DocXchain_obj
-    horizontal_scale_ratio, vertical_scale_ratio = get_scale_ratio(xf_json, page)
-
-    # {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] / horizontal_scale_ratio
-        U = xf['poly'][1] / vertical_scale_ratio
-        R = xf['poly'][2] / horizontal_scale_ratio
-        D = xf['poly'][5] / vertical_scale_ratio
-        # 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'] == 6 and xf['score'] >= 0.3:
-            footer_bbox_from_DocXChain.append((L, U, R, D))
-            
-    
-    footer_final_names = []
-    footer_final_bboxs = []
-    footer_ID = 0
-    for L, U, R, D in footer_bbox_from_DocXChain:
-        # cur_footer = page.get_pixmap(clip=(L,U,R,D))
-        new_footer_name = "footer_{}_{}.png".format(page_ID, footer_ID)    # 脚注name
-        # cur_footer.save(res_dir_path + '/' + new_footer_name)           # 把页脚存储在新建的文件夹，并命名
-        footer_final_names.append(new_footer_name)                        # 把脚注的名字存在list中
-        footer_final_bboxs.append((L, U, R, D))
-        footer_ID += 1
-        
-
-    footer_final_bboxs.sort(key = lambda LURD: (LURD[1], LURD[0]))
-    curPage_all_footer_bboxs = footer_final_bboxs
-    return curPage_all_footer_bboxs
-