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

magic_pdf/pre_proc/detect_page_number.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_pageNos(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来获取 pageNo ---------#
-    pageNo_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'] == 4 and xf['score'] >= 0.3:
-            pageNo_bbox_from_DocXChain.append((L, U, R, D))
-            
-    
-    pageNo_final_names = []
-    pageNo_final_bboxs = []
-    pageNo_ID = 0
-    for L, U, R, D in pageNo_bbox_from_DocXChain:
-        # cur_pageNo = page.get_pixmap(clip=(L,U,R,D))
-        new_pageNo_name = "pageNo_{}_{}.png".format(page_ID, pageNo_ID)    # 页码name
-        # cur_pageNo.save(res_dir_path + '/' + new_pageNo_name)           # 把页码存储在新建的文件夹，并命名
-        pageNo_final_names.append(new_pageNo_name)                        # 把页码的名字存在list中
-        pageNo_final_bboxs.append((L, U, R, D))
-        pageNo_ID += 1
-        
-
-    pageNo_final_bboxs.sort(key = lambda LURD: (LURD[1], LURD[0]))
-    curPage_all_pageNo_bboxs = pageNo_final_bboxs
-    return curPage_all_pageNo_bboxs
-

magic_pdf/pre_proc/detect_tables.py

@@ -1,62 +0,0 @@
-from magic_pdf.libs.commons import fitz             # pyMuPDF库
-
-
-def parse_tables(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 ---------#
-    table_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)
-
-    
-    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'}
-    #  13: 'embedding',     # 嵌入公式
-    #  14: 'isolated'}      # 单行公式
-        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'] == 7 and xf['score'] >= 0.3:
-            table_bbox_from_DocXChain.append((L, U, R, D))
-            
-    
-    table_final_names = []
-    table_final_bboxs = []
-    table_ID = 0
-    for L, U, R, D in table_bbox_from_DocXChain:
-        # cur_table = page.get_pixmap(clip=(L,U,R,D))
-        new_table_name = "table_{}_{}.png".format(page_ID, table_ID)      # 表格name
-        # cur_table.save(res_dir_path + '/' + new_table_name)        # 把表格存出在新建的文件夹，并命名
-        table_final_names.append(new_table_name)                      # 把表格的名字存在list中，方便在md中插入引用
-        table_final_bboxs.append((L, U, R, D))
-        table_ID += 1
-        
-
-    table_final_bboxs.sort(key = lambda LURD: (LURD[1], LURD[0]))
-    curPage_all_table_bboxs = table_final_bboxs
-    return curPage_all_table_bboxs
-

magic_pdf/pre_proc/equations_replace.py

@@ -1,550 +0,0 @@
-"""对pymupdf返回的结构里的公式进行替换，替换为模型识别的公式结果."""
-
-import json
-import os
-from pathlib import Path
-
-from loguru import logger
-
-from magic_pdf.config.ocr_content_type import ContentType
-from magic_pdf.libs.commons import fitz
-
-TYPE_INLINE_EQUATION = ContentType.InlineEquation
-TYPE_INTERLINE_EQUATION = ContentType.InterlineEquation
-
-
-def combine_chars_to_pymudict(block_dict, char_dict):
-    """把block级别的pymupdf 结构里加入char结构."""
-    # 因为block_dict 被裁剪过，因此先把他和char_dict文字块对齐，才能进行补充
-    char_map = {tuple(item['bbox']): item for item in char_dict}
-
-    for i in range(len(block_dict)):  # block
-        block = block_dict[i]
-        key = block['bbox']
-        char_dict_item = char_map[tuple(key)]
-        char_dict_map = {tuple(item['bbox']): item for item in char_dict_item['lines']}
-        for j in range(len(block['lines'])):
-            lines = block['lines'][j]
-            with_char_lines = char_dict_map[lines['bbox']]
-            for k in range(len(lines['spans'])):
-                spans = lines['spans'][k]
-                try:
-                    chars = with_char_lines['spans'][k]['chars']
-                except Exception:
-                    logger.error(char_dict[i]['lines'][j])
-
-                spans['chars'] = chars
-
-    return block_dict
-
-
-def calculate_overlap_area_2_minbox_area_ratio(bbox1, min_bbox):
-    """计算box1和box2的重叠面积占最小面积的box的比例."""
-    # Determine the coordinates of the intersection rectangle
-    x_left = max(bbox1[0], min_bbox[0])
-    y_top = max(bbox1[1], min_bbox[1])
-    x_right = min(bbox1[2], min_bbox[2])
-    y_bottom = min(bbox1[3], min_bbox[3])
-
-    if x_right < x_left or y_bottom < y_top:
-        return 0.0
-
-    # The area of overlap area
-    intersection_area = (x_right - x_left) * (y_bottom - y_top)
-    min_box_area = (min_bbox[3] - min_bbox[1]) * (min_bbox[2] - min_bbox[0])
-    if min_box_area == 0:
-        return 0
-    else:
-        return intersection_area / min_box_area
-
-
-def _is_xin(bbox1, bbox2):
-    area1 = abs(bbox1[2] - bbox1[0]) * abs(bbox1[3] - bbox1[1])
-    area2 = abs(bbox2[2] - bbox2[0]) * abs(bbox2[3] - bbox2[1])
-    if area1 < area2:
-        ratio = calculate_overlap_area_2_minbox_area_ratio(bbox2, bbox1)
-    else:
-        ratio = calculate_overlap_area_2_minbox_area_ratio(bbox1, bbox2)
-
-    return ratio > 0.6
-
-
-def remove_text_block_in_interline_equation_bbox(interline_bboxes, text_blocks):
-    """消除掉整个块都在行间公式块内部的文本块."""
-    for eq_bbox in interline_bboxes:
-        removed_txt_blk = []
-        for text_blk in text_blocks:
-            text_bbox = text_blk['bbox']
-            if (
-                calculate_overlap_area_2_minbox_area_ratio(eq_bbox['bbox'], text_bbox)
-                >= 0.7
-            ):
-                removed_txt_blk.append(text_blk)
-        for blk in removed_txt_blk:
-            text_blocks.remove(blk)
-
-    return text_blocks
-
-
-def _is_in_or_part_overlap(box1, box2) -> bool:
-    """两个bbox是否有部分重叠或者包含."""
-    if box1 is None or box2 is None:
-        return False
-
-    x0_1, y0_1, x1_1, y1_1 = box1
-    x0_2, y0_2, x1_2, y1_2 = box2
-
-    return not (
-        x1_1 < x0_2  # box1在box2的左边
-        or x0_1 > x1_2  # box1在box2的右边
-        or y1_1 < y0_2  # box1在box2的上边
-        or y0_1 > y1_2
-    )  # box1在box2的下边
-
-
-def remove_text_block_overlap_interline_equation_bbox(
-    interline_eq_bboxes, pymu_block_list
-):
-    """消除掉行行内公式有部分重叠的文本块的内容。 同时重新计算消除重叠之后文本块的大小."""
-    deleted_block = []
-    for text_block in pymu_block_list:
-        deleted_line = []
-        for line in text_block['lines']:
-            deleted_span = []
-            for span in line['spans']:
-                deleted_chars = []
-                for char in span['chars']:
-                    if any(
-                        [
-                            (
-                                calculate_overlap_area_2_minbox_area_ratio(
-                                    eq_bbox['bbox'], char['bbox']
-                                )
-                                > 0.5
-                            )
-                            for eq_bbox in interline_eq_bboxes
-                        ]
-                    ):
-                        deleted_chars.append(char)
-                # 检查span里没有char则删除这个span
-                for char in deleted_chars:
-                    span['chars'].remove(char)
-                # 重新计算这个span的大小
-                if len(span['chars']) == 0:  # 删除这个span
-                    deleted_span.append(span)
-                else:
-                    span['bbox'] = (
-                        min([b['bbox'][0] for b in span['chars']]),
-                        min([b['bbox'][1] for b in span['chars']]),
-                        max([b['bbox'][2] for b in span['chars']]),
-                        max([b['bbox'][3] for b in span['chars']]),
-                    )
-
-            # 检查这个span
-            for span in deleted_span:
-                line['spans'].remove(span)
-            if len(line['spans']) == 0:  # 删除这个line
-                deleted_line.append(line)
-            else:
-                line['bbox'] = (
-                    min([b['bbox'][0] for b in line['spans']]),
-                    min([b['bbox'][1] for b in line['spans']]),
-                    max([b['bbox'][2] for b in line['spans']]),
-                    max([b['bbox'][3] for b in line['spans']]),
-                )
-
-        # 检查这个block是否可以删除
-        for line in deleted_line:
-            text_block['lines'].remove(line)
-        if len(text_block['lines']) == 0:  # 删除block
-            deleted_block.append(text_block)
-        else:
-            text_block['bbox'] = (
-                min([b['bbox'][0] for b in text_block['lines']]),
-                min([b['bbox'][1] for b in text_block['lines']]),
-                max([b['bbox'][2] for b in text_block['lines']]),
-                max([b['bbox'][3] for b in text_block['lines']]),
-            )
-
-    # 检查text block删除
-    for block in deleted_block:
-        pymu_block_list.remove(block)
-    if len(pymu_block_list) == 0:
-        return []
-
-    return pymu_block_list
-
-
-def insert_interline_equations_textblock(interline_eq_bboxes, pymu_block_list):
-    """在行间公式对应的地方插上一个伪造的block."""
-    for eq in interline_eq_bboxes:
-        bbox = eq['bbox']
-        latex_content = eq['latex']
-        text_block = {
-            'number': len(pymu_block_list),
-            'type': 0,
-            'bbox': bbox,
-            'lines': [
-                {
-                    'spans': [
-                        {
-                            'size': 9.962599754333496,
-                            'type': TYPE_INTERLINE_EQUATION,
-                            'flags': 4,
-                            'font': TYPE_INTERLINE_EQUATION,
-                            'color': 0,
-                            'ascender': 0.9409999847412109,
-                            'descender': -0.3050000071525574,
-                            'latex': latex_content,
-                            'origin': [bbox[0], bbox[1]],
-                            'bbox': bbox,
-                        }
-                    ],
-                    'wmode': 0,
-                    'dir': [1.0, 0.0],
-                    'bbox': bbox,
-                }
-            ],
-        }
-        pymu_block_list.append(text_block)
-
-
-def x_overlap_ratio(box1, box2):
-    a, _, c, _ = box1
-    e, _, g, _ = box2
-
-    # 计算重叠宽度
-    overlap_x = max(min(c, g) - max(a, e), 0)
-
-    # 计算box1的宽度
-    width1 = g - e
-
-    # 计算重叠比例
-    overlap_ratio = overlap_x / width1 if width1 != 0 else 0
-
-    return overlap_ratio
-
-
-def __is_x_dir_overlap(bbox1, bbox2):
-    return not (bbox1[2] < bbox2[0] or bbox1[0] > bbox2[2])
-
-
-def __y_overlap_ratio(box1, box2):
-    """"""
-    _, b, _, d = box1
-    _, f, _, h = box2
-
-    # 计算重叠高度
-    overlap_y = max(min(d, h) - max(b, f), 0)
-
-    # 计算box1的高度
-    height1 = d - b
-
-    # 计算重叠比例
-    overlap_ratio = overlap_y / height1 if height1 != 0 else 0
-
-    return overlap_ratio
-
-
-def replace_line_v2(eqinfo, line):
-    """扫描这一行所有的和公式框X方向重叠的char,然后计算char的左、右x0, x1,位于这个区间内的span删除掉。
-    最后与这个x0,x1有相交的span0, span1内部进行分割。"""
-    first_overlap_span = -1
-    first_overlap_span_idx = -1
-    last_overlap_span = -1
-    delete_chars = []
-    for i in range(0, len(line['spans'])):
-        if 'chars' not in line['spans'][i]:
-            continue
-
-        if line['spans'][i].get('_type', None) is not None:
-            continue  # 忽略，因为已经是插入的伪造span公式了
-
-        for char in line['spans'][i]['chars']:
-            if __is_x_dir_overlap(eqinfo['bbox'], char['bbox']):
-                line_txt = ''
-                for span in line['spans']:
-                    span_txt = '<span>'
-                    for ch in span['chars']:
-                        span_txt = span_txt + ch['c']
-
-                    span_txt = span_txt + '</span>'
-
-                    line_txt = line_txt + span_txt
-
-                if first_overlap_span_idx == -1:
-                    first_overlap_span = line['spans'][i]
-                    first_overlap_span_idx = i
-                last_overlap_span = line['spans'][i]
-                delete_chars.append(char)
-
-    # 第一个和最后一个char要进行检查，到底属于公式多还是属于正常span多
-    if len(delete_chars) > 0:
-        ch0_bbox = delete_chars[0]['bbox']
-        if x_overlap_ratio(eqinfo['bbox'], ch0_bbox) < 0.51:
-            delete_chars.remove(delete_chars[0])
-    if len(delete_chars) > 0:
-        ch0_bbox = delete_chars[-1]['bbox']
-        if x_overlap_ratio(eqinfo['bbox'], ch0_bbox) < 0.51:
-            delete_chars.remove(delete_chars[-1])
-
-    # 计算x方向上被删除区间内的char的真实x0, x1
-    if len(delete_chars):
-        x0, x1 = (
-            min([b['bbox'][0] for b in delete_chars]),
-            max([b['bbox'][2] for b in delete_chars]),
-        )
-    else:
-        # logger.debug(f"行内公式替换没有发生，尝试下一行匹配, eqinfo={eqinfo}")
-        return False
-
-    # 删除位于x0, x1这两个中间的span
-    delete_span = []
-    for span in line['spans']:
-        span_box = span['bbox']
-        if x0 <= span_box[0] and span_box[2] <= x1:
-            delete_span.append(span)
-    for span in delete_span:
-        line['spans'].remove(span)
-
-    equation_span = {
-        'size': 9.962599754333496,
-        'type': TYPE_INLINE_EQUATION,
-        'flags': 4,
-        'font': TYPE_INLINE_EQUATION,
-        'color': 0,
-        'ascender': 0.9409999847412109,
-        'descender': -0.3050000071525574,
-        'latex': '',
-        'origin': [337.1410153102337, 216.0205245153934],
-        'bbox': eqinfo['bbox'],
-    }
-    # equation_span = line['spans'][0].copy()
-    equation_span['latex'] = eqinfo['latex']
-    equation_span['bbox'] = [x0, equation_span['bbox'][1], x1, equation_span['bbox'][3]]
-    equation_span['origin'] = [equation_span['bbox'][0], equation_span['bbox'][1]]
-    equation_span['chars'] = delete_chars
-    equation_span['type'] = TYPE_INLINE_EQUATION
-    equation_span['_eq_bbox'] = eqinfo['bbox']
-    line['spans'].insert(first_overlap_span_idx + 1, equation_span)  # 放入公式
-
-    # logger.info(f"==>text is 【{line_txt}】, equation is 【{eqinfo['latex_text']}】")
-
-    # 第一个、和最后一个有overlap的span进行分割,然后插入对应的位置
-    first_span_chars = [
-        char
-        for char in first_overlap_span['chars']
-        if (char['bbox'][2] + char['bbox'][0]) / 2 < x0
-    ]
-    tail_span_chars = [
-        char
-        for char in last_overlap_span['chars']
-        if (char['bbox'][0] + char['bbox'][2]) / 2 > x1
-    ]
-
-    if len(first_span_chars) > 0:
-        first_overlap_span['chars'] = first_span_chars
-        first_overlap_span['text'] = ''.join([char['c'] for char in first_span_chars])
-        first_overlap_span['bbox'] = (
-            first_overlap_span['bbox'][0],
-            first_overlap_span['bbox'][1],
-            max([chr['bbox'][2] for chr in first_span_chars]),
-            first_overlap_span['bbox'][3],
-        )
-        # first_overlap_span['_type'] = "first"
-    else:
-        # 删掉
-        if first_overlap_span not in delete_span:
-            line['spans'].remove(first_overlap_span)
-
-    if len(tail_span_chars) > 0:
-        min_of_tail_span_x0 = min([chr['bbox'][0] for chr in tail_span_chars])
-        min_of_tail_span_y0 = min([chr['bbox'][1] for chr in tail_span_chars])
-        max_of_tail_span_x1 = max([chr['bbox'][2] for chr in tail_span_chars])
-        max_of_tail_span_y1 = max([chr['bbox'][3] for chr in tail_span_chars])
-
-        if last_overlap_span == first_overlap_span:  # 这个时候应该插入一个新的
-            tail_span_txt = ''.join([char['c'] for char in tail_span_chars])  # noqa: F841
-            last_span_to_insert = last_overlap_span.copy()
-            last_span_to_insert['chars'] = tail_span_chars
-            last_span_to_insert['text'] = ''.join(
-                [char['c'] for char in tail_span_chars]
-            )
-            if equation_span['bbox'][2] >= last_overlap_span['bbox'][2]:
-                last_span_to_insert['bbox'] = (
-                    min_of_tail_span_x0,
-                    min_of_tail_span_y0,
-                    max_of_tail_span_x1,
-                    max_of_tail_span_y1,
-                )
-            else:
-                last_span_to_insert['bbox'] = (
-                    min([chr['bbox'][0] for chr in tail_span_chars]),
-                    last_overlap_span['bbox'][1],
-                    last_overlap_span['bbox'][2],
-                    last_overlap_span['bbox'][3],
-                )
-            # 插入到公式对象之后
-            equation_idx = line['spans'].index(equation_span)
-            line['spans'].insert(equation_idx + 1, last_span_to_insert)  # 放入公式
-        else:  # 直接修改原来的span
-            last_overlap_span['chars'] = tail_span_chars
-            last_overlap_span['text'] = ''.join([char['c'] for char in tail_span_chars])
-            last_overlap_span['bbox'] = (
-                min([chr['bbox'][0] for chr in tail_span_chars]),
-                last_overlap_span['bbox'][1],
-                last_overlap_span['bbox'][2],
-                last_overlap_span['bbox'][3],
-            )
-    else:
-        # 删掉
-        if (
-            last_overlap_span not in delete_span
-            and last_overlap_span != first_overlap_span
-        ):
-            line['spans'].remove(last_overlap_span)
-
-    remain_txt = ''
-    for span in line['spans']:
-        span_txt = '<span>'
-        for char in span['chars']:
-            span_txt = span_txt + char['c']
-
-        span_txt = span_txt + '</span>'
-
-        remain_txt = remain_txt + span_txt
-
-    # logger.info(f"<== succ replace, text is 【{remain_txt}】, equation is 【{eqinfo['latex_text']}】")
-
-    return True
-
-
-def replace_eq_blk(eqinfo, text_block):
-    """替换行内公式."""
-    for line in text_block['lines']:
-        line_bbox = line['bbox']
-        if (
-            _is_xin(eqinfo['bbox'], line_bbox)
-            or __y_overlap_ratio(eqinfo['bbox'], line_bbox) > 0.6
-        ):  # 定位到行, 使用y方向重合率是因为有的时候，一个行的宽度会小于公式位置宽度：行很高，公式很窄，
-            replace_succ = replace_line_v2(eqinfo, line)
-            if not replace_succ:  # 有的时候，一个pdf的line高度从API里会计算的有问题，因此在行内span级别会替换不成功，这就需要继续重试下一行
-                continue
-            else:
-                break
-    else:
-        return False
-    return True
-
-
-def replace_inline_equations(inline_equation_bboxes, raw_text_blocks):
-    """替换行内公式."""
-    for eqinfo in inline_equation_bboxes:
-        eqbox = eqinfo['bbox']
-        for blk in raw_text_blocks:
-            if _is_xin(eqbox, blk['bbox']):
-                if not replace_eq_blk(eqinfo, blk):
-                    logger.warning(f'行内公式没有替换成功：{eqinfo} ')
-                else:
-                    break
-
-    return raw_text_blocks
-
-
-def remove_chars_in_text_blocks(text_blocks):
-    """删除text_blocks里的char."""
-    for blk in text_blocks:
-        for line in blk['lines']:
-            for span in line['spans']:
-                _ = span.pop('chars', 'no such key')
-    return text_blocks
-
-
-def replace_equations_in_textblock(
-    raw_text_blocks, inline_equation_bboxes, interline_equation_bboxes
-):
-    """替换行间和和行内公式为latex."""
-    raw_text_blocks = remove_text_block_in_interline_equation_bbox(
-        interline_equation_bboxes, raw_text_blocks
-    )  # 消除重叠：第一步，在公式内部的
-
-    raw_text_blocks = remove_text_block_overlap_interline_equation_bbox(
-        interline_equation_bboxes, raw_text_blocks
-    )  # 消重，第二步，和公式覆盖的
-
-    insert_interline_equations_textblock(interline_equation_bboxes, raw_text_blocks)
-    raw_text_blocks = replace_inline_equations(inline_equation_bboxes, raw_text_blocks)
-    return raw_text_blocks
-
-
-def draw_block_on_pdf_with_txt_replace_eq_bbox(json_path, pdf_path):
-    """"""
-    new_pdf = f'{Path(pdf_path).parent}/{Path(pdf_path).stem}.step3-消除行内公式text_block.pdf'
-    with open(json_path, 'r', encoding='utf-8') as f:
-        obj = json.loads(f.read())
-
-    if os.path.exists(new_pdf):
-        os.remove(new_pdf)
-    new_doc = fitz.open('')
-
-    doc = fitz.open(pdf_path)  # noqa: F841
-    new_doc = fitz.open(pdf_path)
-    for i in range(len(new_doc)):
-        page = new_doc[i]
-        inline_equation_bboxes = obj[f'page_{i}']['inline_equations']
-        interline_equation_bboxes = obj[f'page_{i}']['interline_equations']
-        raw_text_blocks = obj[f'page_{i}']['preproc_blocks']
-        raw_text_blocks = remove_text_block_in_interline_equation_bbox(
-            interline_equation_bboxes, raw_text_blocks
-        )  # 消除重叠：第一步，在公式内部的
-        raw_text_blocks = remove_text_block_overlap_interline_equation_bbox(
-            interline_equation_bboxes, raw_text_blocks
-        )  # 消重，第二步，和公式覆盖的
-        insert_interline_equations_textblock(interline_equation_bboxes, raw_text_blocks)
-        raw_text_blocks = replace_inline_equations(
-            inline_equation_bboxes, raw_text_blocks
-        )
-
-        # 为了检验公式是否重复，把每一行里，含有公式的span背景改成黄色的
-        color_map = [fitz.pdfcolor['blue'], fitz.pdfcolor['green']]  # noqa: F841
-        j = 0  # noqa: F841
-        for blk in raw_text_blocks:
-            for i, line in enumerate(blk['lines']):
-                # line_box = line['bbox']
-                # shape = page.new_shape()
-                # shape.draw_rect(line_box)
-                # shape.finish(color=fitz.pdfcolor['red'], fill=color_map[j%2], fill_opacity=0.3)
-                # shape.commit()
-                # j = j+1
-
-                for i, span in enumerate(line['spans']):
-                    shape_page = page.new_shape()
-                    span_type = span.get('_type')
-                    color = fitz.pdfcolor['blue']
-                    if span_type == 'first':
-                        color = fitz.pdfcolor['blue']
-                    elif span_type == 'tail':
-                        color = fitz.pdfcolor['green']
-                    elif span_type == TYPE_INLINE_EQUATION:
-                        color = fitz.pdfcolor['black']
-                    else:
-                        color = None
-
-                    b = span['bbox']
-                    shape_page.draw_rect(b)
-
-                    shape_page.finish(color=None, fill=color, fill_opacity=0.3)
-                    shape_page.commit()
-
-    new_doc.save(new_pdf)
-    logger.info(f'save ok {new_pdf}')
-    final_json = json.dumps(obj, ensure_ascii=False, indent=2)
-    with open('equations_test/final_json.json', 'w') as f:
-        f.write(final_json)
-
-    return new_pdf
-
-
-if __name__ == '__main__':
-    # draw_block_on_pdf_with_txt_replace_eq_bbox(new_json_path, equation_color_pdf)
-    pass