docvortex 0.2.1__py3-none-any.whl

docvortex/analyzers/native/pdf/table_detection.py

@@ -0,0 +1,227 @@
+"""PDF 表格检测编排与续表标题；保留原有认领顺序与判定规则。"""
+
+from __future__ import annotations
+from ....schema import BBox
+from .models import _PageSource, _TableAnnotation, _TableCandidate
+from .geometry import (
+    _bbox_area,
+    _bbox_axis_overlap_ratio,
+    _bbox_overlap_in_smaller,
+    _bbox_union,
+    _expand_bbox,
+    _rotate_bbox_from_upright,
+    _rotate_bbox_to_upright,
+    _transform_axis_lines,
+)
+
+from .table_constants import _TABLE_CONTINUATION_RE
+from .table_filled_grid import _detect_filled_grid_table_candidates
+from .table_rules import (
+    _build_closed_rule_grid_candidates,
+    _build_fragments,
+    _build_rule_table_candidates,
+    _cluster_fragment_rows,
+    _connected_rule_grid_bboxes,
+    _median_fragment_height,
+    _merge_table_candidates,
+)
+
+
+def _detect_table_candidates(
+    source: _PageSource,
+    excluded_bboxes: list[BBox] | None = None,
+) -> list[_TableCandidate]:
+    """按文本方向融合横线区间、规则文本和填充行带，生成表格候选。"""
+
+    excluded_bboxes = excluded_bboxes or []
+    filled_grid_candidates = _detect_filled_grid_table_candidates(
+        source.path_infos,
+        source.page_size,
+        excluded_bboxes,
+    )
+    filled_grid_bboxes = [candidate.bbox for candidate in filled_grid_candidates]
+    rule_candidates: list[_TableCandidate] = []
+    angles = sorted({line.angle for line in source.lines})
+    for angle in angles:
+        angle_lines = [line for line in source.lines if line.angle == angle]
+        if not angle_lines:
+            continue
+        fragments = _build_fragments(angle_lines, source.page_size)
+        if not fragments:
+            continue
+        median_height = _median_fragment_height(fragments)
+        rows = _cluster_fragment_rows(fragments, median_height)
+        local_axis_lines = _transform_axis_lines(
+            source.drawing_lines,
+            source.page_size,
+            angle,
+        )
+        local_excluded_bboxes = [
+            _expand_bbox(
+                _rotate_bbox_to_upright(bbox, source.page_size, angle),
+                2.5 * median_height,
+            )
+            for bbox in [*excluded_bboxes, *filled_grid_bboxes]
+        ]
+        local_closed_grid_excluded_bboxes = [
+            *local_excluded_bboxes,
+            *[_rotate_bbox_to_upright(bbox, source.page_size, angle) for bbox in source.form_bboxes],
+        ]
+        rule_candidates.extend(
+            _build_rule_table_candidates(
+                rows,
+                angle_lines,
+                source.page_size,
+                angle,
+                median_height,
+                local_axis_lines,
+                path_infos=source.path_infos,
+                excluded_bboxes=local_excluded_bboxes,
+            )
+        )
+        rule_candidates.extend(
+            _build_closed_rule_grid_candidates(
+                rows,
+                angle_lines,
+                source.page_size,
+                angle,
+                median_height,
+                local_axis_lines,
+                local_closed_grid_excluded_bboxes,
+            )
+        )
+    merged_rule_candidates = [
+        candidate
+        for candidate in _merge_table_candidates(rule_candidates)
+        if not any(_bbox_overlap_in_smaller(candidate.bbox, filled_bbox) >= 0.2 for filled_bbox in filled_grid_bboxes)
+    ]
+    candidates = [*filled_grid_candidates, *merged_rule_candidates]
+    _externalize_table_continuation_captions(
+        source,
+        candidates,
+    )
+    return sorted(
+        candidates,
+        key=lambda candidate: (candidate.bbox[1], candidate.bbox[0]),
+    )
+
+
+def _externalize_table_continuation_captions(
+    source: _PageSource,
+    candidates: list[_TableCandidate],
+) -> None:
+    """以连通物理网格收紧表体，并把其上方续表标记外置为 caption。"""
+
+    for candidate in candidates:
+        angle_lines = [line for line in source.lines if line.angle == candidate.angle]
+        if not angle_lines:
+            continue
+        fragments = _build_fragments(
+            angle_lines,
+            source.page_size,
+        )
+        if not fragments:
+            continue
+        median_height = _median_fragment_height(fragments)
+        local_axis_lines = _transform_axis_lines(
+            source.drawing_lines,
+            source.page_size,
+            candidate.angle,
+        )
+        grid_matches = [
+            grid_bbox
+            for grid_bbox in _connected_rule_grid_bboxes(
+                local_axis_lines,
+                median_height,
+            )
+            if _bbox_axis_overlap_ratio(
+                grid_bbox,
+                candidate.local_bbox,
+                axis="x",
+            )
+            >= 0.9
+            and _bbox_overlap_in_smaller(
+                grid_bbox,
+                candidate.local_bbox,
+            )
+            >= 0.9
+        ]
+        if not grid_matches:
+            continue
+        grid_bbox = max(
+            grid_matches,
+            key=lambda bbox: _bbox_area(bbox),
+        )
+        continuation_lines = []
+        for line in angle_lines:
+            if (
+                _TABLE_CONTINUATION_RE.fullmatch(
+                    line.text.strip(),
+                )
+                is None
+            ):
+                continue
+            local_bbox = _rotate_bbox_to_upright(
+                line.bbox,
+                source.page_size,
+                candidate.angle,
+            )
+            gap = grid_bbox[1] - local_bbox[3]
+            if (
+                local_bbox[3] <= grid_bbox[1] + 0.25 * median_height
+                and -0.25 * median_height <= gap <= 3.0 * median_height
+                and _bbox_axis_overlap_ratio(
+                    local_bbox,
+                    grid_bbox,
+                    axis="x",
+                )
+                >= 0.8
+            ):
+                continuation_lines.append(
+                    (line, local_bbox),
+                )
+        if len(continuation_lines) != 1:
+            continue
+        continuation_line, continuation_local_bbox = continuation_lines[0]
+        continuation_bbox = continuation_line.bbox
+        existing_caption = next(
+            (annotation for annotation in candidate.annotations if annotation.kind == "caption"),
+            None,
+        )
+        if existing_caption is None:
+            candidate.annotations.append(
+                _TableAnnotation(
+                    kind="caption",
+                    bbox=continuation_bbox,
+                    line_indices={continuation_line.source_index},
+                    line_bboxes={
+                        continuation_line.source_index: continuation_bbox,
+                    },
+                )
+            )
+        else:
+            existing_caption.bbox = _bbox_union(
+                existing_caption.bbox,
+                continuation_bbox,
+            )
+            existing_caption.line_indices.add(
+                continuation_line.source_index,
+            )
+            existing_caption.line_bboxes[continuation_line.source_index] = continuation_bbox
+        candidate.line_indices.discard(
+            continuation_line.source_index,
+        )
+        core_bbox = _rotate_bbox_from_upright(
+            grid_bbox,
+            source.page_size,
+            candidate.angle,
+        )
+        candidate.core_bbox = core_bbox
+        candidate.local_bbox = _bbox_union(
+            grid_bbox,
+            continuation_local_bbox,
+        )
+        candidate.bbox = _bbox_union(
+            core_bbox,
+            continuation_bbox,
+        )

docvortex/analyzers/native/pdf/table_filled_grid.py

@@ -0,0 +1,218 @@
+"""PDF 填充单元格候选；保留原有认领顺序与判定规则。"""
+
+from __future__ import annotations
+from ....schema import BBox
+from ....document.pdf.document import PDFPathInfo
+from .models import _TableCandidate
+from .geometry import (
+    _bbox_area,
+    _bbox_overlap_in_smaller,
+)
+
+from .table_constants import (
+    _FILLED_GRID_MAX_PAGE_AREA_RATIO,
+    _FILLED_GRID_MIN_PAGE_AREA_RATIO,
+    _FILLED_GRID_MIN_PAGE_HEIGHT_RATIO,
+    _FILLED_GRID_MIN_PAGE_WIDTH_RATIO,
+)
+
+
+def _detect_filled_grid_table_candidates(
+    path_infos: list[PDFPathInfo],
+    page_size: tuple[float, float],
+    excluded_bboxes: list[BBox] | None = None,
+) -> list[_TableCandidate]:
+    """仅按根层填充矩形的嵌套行带识别精确表格外框。"""
+
+    page_width, page_height = page_size
+    page_area = page_width * page_height
+    if page_area <= 0:
+        return []
+    excluded_bboxes = excluded_bboxes or []
+    rectangles = [
+        path_info.bbox
+        for path_info in path_infos
+        if path_info.form_depth == 0
+        and path_info.fill_visible
+        and path_info.segment_count == 5
+        and _bbox_area(path_info.bbox) > 0
+    ]
+    evidence: list[tuple[_TableCandidate, int, float, float]] = []
+    for outer_bbox in rectangles:
+        outer_width = outer_bbox[2] - outer_bbox[0]
+        outer_height = outer_bbox[3] - outer_bbox[1]
+        outer_area = _bbox_area(outer_bbox)
+        if not (
+            _FILLED_GRID_MIN_PAGE_AREA_RATIO <= outer_area / page_area <= _FILLED_GRID_MAX_PAGE_AREA_RATIO
+            and outer_width >= _FILLED_GRID_MIN_PAGE_WIDTH_RATIO * page_width
+            and outer_height >= _FILLED_GRID_MIN_PAGE_HEIGHT_RATIO * page_height
+        ):
+            continue
+        if any(_bbox_overlap_in_smaller(outer_bbox, excluded_bbox) >= 0.5 for excluded_bbox in excluded_bboxes):
+            continue
+
+        cells = _select_maximal_filled_grid_cells(rectangles, outer_bbox)
+        bands = _group_filled_grid_cells_into_bands(cells, outer_bbox)
+        accepted_bands = [band for band in bands if _filled_grid_band_covers_outer_width(band, outer_bbox)]
+        if len(accepted_bands) < 4:
+            continue
+        accepted_bands.sort(
+            key=lambda band: (
+                min(cell[1] for cell in band),
+                min(cell[0] for cell in band),
+            )
+        )
+        covered_height = sum(max(cell[3] for cell in band) - min(cell[1] for cell in band) for band in accepted_bands)
+        vertical_coverage = covered_height / outer_height
+        if vertical_coverage < 0.75:
+            continue
+        if any(
+            min(cell[1] for cell in next_band) - max(cell[3] for cell in current_band) > 0.05 * outer_height
+            for current_band, next_band in zip(
+                accepted_bands,
+                accepted_bands[1:],
+            )
+        ):
+            continue
+        candidate = _TableCandidate(
+            bbox=outer_bbox,
+            local_bbox=outer_bbox,
+            angle=0,
+            score=float(100.0 + len(accepted_bands) + vertical_coverage),
+            core_bbox=outer_bbox,
+            line_indices=set(),
+        )
+        evidence.append(
+            (
+                candidate,
+                len(accepted_bands),
+                vertical_coverage,
+                outer_area,
+            )
+        )
+
+    output: list[_TableCandidate] = []
+    for candidate, _band_count, _coverage, _outer_area in sorted(
+        evidence,
+        key=lambda item: (item[1], item[2], item[3]),
+        reverse=True,
+    ):
+        if any(_bbox_overlap_in_smaller(candidate.bbox, accepted.bbox) >= 0.9 for accepted in output):
+            continue
+        output.append(candidate)
+    return sorted(output, key=lambda candidate: (candidate.bbox[1], candidate.bbox[0]))
+
+
+def _select_maximal_filled_grid_cells(
+    rectangles: list[BBox],
+    outer_bbox: BBox,
+) -> list[BBox]:
+    """移除边缘细条、重复 Path 和同跨度半行底纹，保留最大单元格。"""
+
+    outer_width = outer_bbox[2] - outer_bbox[0]
+    outer_height = outer_bbox[3] - outer_bbox[1]
+    outer_area = _bbox_area(outer_bbox)
+    x_tolerance = 0.01 * outer_width
+    y_tolerance = 0.02 * outer_height
+    nested_rectangles = [
+        rectangle
+        for rectangle in rectangles
+        if rectangle != outer_bbox
+        and _bbox_is_contained_with_tolerance(
+            rectangle,
+            outer_bbox,
+            x_tolerance,
+            y_tolerance,
+        )
+        and _bbox_area(rectangle) <= 0.8 * outer_area
+        and rectangle[2] - rectangle[0] >= 0.1 * outer_width
+        and rectangle[3] - rectangle[1] >= 0.06 * outer_height
+    ]
+    output: list[BBox] = []
+    for rectangle in sorted(
+        nested_rectangles,
+        key=lambda bbox: (-_bbox_area(bbox), bbox[1], bbox[0]),
+    ):
+        if any(
+            rectangle != other
+            and _bbox_is_contained_with_tolerance(
+                rectangle,
+                other,
+                x_tolerance,
+                y_tolerance,
+            )
+            and _bbox_area(other) >= 1.08 * _bbox_area(rectangle)
+            and _bbox_area(other) <= 0.8 * outer_area
+            and abs((rectangle[2] - rectangle[0]) - (other[2] - other[0])) <= 0.01 * outer_width
+            for other in nested_rectangles
+        ):
+            continue
+        if any(_bbox_overlap_in_smaller(rectangle, accepted) >= 0.95 for accepted in output):
+            continue
+        output.append(rectangle)
+    return sorted(output, key=lambda bbox: (bbox[1], bbox[0], bbox[3], bbox[2]))
+
+
+def _bbox_is_contained_with_tolerance(
+    inner_bbox: BBox,
+    outer_bbox: BBox,
+    x_tolerance: float,
+    y_tolerance: float,
+) -> bool:
+    """按横纵独立容差判断一个矩形是否完整位于另一个矩形内。"""
+
+    return (
+        inner_bbox[0] >= outer_bbox[0] - x_tolerance
+        and inner_bbox[1] >= outer_bbox[1] - y_tolerance
+        and inner_bbox[2] <= outer_bbox[2] + x_tolerance
+        and inner_bbox[3] <= outer_bbox[3] + y_tolerance
+    )
+
+
+def _group_filled_grid_cells_into_bands(
+    cells: list[BBox],
+    outer_bbox: BBox,
+) -> list[list[BBox]]:
+    """按相近上下边界把最大填充单元格聚成水平行带。"""
+
+    y_tolerance = 0.02 * (outer_bbox[3] - outer_bbox[1])
+    bands: list[list[BBox]] = []
+    for cell in sorted(cells, key=lambda bbox: (bbox[1], bbox[0], bbox[3])):
+        target = next(
+            (band for band in bands if abs(cell[1] - band[0][1]) <= y_tolerance and abs(cell[3] - band[0][3]) <= y_tolerance),
+            None,
+        )
+        if target is None:
+            bands.append([cell])
+        else:
+            target.append(cell)
+    return bands
+
+
+def _filled_grid_band_covers_outer_width(
+    band: list[BBox],
+    outer_bbox: BBox,
+) -> bool:
+    """校验单个填充行带的单元格数量、横向覆盖、间隙和端点。"""
+
+    if len(band) < 2:
+        return False
+    outer_width = outer_bbox[2] - outer_bbox[0]
+    segments = sorted((cell[0], cell[2]) for cell in band)
+    current_left, current_right = segments[0]
+    covered_width = 0.0
+    maximum_gap = 0.0
+    for left, right in segments[1:]:
+        if left <= current_right:
+            current_right = max(current_right, right)
+            continue
+        covered_width += current_right - current_left
+        maximum_gap = max(maximum_gap, left - current_right)
+        current_left, current_right = left, right
+    covered_width += current_right - current_left
+    return (
+        covered_width >= 0.9 * outer_width
+        and maximum_gap <= 0.01 * outer_width
+        and abs(min(cell[0] for cell in band) - outer_bbox[0]) <= 0.02 * outer_width
+        and abs(max(cell[2] for cell in band) - outer_bbox[2]) <= 0.02 * outer_width
+    )

docvortex/analyzers/native/pdf/table_geometry.py

@@ -0,0 +1,40 @@
+"""提供表格恢复与文本投影共享的局部几何，不改变各业务层校验策略。"""
+
+from __future__ import annotations
+
+from ....schema import BBox
+
+
+def normalize_bbox(value: object) -> BBox | None:
+    """把任意四元组规范为有效浮点 bbox，异常或退化框返回空。"""
+
+    try:
+        x0, y0, x1, y1 = [float(item) for item in value]  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return None
+    left, right = sorted((x0, x1))
+    top, bottom = sorted((y0, y1))
+    if right <= left or bottom <= top:
+        return None
+    return left, top, right, bottom
+
+
+def rotate_local_bbox(
+    bbox: BBox,
+    width: float,
+    height: float,
+    angle: int,
+) -> BBox:
+    """把表格裁剪框内 bbox 转换到正向表格局部坐标。"""
+
+    x0, y0, x1, y1 = bbox
+    if angle == 270:
+        return height - y1, x0, height - y0, x1
+    if angle == 90:
+        return y0, width - x1, y1, width - x0
+    if angle == 180:
+        return width - x1, height - y1, width - x0, height - y0
+    return bbox
+
+
+__all__ = ["normalize_bbox", "rotate_local_bbox"]