BabelDOC 0.2.13__tar.gz → 0.2.15__tar.gz

{babeldoc-0.2.13 → babeldoc-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: BabelDOC
-Version: 0.2.13
+Version: 0.2.15
 Summary: Yet Another Document Translator
 Project-URL: Homepage, https://github.com/funstory-ai/BabelDOC
 Project-URL: Issues, https://github.com/funstory-ai/BabelDOC/issues
@@ -30,6 +30,7 @@ Requires-Dist: psutil>=7.0.0
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pymupdf>=1.25.1
 Requires-Dist: python-levenshtein>=0.27.1
+Requires-Dist: rapidocr-onnxruntime>=1.4.4
 Requires-Dist: rich>=13.9.4
 Requires-Dist: scikit-image>=0.25.2
 Requires-Dist: tenacity>=9.0.0
@@ -181,6 +182,7 @@ uv run babeldoc --files example.pdf --files example2.pdf --openai --openai-model
 - `--watermark-output-mode`: Control watermark output mode: 'watermarked' (default) adds watermark to translated PDF, 'no_watermark' doesn't add watermark, 'both' outputs both versions.
 - `--max-pages-per-part`: Maximum number of pages per part for split translation. If not set, no splitting will be performed.
 - `--no-watermark`: [DEPRECATED] Use --watermark-output-mode=no_watermark instead.
+- `--translate-table-text`: Translate table text (experimental, default: False)
 
 > [!TIP]
 > - Both `--skip-clean` and `--dual-translate-first` may help improve compatibility with some PDF readers

{babeldoc-0.2.13 → babeldoc-0.2.15}/README.md

@@ -136,6 +136,7 @@ uv run babeldoc --files example.pdf --files example2.pdf --openai --openai-model
 - `--watermark-output-mode`: Control watermark output mode: 'watermarked' (default) adds watermark to translated PDF, 'no_watermark' doesn't add watermark, 'both' outputs both versions.
 - `--max-pages-per-part`: Maximum number of pages per part for split translation. If not set, no splitting will be performed.
 - `--no-watermark`: [DEPRECATED] Use --watermark-output-mode=no_watermark instead.
+- `--translate-table-text`: Translate table text (experimental, default: False)
 
 > [!TIP]
 > - Both `--skip-clean` and `--dual-translate-first` may help improve compatibility with some PDF readers

babeldoc-0.2.15/babeldoc/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.15"

{babeldoc-0.2.13 → babeldoc-0.2.15}/babeldoc/assets/assets.py

@@ -14,6 +14,10 @@ from babeldoc.assets.embedding_assets_metadata import (
 from babeldoc.assets.embedding_assets_metadata import EMBEDDING_FONT_METADATA
 from babeldoc.assets.embedding_assets_metadata import FONT_METADATA_URL
 from babeldoc.assets.embedding_assets_metadata import FONT_URL_BY_UPSTREAM
+from babeldoc.assets.embedding_assets_metadata import (
+    TABLE_DETECTION_RAPIDOCR_MODEL_SHA3_256,
+)
+from babeldoc.assets.embedding_assets_metadata import TABLE_DETECTION_RAPIDOCR_MODEL_URL
 from babeldoc.assets.embedding_assets_metadata import TIKTOKEN_CACHES
 from babeldoc.const import get_cache_file_path
 from tenacity import retry
@@ -204,10 +208,36 @@ async def get_doclayout_onnx_model_path_async(client: httpx.AsyncClient | None =
     return onnx_path
 
 
+async def get_table_detection_rapidocr_model_path_async(
+    client: httpx.AsyncClient | None = None,
+):
+    onnx_path = get_cache_file_path("ch_PP-OCRv4_det_infer.onnx", "models")
+    if verify_file(onnx_path, TABLE_DETECTION_RAPIDOCR_MODEL_SHA3_256):
+        return onnx_path
+
+    logger.info("table detection rapidocr model not found or corrupted, downloading...")
+    fastest_upstream, _ = await get_fastest_upstream_for_model(client)
+    if fastest_upstream is None:
+        logger.error("Failed to get fastest upstream")
+        exit(1)
+
+    url = TABLE_DETECTION_RAPIDOCR_MODEL_URL[fastest_upstream]
+
+    await download_file(client, url, onnx_path, TABLE_DETECTION_RAPIDOCR_MODEL_SHA3_256)
+    logger.info(
+        f"Download table detection rapidocr model from {fastest_upstream} success"
+    )
+    return onnx_path
+
+
 def get_doclayout_onnx_model_path():
     return run_coro(get_doclayout_onnx_model_path_async())
 
 
+def get_table_detection_rapidocr_model_path():
+    return run_coro(get_table_detection_rapidocr_model_path_async())
+
+
 def get_font_url_by_name_and_upstream(font_file_name: str, upstream: str):
     if upstream not in FONT_URL_BY_UPSTREAM:
         logger.critical(f"Invalid upstream: {upstream}")
@@ -329,7 +359,11 @@ def generate_all_assets_file_list():
         {
             "name": "doclayout_yolo_docstructbench_imgsz1024.onnx",
             "sha3_256": DOCLAYOUT_YOLO_DOCSTRUCTBENCH_IMGSZ1024ONNX_SHA3_256,
-        }
+        },
+        {
+            "name": "ch_PP-OCRv4_det_infer.onnx",
+            "sha3_256": TABLE_DETECTION_RAPIDOCR_MODEL_SHA3_256,
+        },
     )
     return result
 

{babeldoc-0.2.13 → babeldoc-0.2.15}/babeldoc/assets/embedding_assets_metadata.py

@@ -2,6 +2,10 @@ DOCLAYOUT_YOLO_DOCSTRUCTBENCH_IMGSZ1024ONNX_SHA3_256 = (
     "60be061226930524958b5465c8c04af3d7c03bcb0beb66454f5da9f792e3cf2a"
 )
 
+TABLE_DETECTION_RAPIDOCR_MODEL_SHA3_256 = (
+    "062f4619afe91b33147c033acadecbb53f2a7b99ac703d157b96d5b10948da5e"
+)
+
 TIKTOKEN_CACHES = {
     "fb374d419588a4632f3f557e76b4b70aebbca790": "cb04bcda5782cfbbe77f2f991d92c0ea785d9496ef1137c91dfc3c8c324528d6"
 }
@@ -26,6 +30,12 @@ DOC_LAYOUT_ONNX_MODEL_URL = {
     "modelscope": "https://www.modelscope.cn/models/AI-ModelScope/DocLayout-YOLO-DocStructBench-onnx/resolve/master/doclayout_yolo_docstructbench_imgsz1024.onnx",
 }
 
+TABLE_DETECTION_RAPIDOCR_MODEL_URL = {
+    "huggingface": "https://huggingface.co/spaces/RapidAI/RapidOCR/resolve/main/models/text_det/ch_PP-OCRv4_det_infer.onnx",
+    "hf-mirror": "https://hf-mirror.com/spaces/RapidAI/RapidOCR/resolve/main/models/text_det/ch_PP-OCRv4_det_infer.onnx",
+    "modelscope": "https://www.modelscope.cn/models/RapidAI/RapidOCR/resolve/master/onnx/PP-OCRv4/det/ch_PP-OCRv4_det_infer.onnx",
+}
+
 # from https://github.com/funstory-ai/BabelDOC-Assets/blob/main/font_metadata.json
 EMBEDDING_FONT_METADATA = {
     "GoNotoKurrent-Bold.ttf": {

{babeldoc-0.2.13 → babeldoc-0.2.15}/babeldoc/const.py

@@ -3,7 +3,7 @@ import shutil
 import subprocess
 from pathlib import Path
 
-__version__ = "0.2.13"
+__version__ = "0.2.15"
 
 CACHE_FOLDER = Path.home() / ".cache" / "babeldoc"
 

{babeldoc-0.2.13 → babeldoc-0.2.15}/babeldoc/document_il/backend/pdf_creater.py

@@ -730,7 +730,12 @@ class PDFCreater:
                     draw_op.append(b" Tj ET Q \n")
                 for xobj in page.pdf_xobject:
                     draw_op = xobj_draw_ops[xobj.xobj_id]
-                    pdf.update_stream(xobj.xref_id, draw_op.tobytes())
+                    try:
+                        pdf.update_stream(xobj.xref_id, draw_op.tobytes())
+                    except Exception:
+                        logger.warning(
+                            f"update xref {xobj.xref_id} stream fail, continue"
+                        )
                     # pdf.update_stream(xobj.xref_id, b'')
                 for rect in page.pdf_rectangle:
                     self._debug_render_rectangle(page_op, rect)

{babeldoc-0.2.13 → babeldoc-0.2.15}/babeldoc/document_il/midend/paragraph_finder.py

@@ -287,6 +287,7 @@ class ParagraphFinder:
             "abandon",
             "figure_caption",
             "table_caption",
+            "table_text",
         ]
 
     def get_layout(
@@ -313,6 +314,7 @@ class ParagraphFinder:
             "table_footnote",
             "table_caption",
             "figure_caption",
+            "table_text",
             "table",
             "figure",
             "abandon",

babeldoc-0.2.15/babeldoc/document_il/midend/table_parser.py

@@ -0,0 +1,164 @@
+import logging
+from pathlib import Path
+
+import cv2
+import numpy as np
+from pymupdf import Document
+
+from babeldoc.document_il import il_version_1
+from babeldoc.document_il.utils.style_helper import GREEN
+from babeldoc.translation_config import TranslationConfig
+
+logger = logging.getLogger(__name__)
+
+
+class TableParser:
+    stage_name = "Parse Table"
+
+    def __init__(self, translation_config: TranslationConfig):
+        self.translation_config = translation_config
+        self.model = translation_config.table_model
+
+    def _save_debug_image(self, image: np.ndarray, layouts, page_number: int):
+        """Save debug image with drawn boxes if debug mode is enabled."""
+        if not self.translation_config.debug:
+            return
+
+        if not isinstance(layouts, list):
+            layouts = [layouts]
+        debug_dir = Path(
+            self.translation_config.get_working_file_path("table-ocr-box-image")
+        )
+        debug_dir.mkdir(parents=True, exist_ok=True)
+
+        # Draw boxes on the image
+        debug_image = image.copy()
+        for layout in layouts:
+            for box in layout.boxes:
+                x0, y0, x1, y1 = box.xyxy
+                cv2.rectangle(
+                    debug_image,
+                    (int(x0), int(y0)),
+                    (int(x1), int(y1)),
+                    (0, 255, 0),
+                    2,
+                )
+                # Add text label
+                cv2.putText(
+                    debug_image,
+                    layout.names[box.cls],
+                    (int(x0), int(y0) - 5),
+                    cv2.FONT_HERSHEY_SIMPLEX,
+                    0.5,
+                    (0, 255, 0),
+                    1,
+                )
+
+        # Save the image
+        output_path = debug_dir / f"{page_number}.jpg"
+        cv2.imwrite(str(output_path), debug_image)
+
+    def _save_debug_box_to_page(self, page: il_version_1.Page):
+        """Save debug boxes and text labels to the PDF page."""
+        if not self.translation_config.debug:
+            return
+
+        color = GREEN
+
+        for layout in page.page_layout:
+            # Create a rectangle box
+            rect = il_version_1.PdfRectangle(
+                box=il_version_1.Box(
+                    x=layout.box.x,
+                    y=layout.box.y,
+                    x2=layout.box.x2,
+                    y2=layout.box.y2,
+                ),
+                graphic_state=color,
+                debug_info=True,
+            )
+            page.pdf_rectangle.append(rect)
+
+            # Create text label at top-left corner
+            # Note: PDF coordinates are from bottom-left,
+            # so we use y2 for top position
+            style = il_version_1.PdfStyle(
+                font_id="china-ss",
+                font_size=4,
+                graphic_state=color,
+            )
+            page.pdf_paragraph.append(
+                il_version_1.PdfParagraph(
+                    first_line_indent=False,
+                    box=il_version_1.Box(
+                        x=layout.box.x,
+                        y=layout.box.y2,
+                        x2=layout.box.x2,
+                        y2=layout.box.y2 + 5,
+                    ),
+                    vertical=False,
+                    pdf_style=style,
+                    unicode=layout.class_name,
+                    pdf_paragraph_composition=[
+                        il_version_1.PdfParagraphComposition(
+                            pdf_same_style_unicode_characters=il_version_1.PdfSameStyleUnicodeCharacters(
+                                unicode=layout.class_name,
+                                pdf_style=style,
+                                debug_info=True,
+                            ),
+                        ),
+                    ],
+                    xobj_id=-1,
+                ),
+            )
+
+    def process(self, docs: il_version_1.Document, mupdf_doc: Document):
+        """Generate layouts for all pages that need to be translated."""
+        # Get pages that need to be translated
+        have_table_pages = {}
+        for page in docs.page:
+            for layout in page.page_layout:
+                if layout.class_name == "table":
+                    have_table_pages[page.page_number] = page
+        with self.translation_config.progress_monitor.stage_start(
+            self.stage_name,
+            len(have_table_pages),
+        ) as progress:
+            # Process predictions for each page
+            for page, layouts in self.model.handle_document(
+                have_table_pages.values(),
+                mupdf_doc,
+                self.translation_config,
+                self._save_debug_image,
+            ):
+                page_layouts = []
+                for layout in layouts.boxes:
+                    # Convert coordinate system from picture to il
+                    # system to the il coordinate system
+                    x0, y0, x1, y1 = layout.xyxy
+                    pix = mupdf_doc[page.page_number].get_pixmap()
+                    h, w = pix.height, pix.width
+                    x0, y0, x1, y1 = (
+                        np.clip(int(x0 - 1), 0, w - 1),
+                        np.clip(int(h - y1 - 1), 0, h - 1),
+                        np.clip(int(x1 + 1), 0, w - 1),
+                        np.clip(int(h - y0 + 1), 0, h - 1),
+                    )
+                    page_layout = il_version_1.PageLayout(
+                        id=len(page_layouts) + 1,
+                        box=il_version_1.Box(
+                            x0.item(),
+                            y0.item(),
+                            x1.item(),
+                            y1.item(),
+                        ),
+                        conf=layout.conf.item(),
+                        class_name=layouts.names[layout.cls],
+                    )
+                    page_layouts.append(page_layout)
+
+                page.page_layout.extend(page_layouts)
+                self._save_debug_box_to_page(page)
+                progress.advance(1)
+
+        return docs

babeldoc-0.2.15/babeldoc/docvision/table_detection/rapidocr.py

@@ -0,0 +1,316 @@
+import logging
+import re
+from collections.abc import Generator
+
+import cv2
+import numpy as np
+from babeldoc.assets.assets import get_table_detection_rapidocr_model_path
+from babeldoc.docvision.doclayout import YoloBox
+from babeldoc.docvision.doclayout import YoloResult
+from rapidocr_onnxruntime import RapidOCR
+
+try:
+    import onnxruntime
+except ImportError as e:
+    if "DLL load failed" in str(e):
+        raise OSError(
+            "Microsoft Visual C++ Redistributable is not installed. "
+            "Download it at https://aka.ms/vs/17/release/vc_redist.x64.exe"
+        ) from e
+    raise
+import babeldoc.document_il.il_version_1
+import pymupdf
+
+logger = logging.getLogger(__name__)
+
+
+def convert_to_yolo_result(predictions):
+    """
+    Convert RapidOCR predictions to YoloResult format.
+
+    Args:
+        predictions (list): List of predictions, where each prediction is a list of coordinates
+                           in format [[x1, y1], [x2, y2], [x3, y3], [x4, y4], (text, confidence)]
+                           or a numpy array of format [x1, y1, x2, y2, ...]
+
+    Returns:
+        YoloResult: Converted predictions in YoloResult format
+    """
+    boxes = []
+
+    for pred in predictions:
+        # Check if the prediction is in the format of 4 corner points
+        if isinstance(pred, list) and len(pred) >= 5 and isinstance(pred[0], list):
+            # Convert 4 corner points to xyxy format (min x, min y, max x, max y)
+            points = np.array(pred[:4])
+            x1, y1 = points[:, 0].min(), points[:, 1].min()
+            x2, y2 = points[:, 0].max(), points[:, 1].max()
+            xyxy = [x1, y1, x2, y2]
+            box = YoloBox(xyxy=xyxy, conf=1.0, cls="text")
+        # Check if the prediction is already in xyxy format
+        elif isinstance(pred, list | np.ndarray) and len(pred) >= 4:
+            if isinstance(pred, np.ndarray):
+                pred = pred.tolist()
+            xyxy = pred[:4]
+            box = YoloBox(xyxy=xyxy, conf=1.0, cls="text")
+        else:
+            continue
+
+        boxes.append(box)
+
+    return YoloResult(names=["text"], boxes=boxes)
+
+
+def create_yolo_result_from_nested_coords(nested_coords: np.ndarray, names: dict):
+    boxes = []
+
+    for quad in nested_coords.tolist():
+        if len(quad) != 4:
+            continue
+
+        # Convert quad coordinates to xyxy format (min x, min y, max x, max y)
+        x1, y1, x2, y2 = quad
+
+        # Create YoloBox with confidence 1.0 and class 'text'
+        box = YoloBox(
+            xyxy=[float(x1), float(y1), float(x2), float(y2)], conf=np.array(1.0), cls=0
+        )
+        boxes.append(box)
+
+    return YoloResult(names=names, boxes=boxes)
+
+
+class RapidOCRModel:
+    def __init__(self):
+        self.use_cuda = False
+        self.use_dml = False
+        available_providers = onnxruntime.get_available_providers()
+        for provider in available_providers:
+            if re.match(r"dml", provider, re.IGNORECASE):
+                self.use_dml = True
+            elif re.match(r"cuda", provider, re.IGNORECASE):
+                self.use_cuda = True
+
+        self.model = RapidOCR(
+            det_model_path=get_table_detection_rapidocr_model_path(),
+            det_use_cuda=self.use_cuda,
+            det_use_dml=self.use_dml,
+        )
+        self.names = {0: "table_text"}
+
+    @property
+    def stride(self):
+        return 32
+
+    def resize_and_pad_image(self, image, new_shape):
+        """
+        Resize and pad the image to the specified size, ensuring dimensions are multiples of stride.
+
+        Parameters:
+        - image: Input image
+        - new_shape: Target size (integer or (height, width) tuple)
+        - stride: Padding alignment stride, default 32
+
+        Returns:
+        - Processed image
+        """
+        if isinstance(new_shape, int):
+            new_shape = (new_shape, new_shape)
+
+        h, w = image.shape[:2]
+        new_h, new_w = new_shape
+
+        # Calculate scaling ratio
+        r = min(new_h / h, new_w / w)
+        resized_h, resized_w = int(round(h * r)), int(round(w * r))
+
+        # Resize image
+        image = cv2.resize(
+            image,
+            (resized_w, resized_h),
+            interpolation=cv2.INTER_LINEAR,
+        )
+
+        # Calculate padding size and align to stride multiple
+        pad_w = (new_w - resized_w) % self.stride
+        pad_h = (new_h - resized_h) % self.stride
+        top, bottom = pad_h // 2, pad_h - pad_h // 2
+        left, right = pad_w // 2, pad_w - pad_w // 2
+
+        # Add padding
+        image = cv2.copyMakeBorder(
+            image,
+            top,
+            bottom,
+            left,
+            right,
+            cv2.BORDER_CONSTANT,
+            value=(114, 114, 114),
+        )
+
+        return image
+
+    def scale_boxes(self, img1_shape, boxes, img0_shape):
+        """
+        Rescales bounding boxes (in the format of xyxy by default) from the shape of the image they were originally
+        specified in (img1_shape) to the shape of a different image (img0_shape).
+
+        Args:
+            img1_shape (tuple): The shape of the image that the bounding boxes are for,
+                in the format of (height, width).
+            boxes (torch.Tensor): the bounding boxes of the objects in the image, in the format of (x1, y1, x2, y2)
+            img0_shape (tuple): the shape of the target image, in the format of (height, width).
+
+        Returns:
+            boxes (torch.Tensor): The scaled bounding boxes, in the format of (x1, y1, x2, y2)
+        """
+
+        # Calculate scaling ratio
+        gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1])
+
+        # Calculate padding size
+        pad_x = round((img1_shape[1] - img0_shape[1] * gain) / 2 - 0.1)
+        pad_y = round((img1_shape[0] - img0_shape[0] * gain) / 2 - 0.1)
+
+        # Remove padding and scale boxes
+        boxes[..., :4] = (boxes[..., :4] - [pad_x, pad_y, pad_x, pad_y]) / gain
+        return boxes
+
+    def predict(self, image, imgsz=800, batch_size=16, **kwargs):
+        """
+        Predict the layout of document pages.
+
+        Args:
+            image: A single image or a list of images of document pages.
+            imgsz: Resize the image to this size. Must be a multiple of the stride.
+            batch_size: Number of images to process in one batch.
+            **kwargs: Additional arguments.
+
+        Returns:
+            A YoloResult object containing the detected boxes.
+        """
+        # Handle single image input
+        assert isinstance(image, np.ndarray) and len(image.shape) == 3
+
+        # Calculate target size based on the maximum height in the batch
+        target_imgsz = 1024
+
+        orig_shape = (image.shape[0], image.shape[1])
+
+        pix = self.resize_and_pad_image(image, new_shape=target_imgsz)
+        # pix = np.transpose(pix, (2, 0, 1))  # CHW
+        # pix = pix.astype(np.float32) / 255.0  # Normalize to [0, 1]
+        input_ = pix
+
+        new_h, new_w = input_.shape[:2]
+
+        # Run inference
+        preds = self.model(input_, use_det=True, use_cls=False, use_rec=False)
+
+        # Process each prediction in the batch
+        if len(preds) > 0:
+            preds_np = np.array(preds[0])[:, [0, 2], :].reshape([-1, 4])
+            preds_np[..., :4] = self.scale_boxes(
+                (new_h, new_w),
+                preds_np[..., :4],
+                orig_shape,
+            )
+
+            # Convert predictions to YoloResult format
+            return create_yolo_result_from_nested_coords(preds_np, self.names)
+        else:
+            # Return empty YoloResult if no predictions
+            return YoloResult(names=self.names, boxes=[])
+
+    def handle_document(
+        self,
+        pages: list[babeldoc.document_il.il_version_1.Page],
+        mupdf_doc: pymupdf.Document,
+        translate_config,
+        save_debug_image,
+    ) -> Generator[
+        tuple[babeldoc.document_il.il_version_1.Page, YoloResult], None, None
+    ]:
+        for page in pages:
+            translate_config.raise_if_cancelled()
+            pix = mupdf_doc[page.page_number].get_pixmap(dpi=72)
+            image = np.fromstring(pix.samples, np.uint8).reshape(
+                pix.height,
+                pix.width,
+                3,
+            )[:, :, ::-1]
+
+            table_boxes = []
+            for layout in page.page_layout:
+                if layout.class_name == "table":
+                    table_boxes.append(layout.box)
+
+            predict_result = self.predict(image)
+
+            ok_boxes = []
+            for box in predict_result.boxes:
+                # Convert the box coordinates to float for proper comparison
+                box_xyxy = [float(coord) for coord in box.xyxy]
+
+                # Check if this box is inside any of the table boxes
+                for table_box in table_boxes:
+                    # Determine if box is inside or overlapping with table_box with image dimensions
+                    if self._is_box_in_table(
+                        box_xyxy, table_box, page, image.shape[1], image.shape[0]
+                    ):
+                        ok_boxes.append(box)
+                        break
+
+            yolo_result = YoloResult(names=self.names, boxes=ok_boxes)
+            save_debug_image(
+                image,
+                yolo_result,
+                page.page_number + 1,
+            )
+            yield page, yolo_result
+
+    def _is_box_in_table(self, box_xyxy, table_box, page, img_width, img_height):
+        """
+        Check if a box from image coordinates is inside a table box from PDF coordinates.
+
+        Args:
+            box_xyxy (list): Box coordinates in image coordinate system [x1, y1, x2, y2]
+            table_box (Box): Table box in PDF coordinate system
+            page: The page object containing information for coordinate conversion
+            img_width: Width of the image
+            img_height: Height of the image
+
+        Returns:
+            bool: True if the box is inside or significantly overlapping with the table box
+        """
+
+        # Get table box coordinates in PDF coordinate system
+        table_pdf_x1 = table_box.x
+        table_pdf_y1 = table_box.y
+        table_pdf_x2 = table_box.x2
+        table_pdf_y2 = table_box.y2
+
+        # Convert table box to image coordinates
+        table_img_x1 = table_pdf_x1
+        table_img_y1 = img_height - table_pdf_y2
+        table_img_x2 = table_pdf_x2
+        table_img_y2 = img_height - table_pdf_y1
+
+        # Now check for overlap between the boxes
+        # Calculate the area of overlap
+        x_overlap = max(
+            0, min(box_xyxy[2], table_img_x2) - max(box_xyxy[0], table_img_x1)
+        )
+        y_overlap = max(
+            0, min(box_xyxy[3], table_img_y2) - max(box_xyxy[1], table_img_y1)
+        )
+        overlap_area = x_overlap * y_overlap
+
+        # Calculate area of the detected box
+        box_area = (box_xyxy[2] - box_xyxy[0]) * (box_xyxy[3] - box_xyxy[1])
+
+        # If overlap area is significant relative to the box area, consider it inside
+        if box_area > 0 and overlap_area / box_area > 0.5:
+            return True
+
+        return False