paddlex 3.0.0rc1__py3-none-any.whl → 3.0.2__py3-none-any.whl

paddlex/inference/pipelines/layout_parsing/result.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 import copy
-from pathlib import Path
 from typing import Dict
 
 import numpy as np
@@ -31,15 +30,6 @@ class LayoutParsingResult(BaseCVResult, HtmlMixin, XlsxMixin):
         HtmlMixin.__init__(self)
         XlsxMixin.__init__(self)
 
-    def _get_input_fn(self):
-        fn = super()._get_input_fn()
-        if (page_idx := self["page_index"]) is not None:
-            fp = Path(fn)
-            stem, suffix = fp.stem, fp.suffix
-            return f"{stem}_{page_idx}{suffix}"
-        else:
-            return fn
-
     def _to_img(self) -> Dict[str, np.ndarray]:
         res_img_dict = {}
         model_settings = self["model_settings"]
@@ -47,12 +37,11 @@ class LayoutParsingResult(BaseCVResult, HtmlMixin, XlsxMixin):
             res_img_dict.update(**self["doc_preprocessor_res"].img)
         res_img_dict["layout_det_res"] = self["layout_det_res"].img["res"]
 
-        if model_settings["use_general_ocr"] or model_settings["use_table_recognition"]:
-            res_img_dict["overall_ocr_res"] = self["overall_ocr_res"].img["ocr_res_img"]
+        res_img_dict["overall_ocr_res"] = self["overall_ocr_res"].img["ocr_res_img"]
 
         if model_settings["use_table_recognition"] and len(self["table_res_list"]) > 0:
             table_cell_img = Image.fromarray(
-                copy.deepcopy(self["doc_preprocessor_res"]["output_img"])
+                copy.deepcopy(self["doc_preprocessor_res"]["output_img"][:, :, ::-1])
             )
             table_draw = ImageDraw.Draw(table_cell_img)
             rectangle_color = (255, 0, 0)
@@ -106,8 +95,7 @@ class LayoutParsingResult(BaseCVResult, HtmlMixin, XlsxMixin):
         if self["model_settings"]["use_doc_preprocessor"]:
             data["doc_preprocessor_res"] = self["doc_preprocessor_res"].str["res"]
         data["layout_det_res"] = self["layout_det_res"].str["res"]
-        if model_settings["use_general_ocr"] or model_settings["use_table_recognition"]:
-            data["overall_ocr_res"] = self["overall_ocr_res"].str["res"]
+        data["overall_ocr_res"] = self["overall_ocr_res"].str["res"]
         if model_settings["use_table_recognition"] and len(self["table_res_list"]) > 0:
             data["table_res_list"] = []
             for sno in range(len(self["table_res_list"])):
@@ -149,8 +137,7 @@ class LayoutParsingResult(BaseCVResult, HtmlMixin, XlsxMixin):
         if self["model_settings"]["use_doc_preprocessor"]:
             data["doc_preprocessor_res"] = self["doc_preprocessor_res"].json["res"]
         data["layout_det_res"] = self["layout_det_res"].json["res"]
-        if model_settings["use_general_ocr"] or model_settings["use_table_recognition"]:
-            data["overall_ocr_res"] = self["overall_ocr_res"].json["res"]
+        data["overall_ocr_res"] = self["overall_ocr_res"].json["res"]
         if model_settings["use_table_recognition"] and len(self["table_res_list"]) > 0:
             data["table_res_list"] = []
             for sno in range(len(self["table_res_list"])):

paddlex/inference/pipelines/layout_parsing/result_v2.py

@@ -15,11 +15,13 @@ from __future__ import annotations
 
 import copy
 import re
-from pathlib import Path
+from functools import partial
+from typing import List
 
 import numpy as np
-from PIL import Image, ImageDraw
+from PIL import Image, ImageDraw, ImageFont
 
+from ....utils.fonts import PINGFANG_FONT_FILE_PATH
 from ...common.result import (
     BaseCVResult,
     HtmlMixin,
@@ -27,7 +29,115 @@ from ...common.result import (
     MarkdownMixin,
     XlsxMixin,
 )
-from .utils import get_show_color
+from .layout_objects import LayoutBlock
+from .utils import get_seg_flag
+
+
+def compile_title_pattern():
+    # Precompiled regex pattern for matching numbering at the beginning of the title
+    numbering_pattern = (
+        r"(?:" + r"[1-9][0-9]*(?:\.[1-9][0-9]*)*[\.、]?|" + r"[\(\（](?:[1-9][0-9]*|["
+        r"一二三四五六七八九十百千万亿零壹贰叁肆伍陆柒捌玖拾]+)[\)\）]|" + r"["
+        r"一二三四五六七八九十百千万亿零壹贰叁肆伍陆柒捌玖拾]+"
+        r"[、\.]?|" + r"(?:I|II|III|IV|V|VI|VII|VIII|IX|X)\.?" + r")"
+    )
+    return re.compile(r"^\s*(" + numbering_pattern + r")(\s*)(.*)$")
+
+
+TITLE_RE_PATTERN = compile_title_pattern()
+
+
+def format_title_func(block):
+    """
+    Normalize chapter title.
+    Add the '#' to indicate the level of the title.
+    If numbering exists, ensure there's exactly one space between it and the title content.
+    If numbering does not exist, return the original title unchanged.
+
+    :param title: Original chapter title string.
+    :return: Normalized chapter title string.
+    """
+    title = block.content
+    match = TITLE_RE_PATTERN.match(title)
+    if match:
+        numbering = match.group(1).strip()
+        title_content = match.group(3).lstrip()
+        # Return numbering and title content separated by one space
+        title = numbering + " " + title_content
+
+    title = title.rstrip(".")
+    level = (
+        title.count(
+            ".",
+        )
+        + 1
+        if "." in title
+        else 1
+    )
+    return f"#{'#' * level} {title}".replace("-\n", "").replace(
+        "\n",
+        " ",
+    )
+
+
+def format_centered_by_html(string):
+    return (
+        f'<div style="text-align: center;">{string}</div>'.replace(
+            "-\n",
+            "",
+        ).replace("\n", " ")
+        + "\n"
+    )
+
+
+def format_text_plain_func(block):
+    return block.content
+
+
+def format_image_scaled_by_html_func(block, original_image_width):
+    img_tags = []
+    image_path = block.image["path"]
+    image_width = block.image["img"].width
+    scale = int(image_width / original_image_width * 100)
+    img_tags.append(
+        '<img src="{}" alt="Image" width="{}%" />'.format(
+            image_path.replace("-\n", "").replace("\n", " "), scale
+        ),
+    )
+    return "\n".join(img_tags)
+
+
+def format_image_plain_func(block):
+    img_tags = []
+    image_path = block.image["path"]
+    img_tags.append("![]({})".format(image_path.replace("-\n", "").replace("\n", " ")))
+    return "\n".join(img_tags)
+
+
+def format_chart2table_func(block):
+    lines_list = block.content.split("\n")
+    column_num = len(lines_list[0].split("|"))
+    lines_list.insert(1, "|".join(["---"] * column_num))
+    lines_list = [f"|{line}|" for line in lines_list]
+    return "\n".join(lines_list)
+
+
+def simplify_table_func(table_code):
+    return "\n" + table_code.replace("<html>", "").replace("</html>", "").replace(
+        "<body>", ""
+    ).replace("</body>", "")
+
+
+def format_first_line_func(block, templates, format_func, spliter):
+    lines = block.content.split(spliter)
+    for idx in range(len(lines)):
+        line = lines[idx]
+        if line.strip() == "":
+            continue
+        if line.lower() in templates:
+            lines[idx] = format_func(line)
+        break
+    return spliter.join(lines)
 
 
 class LayoutParsingResultV2(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
@@ -40,30 +150,10 @@ class LayoutParsingResultV2(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
         XlsxMixin.__init__(self)
         MarkdownMixin.__init__(self)
         JsonMixin.__init__(self)
-        self.title_pattern = self._build_title_pattern()
-
-    def _build_title_pattern(self):
-        # Precompiled regex pattern for matching numbering at the beginning of the title
-        numbering_pattern = (
-            r"(?:"
-            + r"[1-9][0-9]*(?:\.[1-9][0-9]*)*[\.、]?|"
-            + r"[\(\（](?:[1-9][0-9]*|["
-            r"一二三四五六七八九十百千万亿零壹贰叁肆伍陆柒捌玖拾]+)[\)\）]|" + r"["
-            r"一二三四五六七八九十百千万亿零壹贰叁肆伍陆柒捌玖拾]+"
-            r"[、\.]?|" + r"(?:I|II|III|IV|V|VI|VII|VIII|IX|X)\.?" + r")"
-        )
-        return re.compile(r"^\s*(" + numbering_pattern + r")(\s*)(.*)$")
-
-    def _get_input_fn(self):
-        fn = super()._get_input_fn()
-        if (page_idx := self["page_index"]) is not None:
-            fp = Path(fn)
-            stem, suffix = fp.stem, fp.suffix
-            return f"{stem}_{page_idx}{suffix}"
-        else:
-            return fn
 
     def _to_img(self) -> dict[str, np.ndarray]:
+        from .utils import get_show_color
+
         res_img_dict = {}
         model_settings = self["model_settings"]
         if model_settings["use_doc_preprocessor"]:
@@ -71,12 +161,14 @@ class LayoutParsingResultV2(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
                 res_img_dict[key] = value
         res_img_dict["layout_det_res"] = self["layout_det_res"].img["res"]
 
-        if model_settings["use_general_ocr"] or model_settings["use_table_recognition"]:
-            res_img_dict["overall_ocr_res"] = self["overall_ocr_res"].img["ocr_res_img"]
+        if model_settings["use_region_detection"]:
+            res_img_dict["region_det_res"] = self["region_det_res"].img["res"]
+
+        res_img_dict["overall_ocr_res"] = self["overall_ocr_res"].img["ocr_res_img"]
 
         if model_settings["use_table_recognition"] and len(self["table_res_list"]) > 0:
             table_cell_img = Image.fromarray(
-                copy.deepcopy(self["doc_preprocessor_res"]["output_img"])
+                copy.deepcopy(self["doc_preprocessor_res"]["output_img"][:, :, ::-1])
             )
             table_draw = ImageDraw.Draw(table_cell_img)
             rectangle_color = (255, 0, 0)
@@ -101,16 +193,23 @@ class LayoutParsingResultV2(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
         # for layout ordering image
         image = Image.fromarray(self["doc_preprocessor_res"]["output_img"][:, :, ::-1])
         draw = ImageDraw.Draw(image, "RGBA")
-        parsing_result = self["parsing_res_list"]
+        font_size = int(0.018 * int(image.width)) + 2
+        font = ImageFont.truetype(PINGFANG_FONT_FILE_PATH, font_size, encoding="utf-8")
+        parsing_result: List[LayoutBlock] = self["parsing_res_list"]
         for block in parsing_result:
-            bbox = block["block_bbox"]
-            index = block.get("index", None)
-            label = block["sub_label"]
-            fill_color = get_show_color(label)
+            bbox = block.bbox
+            index = block.order_index
+            label = block.label
+            fill_color = get_show_color(label, False)
             draw.rectangle(bbox, fill=fill_color)
             if index is not None:
-                text_position = (bbox[2] + 2, bbox[1] - 10)
-                draw.text(text_position, str(index), fill="red")
+                text_position = (bbox[2] + 2, bbox[1] - font_size // 2)
+                if int(image.width) - bbox[2] < font_size:
+                    text_position = (
+                        int(bbox[2] - font_size * 1.1),
+                        bbox[1] - font_size // 2,
+                    )
+                draw.text(text_position, str(index), font=font, fill="red")
 
         res_img_dict["layout_order_res"] = image
 
@@ -134,8 +233,7 @@ class LayoutParsingResultV2(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
         if self["model_settings"]["use_doc_preprocessor"]:
             data["doc_preprocessor_res"] = self["doc_preprocessor_res"].str["res"]
         data["layout_det_res"] = self["layout_det_res"].str["res"]
-        if model_settings["use_general_ocr"] or model_settings["use_table_recognition"]:
-            data["overall_ocr_res"] = self["overall_ocr_res"].str["res"]
+        data["overall_ocr_res"] = self["overall_ocr_res"].str["res"]
         if model_settings["use_table_recognition"] and len(self["table_res_list"]) > 0:
             data["table_res_list"] = []
             for sno in range(len(self["table_res_list"])):
@@ -176,9 +274,9 @@ class LayoutParsingResultV2(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
         parsing_res_list = self["parsing_res_list"]
         parsing_res_list = [
             {
-                "block_label": parsing_res["block_label"],
-                "block_content": parsing_res["block_content"],
-                "block_bbox": parsing_res["block_bbox"],
+                "block_label": parsing_res.label,
+                "block_content": parsing_res.content,
+                "block_bbox": parsing_res.bbox,
             }
             for parsing_res in parsing_res_list
         ]
@@ -186,8 +284,7 @@ class LayoutParsingResultV2(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
         if self["model_settings"]["use_doc_preprocessor"]:
             data["doc_preprocessor_res"] = self["doc_preprocessor_res"].json["res"]
         data["layout_det_res"] = self["layout_det_res"].json["res"]
-        if model_settings["use_general_ocr"] or model_settings["use_table_recognition"]:
-            data["overall_ocr_res"] = self["overall_ocr_res"].json["res"]
+        data["overall_ocr_res"] = self["overall_ocr_res"].json["res"]
         if model_settings["use_table_recognition"] and len(self["table_res_list"]) > 0:
             data["table_res_list"] = []
             for sno in range(len(self["table_res_list"])):
@@ -240,227 +337,144 @@ class LayoutParsingResultV2(BaseCVResult, HtmlMixin, XlsxMixin, MarkdownMixin):
                 res_xlsx_dict[key] = table_res.xlsx["pred"]
         return res_xlsx_dict
 
-    def _to_markdown(self) -> dict:
+    def _to_markdown(self, pretty=True) -> dict:
         """
         Save the parsing result to a Markdown file.
 
+        Args:
+            pretty (Optional[bool]): whether to pretty markdown by HTML, default by True.
+
         Returns:
             Dict
         """
+        original_image_width = self["doc_preprocessor_res"]["output_img"].shape[1]
 
-        def _format_data(obj):
-
-            def format_title(title):
-                """
-                Normalize chapter title.
-                Add the '#' to indicate the level of the title.
-                If numbering exists, ensure there's exactly one space between it and the title content.
-                If numbering does not exist, return the original title unchanged.
-
-                :param title: Original chapter title string.
-                :return: Normalized chapter title string.
-                """
-                match = self.title_pattern.match(title)
-                if match:
-                    numbering = match.group(1).strip()
-                    title_content = match.group(3).lstrip()
-                    # Return numbering and title content separated by one space
-                    title = numbering + " " + title_content
-
-                title = title.rstrip(".")
-                level = (
-                    title.count(
-                        ".",
-                    )
-                    + 1
-                    if "." in title
-                    else 1
-                )
-                return f"#{'#' * level} {title}".replace("-\n", "").replace(
-                    "\n",
-                    " ",
-                )
-
-            def format_centered_text(key):
-                return (
-                    f'<div style="text-align: center;">{block[key]}</div>'.replace(
-                        "-\n",
-                        "",
-                    ).replace("\n", " ")
-                    + "\n"
+        if pretty:
+            format_text_func = lambda block: format_centered_by_html(
+                format_text_plain_func(block)
+            )
+            format_image_func = lambda block: format_centered_by_html(
+                format_image_scaled_by_html_func(
+                    block,
+                    original_image_width=original_image_width,
                 )
+            )
+        else:
+            format_text_func = lambda block: block.content
+            format_image_func = format_image_plain_func
 
-            def format_image(label):
-                img_tags = []
-                image_path = "".join(block[label].keys())
-                img_tags.append(
-                    '<div style="text-align: center;"><img src="{}" alt="Image" /></div>'.format(
-                        image_path.replace("-\n", "").replace("\n", " "),
-                    ),
-                )
-                return "\n".join(img_tags)
-
-            def format_first_line(templates, format_func, spliter):
-                lines = block["block_content"].split(spliter)
-                for idx in range(len(lines)):
-                    line = lines[idx]
-                    if line.strip() == "":
-                        continue
-                    if line.lower() in templates:
-                        lines[idx] = format_func(line)
-                    break
-                return spliter.join(lines)
-
-            def format_table():
-                return "\n" + block["block_content"]
-
-            def get_seg_flag(block, prev_block):
-
-                seg_start_flag = True
-                seg_end_flag = True
-
-                block_box = block["block_bbox"]
-                context_left_coordinate = block_box[0]
-                context_right_coordinate = block_box[2]
-                seg_start_coordinate = block.get("seg_start_coordinate")
-                seg_end_coordinate = block.get("seg_end_coordinate")
-
-                if prev_block is not None:
-                    prev_block_bbox = prev_block["block_bbox"]
-                    num_of_prev_lines = prev_block.get("num_of_lines")
-                    pre_block_seg_end_coordinate = prev_block.get("seg_end_coordinate")
-                    prev_end_space_small = (
-                        context_right_coordinate - pre_block_seg_end_coordinate < 10
-                    )
-                    prev_lines_more_than_one = num_of_prev_lines > 1
-
-                    overlap_blocks = context_left_coordinate < prev_block_bbox[2]
-
-                    # update context_left_coordinate and context_right_coordinate
-                    if overlap_blocks:
-                        context_left_coordinate = min(
-                            prev_block_bbox[0], context_left_coordinate
-                        )
-                        context_right_coordinate = max(
-                            prev_block_bbox[2], context_right_coordinate
-                        )
-                        prev_end_space_small = (
-                            prev_block_bbox[2] - pre_block_seg_end_coordinate < 10
-                        )
-
-                    current_start_space_small = (
-                        seg_start_coordinate - context_left_coordinate < 10
-                    )
+        if self["model_settings"].get("use_chart_recognition", False):
+            format_chart_func = format_chart2table_func
+        else:
+            format_chart_func = format_image_func
 
-                    if (
-                        prev_end_space_small
-                        and current_start_space_small
-                        and prev_lines_more_than_one
-                    ):
-                        seg_start_flag = False
-                else:
-                    if seg_start_coordinate - context_left_coordinate < 10:
-                        seg_start_flag = False
-
-                if context_right_coordinate - seg_end_coordinate < 10:
-                    seg_end_flag = False
-
-                return seg_start_flag, seg_end_flag
-
-            handlers = {
-                "paragraph_title": lambda: format_title(block["block_content"]),
-                "doc_title": lambda: f"# {block['block_content']}".replace(
-                    "-\n",
-                    "",
-                ).replace("\n", " "),
-                "table_title": lambda: format_centered_text("block_content"),
-                "figure_title": lambda: format_centered_text("block_content"),
-                "chart_title": lambda: format_centered_text("block_content"),
-                "text": lambda: block["block_content"]
-                .replace("-\n", " ")
-                .replace("\n", " "),
-                "abstract": lambda: format_first_line(
-                    ["摘要", "abstract"], lambda l: f"## {l}\n", " "
-                ),
-                "content": lambda: block["block_content"]
-                .replace("-\n", "  \n")
-                .replace("\n", "  \n"),
-                "image": lambda: format_image("block_image"),
-                "chart": lambda: format_image("block_image"),
-                "formula": lambda: f"$${block['block_content']}$$",
-                "table": format_table,
-                "reference": lambda: format_first_line(
-                    ["参考文献", "references"], lambda l: f"## {l}", "\n"
-                ),
-                "algorithm": lambda: block["block_content"].strip("\n"),
-                "seal": lambda: f"Words of Seals:\n{block['block_content']}",
-            }
-            parsing_res_list = obj["parsing_res_list"]
-            markdown_content = ""
-            last_label = None
-            seg_start_flag = None
-            seg_end_flag = None
-            prev_block = None
-            page_first_element_seg_start_flag = None
-            page_last_element_seg_end_flag = None
-            parsing_res_list = sorted(
-                parsing_res_list,
-                key=lambda x: x.get("sub_index", 999),
+        if self["model_settings"].get("use_seal_recognition", False):
+            format_seal_func = lambda block: "\n".join(
+                [format_image_func(block), format_text_func(block)]
             )
-            for block in parsing_res_list:
-                seg_start_flag, seg_end_flag = get_seg_flag(block, prev_block)
-
-                label = block.get("block_label")
-                page_first_element_seg_start_flag = (
-                    seg_start_flag
-                    if (page_first_element_seg_start_flag is None)
-                    else page_first_element_seg_start_flag
+        else:
+            format_seal_func = format_image_func
+
+        if self["model_settings"].get("use_table_recognition", False):
+            if pretty:
+                format_table_func = lambda block: "\n" + format_text_func(
+                    block
+                ).replace("<table>", '<table border="1">')
+            else:
+                format_table_func = lambda block: simplify_table_func(
+                    "\n" + block.content
                 )
-                handler = handlers.get(label)
-                if handler:
-                    prev_block = block
-                    if label == last_label == "text" and seg_start_flag == False:
-                        last_char_of_markdown = (
-                            markdown_content[-1] if markdown_content else ""
-                        )
-                        first_char_of_handler = handler()[0] if handler() else ""
-                        last_is_chinese_char = (
-                            re.match(r"[\u4e00-\u9fff]", last_char_of_markdown)
-                            if last_char_of_markdown
-                            else False
-                        )
-                        first_is_chinese_char = (
-                            re.match(r"[\u4e00-\u9fff]", first_char_of_handler)
-                            if first_char_of_handler
-                            else False
-                        )
-                        if not (last_is_chinese_char or first_is_chinese_char):
-                            markdown_content += " " + handler()
-                        else:
-                            markdown_content += handler()
-                    else:
-                        markdown_content += (
-                            "\n\n" + handler() if markdown_content else handler()
-                        )
-                    last_label = label
-            page_last_element_seg_end_flag = seg_end_flag
-
-            return markdown_content, (
-                page_first_element_seg_start_flag,
-                page_last_element_seg_end_flag,
+        else:
+            format_table_func = format_image_func
+
+        if self["model_settings"].get("use_formula_recognition", False):
+            format_formula_func = lambda block: f"$${block.content}$$"
+        else:
+            format_formula_func = format_image_func
+
+        handle_funcs_dict = {
+            "paragraph_title": format_title_func,
+            "abstract_title": format_title_func,
+            "reference_title": format_title_func,
+            "content_title": format_title_func,
+            "doc_title": lambda block: f"# {block.content}".replace(
+                "-\n",
+                "",
+            ).replace("\n", " "),
+            "table_title": format_text_func,
+            "figure_title": format_text_func,
+            "chart_title": format_text_func,
+            "vision_footnote": lambda block: block.content.replace(
+                "\n\n", "\n"
+            ).replace("\n", "\n\n"),
+            "text": lambda block: block.content.replace("\n\n", "\n").replace(
+                "\n", "\n\n"
+            ),
+            "abstract": partial(
+                format_first_line_func,
+                templates=["摘要", "abstract"],
+                format_func=lambda l: f"## {l}\n",
+                spliter=" ",
+            ),
+            "content": lambda block: block.content.replace("-\n", "  \n").replace(
+                "\n", "  \n"
+            ),
+            "image": format_image_func,
+            "chart": format_chart_func,
+            "formula": format_formula_func,
+            "table": format_table_func,
+            "reference": partial(
+                format_first_line_func,
+                templates=["参考文献", "references"],
+                format_func=lambda l: f"## {l}",
+                spliter="\n",
+            ),
+            "algorithm": lambda block: block.content.strip("\n"),
+            "seal": format_seal_func,
+        }
+
+        markdown_content = ""
+        last_label = None
+        seg_start_flag = None
+        seg_end_flag = None
+        prev_block = None
+        page_first_element_seg_start_flag = None
+        page_last_element_seg_end_flag = None
+        markdown_info = {}
+        markdown_info["markdown_images"] = {}
+        for block in self["parsing_res_list"]:
+            seg_start_flag, seg_end_flag = get_seg_flag(block, prev_block)
+
+            label = block.label
+            if block.image is not None:
+                markdown_info["markdown_images"][block.image["path"]] = block.image[
+                    "img"
+                ]
+            page_first_element_seg_start_flag = (
+                seg_start_flag
+                if (page_first_element_seg_start_flag is None)
+                else page_first_element_seg_start_flag
             )
 
-        markdown_info = dict()
-        markdown_info["markdown_texts"], (
-            page_first_element_seg_start_flag,
-            page_last_element_seg_end_flag,
-        ) = _format_data(self)
+            handle_func = handle_funcs_dict.get(label, None)
+            if handle_func:
+                prev_block = block
+                if label == last_label == "text" and seg_start_flag == False:
+                    markdown_content += handle_func(block)
+                else:
+                    markdown_content += (
+                        "\n\n" + handle_func(block)
+                        if markdown_content
+                        else handle_func(block)
+                    )
+                last_label = label
+        page_last_element_seg_end_flag = seg_end_flag
+
+        markdown_info["markdown_texts"] = markdown_content
         markdown_info["page_continuation_flags"] = (
             page_first_element_seg_start_flag,
             page_last_element_seg_end_flag,
         )
-
-        markdown_info["markdown_images"] = {}
         for img in self["imgs_in_doc"]:
             markdown_info["markdown_images"][img["path"]] = img["img"]