docvortex 0.2.1__py3-none-any.whl

docvortex/analyzers/native/pdf/table_recovery/geometry.py

@@ -0,0 +1,164 @@
+"""Native PDF 表格结构恢复使用的局部坐标与聚类原语。"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from .....schema import BBox
+from ..table_geometry import normalize_bbox as normalize_bbox, rotate_local_bbox as rotate_local_bbox
+
+
+def normalize_angle(value: object) -> int:
+    """把输入角度限制为表格流程支持的四个标准方向。"""
+
+    try:
+        angle = int(float(value or 0)) % 360
+    except (TypeError, ValueError):
+        return 0
+    return angle if angle in {0, 90, 180, 270} else 0
+
+
+def bbox_area(bbox: BBox) -> float:
+    """返回 bbox 的非负面积。"""
+
+    return max(0.0, float(bbox[2]) - float(bbox[0])) * max(
+        0.0,
+        float(bbox[3]) - float(bbox[1]),
+    )
+
+
+def bbox_union(bboxes: Iterable[BBox]) -> BBox:
+    """返回一组有效 bbox 的最小外接框。"""
+
+    items = list(bboxes)
+    if not items:
+        raise ValueError("bbox union requires at least one bbox")
+    return (
+        min(item[0] for item in items),
+        min(item[1] for item in items),
+        max(item[2] for item in items),
+        max(item[3] for item in items),
+    )
+
+
+def bbox_intersection(first: BBox, second: BBox) -> BBox | None:
+    """返回两个 bbox 的有效交集，无交集时返回空。"""
+
+    intersection = (
+        max(first[0], second[0]),
+        max(first[1], second[1]),
+        min(first[2], second[2]),
+        min(first[3], second[3]),
+    )
+    return intersection if intersection[2] > intersection[0] and intersection[3] > intersection[1] else None
+
+
+def bbox_overlap_ratio(inner: BBox, outer: BBox) -> float:
+    """返回 inner 面积被 outer 覆盖的比例。"""
+
+    area = bbox_area(inner)
+    intersection = bbox_intersection(inner, outer)
+    if area <= 0 or intersection is None:
+        return 0.0
+    return min(1.0, bbox_area(intersection) / area)
+
+
+def bbox_center(bbox: BBox) -> tuple[float, float]:
+    """返回 bbox 的中心坐标。"""
+
+    return (bbox[0] + bbox[2]) / 2.0, (bbox[1] + bbox[3]) / 2.0
+
+
+def page_bbox_to_table_local(
+    bbox: BBox,
+    table_bbox: BBox,
+    angle: int,
+) -> BBox | None:
+    """裁剪页面 bbox 并转换到正向表格局部坐标。"""
+
+    clipped = bbox_intersection(bbox, table_bbox)
+    if clipped is None:
+        return None
+    width = table_bbox[2] - table_bbox[0]
+    height = table_bbox[3] - table_bbox[1]
+    relative = (
+        clipped[0] - table_bbox[0],
+        clipped[1] - table_bbox[1],
+        clipped[2] - table_bbox[0],
+        clipped[3] - table_bbox[1],
+    )
+    return rotate_local_bbox(relative, width, height, angle)
+
+
+def table_local_size(table_bbox: BBox, angle: int) -> tuple[float, float]:
+    """返回旋转到正向后的表格局部宽高。"""
+
+    width = table_bbox[2] - table_bbox[0]
+    height = table_bbox[3] - table_bbox[1]
+    return (height, width) if angle in {90, 270} else (width, height)
+
+
+def clamp(value: float, minimum: float, maximum: float) -> float:
+    """把浮点值限制在闭区间内。"""
+
+    return max(minimum, min(maximum, value))
+
+
+def cluster_positions(values: Iterable[float], tolerance: float) -> list[float]:
+    """按相邻距离聚类一维坐标，并返回各簇均值。"""
+
+    ordered = sorted(float(value) for value in values)
+    if not ordered:
+        return []
+    clusters: list[list[float]] = [[ordered[0]]]
+    for value in ordered[1:]:
+        current_mean = sum(clusters[-1]) / len(clusters[-1])
+        if abs(value - current_mean) <= tolerance:
+            clusters[-1].append(value)
+        else:
+            clusters.append([value])
+    return [sum(cluster) / len(cluster) for cluster in clusters]
+
+
+def covered_interval_ratio(
+    intervals: Iterable[tuple[float, float]],
+    start: float,
+    end: float,
+) -> float:
+    """返回若干区间在目标区间上的并集覆盖比例。"""
+
+    if end <= start:
+        return 0.0
+    clipped = sorted(
+        (max(start, min(first, second)), min(end, max(first, second)))
+        for first, second in intervals
+        if min(end, max(first, second)) > max(start, min(first, second))
+    )
+    if not clipped:
+        return 0.0
+    covered = 0.0
+    current_start, current_end = clipped[0]
+    for item_start, item_end in clipped[1:]:
+        if item_start <= current_end:
+            current_end = max(current_end, item_end)
+            continue
+        covered += current_end - current_start
+        current_start, current_end = item_start, item_end
+    covered += current_end - current_start
+    return min(1.0, covered / (end - start))
+
+
+__all__ = [
+    "bbox_area",
+    "bbox_center",
+    "bbox_intersection",
+    "bbox_overlap_ratio",
+    "bbox_union",
+    "clamp",
+    "cluster_positions",
+    "covered_interval_ratio",
+    "normalize_angle",
+    "normalize_bbox",
+    "page_bbox_to_table_local",
+    "table_local_size",
+]

docvortex/analyzers/native/pdf/table_recovery/sparse_common.py

@@ -0,0 +1,85 @@
+"""共享稀疏表格的坐标聚类和局部物理规则转换，保留两路候选策略。"""
+
+from __future__ import annotations
+
+import statistics
+from dataclasses import dataclass
+
+from .contracts import NativeTableInput
+from .geometry import normalize_angle, normalize_bbox, page_bbox_to_table_local
+
+
+@dataclass(frozen=True, slots=True)
+class _LocalRule:
+    """保存转换到正向表格坐标后的细线区间。"""
+
+    orientation: str
+    coordinate: float
+    start: float
+    end: float
+    width: float
+
+
+def cluster_members(
+    values: list[float],
+    tolerance: float,
+) -> list[tuple[float, tuple[float, ...]]]:
+    """按一维距离聚类坐标并保留每簇原始成员。"""
+
+    if not values:
+        return []
+    clusters: list[list[float]] = [[value] for value in sorted(values)[:1]]
+    for value in sorted(values)[1:]:
+        center = float(statistics.median(clusters[-1]))
+        if abs(value - center) <= tolerance:
+            clusters[-1].append(value)
+        else:
+            clusters.append([value])
+    return [(float(statistics.median(cluster)), tuple(cluster)) for cluster in clusters]
+
+
+def _local_rules(
+    table_input: NativeTableInput,
+    width: float,
+    height: float,
+) -> tuple[_LocalRule, ...]:
+    """把页面 drawing 线转换为按局部长轴重新判向的规则区间。"""
+
+    table_bbox = normalize_bbox(table_input.table_bbox)
+    if table_bbox is None:
+        return ()
+    angle = normalize_angle(table_input.angle)
+    output: list[_LocalRule] = []
+    for rule in table_input.drawing_lines:
+        bbox = normalize_bbox(rule.bbox)
+        if bbox is None:
+            continue
+        local_bbox = page_bbox_to_table_local(bbox, table_bbox, angle)
+        if local_bbox is None:
+            continue
+        local_width = local_bbox[2] - local_bbox[0]
+        local_height = local_bbox[3] - local_bbox[1]
+        if local_width >= max(1.0, 3.0 * max(local_height, 0.1)):
+            output.append(
+                _LocalRule(
+                    orientation="horizontal",
+                    coordinate=(local_bbox[1] + local_bbox[3]) / 2.0,
+                    start=max(0.0, local_bbox[0]),
+                    end=min(width, local_bbox[2]),
+                    width=max(rule.width, local_height),
+                )
+            )
+        elif local_height >= max(1.0, 3.0 * max(local_width, 0.1)):
+            output.append(
+                _LocalRule(
+                    orientation="vertical",
+                    coordinate=(local_bbox[0] + local_bbox[2]) / 2.0,
+                    start=max(0.0, local_bbox[1]),
+                    end=min(height, local_bbox[3]),
+                    width=max(rule.width, local_width),
+                )
+            )
+    return tuple(output)
+
+
+__all__ = ["_LocalRule", "cluster_members", "_local_rules"]