"""Implementation of the Lattice table parser."""
from __future__ import annotations
import os
from typing import Any
import cv2
from ..backends import ImageConversionBackend
from ..image_processing import _line_crossing
from ..image_processing import adaptive_threshold
from ..image_processing import find_contours
from ..image_processing import find_joints
from ..image_processing import find_joints_from_lines
from ..image_processing import find_lines
from ..image_processing import find_lines_from_layout
from ..utils import bbox_from_str
from ..utils import merge_close_lines
from ..utils import scale_image
from ..utils import scale_pdf
from ..utils import segments_in_bbox
from ..utils import text_in_bbox_per_axis
from .base import BaseParser
#: Reject a detected ruled grid whose cells are at least this percent empty.
#: Real data tables are mostly filled; a near-empty grid (whitespace in the
#: 90s) is almost always ruled *noise* — page borders, form rules, header
#: separators — that the contour/joint pipeline mistook for a table. Chosen
#: above the observed real-table whitespace range and below the spurious one
#: (the false positives measured on the ICDAR set sit at 91-95 %).
_GRID_WHITESPACE_REJECT = 90.0
def _line_in_any_bbox(line, bboxes):
"""True if a ruled line's extent overlaps any of the given bboxes.
Used by the vector engine to keep only lines relevant to the
user-supplied ``table_regions``. ``line`` is ``(x0, y0, x1, y1)`` and
each bbox is ``(x0, y0, x1, y1)`` = (left, bottom, right, top), both in
PDF coords.
"""
lx0, ly0, lx1, ly1 = line
lxmin, lxmax = (lx0, lx1) if lx0 <= lx1 else (lx1, lx0)
lymin, lymax = (ly0, ly1) if ly0 <= ly1 else (ly1, ly0)
for x0, y0, x1, y1 in bboxes:
if lxmax >= x0 and lxmin <= x1 and lymax >= y0 and lymin <= y1:
return True
return False
def _joints_in_bbox(h_lines, v_lines, bbox):
"""Line crossings (joints) that fall inside ``bbox`` (PDF coords).
The vector engine's equivalent of the raster ``find_joints`` over a
user-supplied ``table_areas`` box: every h/v line intersection within
the box becomes a joint.
"""
x0, y0, x1, y1 = bbox
joints = []
for h in h_lines:
for v in v_lines:
pt = _line_crossing(h, v)
if pt is not None and x0 <= pt[0] <= x1 and y0 <= pt[1] <= y1:
joints.append(pt)
return joints
class Lattice(BaseParser):
"""Lattice method looks for lines between text to parse the table.
Parameters
----------
table_regions : list, optional (default: None)
List of page regions that may contain tables of the form x1,y1,x2,y2
where (x1, y1) -> left-top and (x2, y2) -> right-bottom
in PDF coordinate space.
table_areas : list, optional (default: None)
List of table area strings of the form x1,y1,x2,y2
where (x1, y1) -> left-top and (x2, y2) -> right-bottom
in PDF coordinate space.
process_background : bool, optional (default: False)
Process background lines.
line_scale : int, optional (default: 15)
Line size scaling factor. The larger the value the smaller
the detected lines. Making it very large will lead to text
being detected as lines.
copy_text : list, optional (default: None)
{'h', 'v'}
Direction in which text in a spanning cell will be copied
over.
shift_text : list, optional (default: ['l', 't'])
{'l', 'r', 't', 'b'}
Direction in which text in a spanning cell will flow.
split_text : bool, optional (default: False)
Split text that spans across multiple cells.
flag_size : bool, optional (default: False)
Flag text based on font size. Useful to detect
super/subscripts. Adds