docvortex 0.5.5__tar.gz → 0.5.6__tar.gz

{docvortex-0.5.5 → docvortex-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docvortex
-Version: 0.5.5
+Version: 0.5.6
 Summary: A fast, multi-format document parsing and conversion engine
 License-Expression: MIT
 Project-URL: Repository, https://github.com/myhloli/DocVortex

{docvortex-0.5.5 → docvortex-0.5.6}/rust/docvortex-core/src/lib.rs

@@ -1,6 +1,6 @@
 //! 不访问 Python 对象或 PDFium 的单线程批量计算内核。
 
-pub const PROTOCOL_VERSION: u32 = 23;
+pub const PROTOCOL_VERSION: u32 = 24;
 pub mod columns;
 pub mod note_index;
 pub mod row_geometry;

docvortex-0.5.6/rust/docvortex-pdfium/src/drawing_lines.rs

@@ -0,0 +1,282 @@
+//! 在受支持的简单描边页上批量提取轴向线，复杂对象交由 Python 参考实现。
+
+use crate::{objects, ReadError};
+use std::ffi::{c_float, c_int, c_uint, c_void};
+use std::sync::Mutex;
+use std::time::Instant;
+
+pub type Line = ((f64, f64), (f64, f64), (f64, f64, f64, f64), f64, i32);
+static LAST_STAGE_NS: Mutex<(u64, u64, u64)> = Mutex::new((0, 0, 0));
+
+/// 返回最近一次启用绘图线剖析后的对象读取、线段读取和几何计算纳秒数。
+pub fn stage_stats() -> (u64, u64, u64) {
+    *LAST_STAGE_NS
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner())
+}
+
+type Segment = *mut c_void;
+type Object = *mut c_void;
+type CountFn = unsafe extern "system" fn(Object) -> c_int;
+type GetFn = unsafe extern "system" fn(Object, c_int) -> Segment;
+type PointFn = unsafe extern "system" fn(Segment, *mut c_float, *mut c_float) -> c_int;
+type SegmentFlagFn = unsafe extern "system" fn(Segment) -> c_int;
+type DrawModeFn = unsafe extern "system" fn(Object, *mut c_int, *mut c_int) -> c_int;
+type StrokeColorFn =
+    unsafe extern "system" fn(Object, *mut c_uint, *mut c_uint, *mut c_uint, *mut c_uint) -> c_int;
+type StrokeWidthFn = unsafe extern "system" fn(Object, *mut c_float) -> c_int;
+
+struct Api {
+    count: CountFn,
+    get: GetFn,
+    point: PointFn,
+    kind: SegmentFlagFn,
+    closes: SegmentFlagFn,
+    draw_mode: DrawModeFn,
+    stroke_color: StrokeColorFn,
+    stroke_width: StrokeWidthFn,
+}
+
+/// 按 Python 页面视觉坐标规则变换点，运算顺序与参考路径一致。
+fn visual_point(point: (f64, f64), bbox: [f64; 4], rotation: i32) -> (f64, f64) {
+    let (x, y) = point;
+    let [left, bottom, right, top] = bbox;
+    match rotation {
+        90 => (y - bottom, x - left),
+        180 => (right - x, y - bottom),
+        270 => (top - y, right - x),
+        _ => (x - left, top - y),
+    }
+}
+
+/// 对单个线段应用与 Python `_make_axis_drawing_line` 相同的轴线和页面裁剪判断。
+fn axis_line(
+    raw_start: (f64, f64),
+    raw_end: (f64, f64),
+    stroke_width: f64,
+    bbox: [f64; 4],
+    rotation: i32,
+) -> Option<Line> {
+    let start = visual_point(raw_start, bbox, rotation);
+    let end = visual_point(raw_end, bbox, rotation);
+    let (page_width, page_height) = if rotation == 90 || rotation == 270 {
+        (bbox[3] - bbox[1], bbox[2] - bbox[0])
+    } else {
+        (bbox[2] - bbox[0], bbox[3] - bbox[1])
+    };
+    let (x0, y0) = start;
+    let (x1, y1) = end;
+    if ![x0, y0, x1, y1, stroke_width].iter().all(|v| v.is_finite()) {
+        return None;
+    }
+    let delta_x = (x1 - x0).abs();
+    let delta_y = (y1 - y0).abs();
+    if delta_x >= delta_y && delta_y <= 1.0_f64.max(delta_x * 0.02) {
+        let coordinate = (y0 + y1) / 2.0;
+        if coordinate < 0.0 || coordinate > page_height {
+            return None;
+        }
+        let main_start = 0.0_f64.max(x0.min(x1));
+        let main_end = page_width.min(x0.max(x1));
+        if main_end - main_start < 1.0 {
+            return None;
+        }
+        let width = 0.0_f64.max(stroke_width).max(delta_y);
+        let half_width = width / 2.0;
+        return Some((
+            (main_start, coordinate),
+            (main_end, coordinate),
+            (
+                main_start,
+                0.0_f64.max(coordinate - half_width),
+                main_end,
+                page_height.min(coordinate + half_width),
+            ),
+            width,
+            0,
+        ));
+    }
+    if delta_y > delta_x && delta_x <= 1.0_f64.max(delta_y * 0.02) {
+        let coordinate = (x0 + x1) / 2.0;
+        if coordinate < 0.0 || coordinate > page_width {
+            return None;
+        }
+        let main_start = 0.0_f64.max(y0.min(y1));
+        let main_end = page_height.min(y0.max(y1));
+        if main_end - main_start < 1.0 {
+            return None;
+        }
+        let width = 0.0_f64.max(stroke_width).max(delta_x);
+        let half_width = width / 2.0;
+        return Some((
+            (coordinate, main_start),
+            (coordinate, main_end),
+            (
+                0.0_f64.max(coordinate - half_width),
+                main_start,
+                page_width.min(coordinate + half_width),
+                main_end,
+            ),
+            width,
+            1,
+        ));
+    }
+    None
+}
+
+/// 仅在显式剖析时测量轴线判定，常规路径不增加计时器开销。
+fn measured_axis_line(
+    start: (f64, f64),
+    end: (f64, f64),
+    width: f64,
+    bbox: [f64; 4],
+    rotation: i32,
+    profile: bool,
+    geometry_ns: &mut u64,
+) -> Option<Line> {
+    if !profile {
+        return axis_line(start, end, width, bbox, rotation);
+    }
+    let started = Instant::now();
+    let result = axis_line(start, end, width, bbox, rotation);
+    *geometry_ns += started.elapsed().as_nanos() as u64;
+    result
+}
+
+/// 只在所有 Path 都是无矩阵、无裁剪、无填充的描边时返回原生线；其他页整体回退。
+///
+/// # Safety
+/// 调用方须验证全部 PDFium ABI，持有页面及同库函数引用，并在全局锁内调用。
+pub unsafe fn read_fast_lines(
+    addresses: Vec<usize>,
+    handle: usize,
+    bbox: [f64; 4],
+    rotation: i32,
+) -> Result<Option<Vec<Line>>, ReadError> {
+    if addresses.len() != 19
+        || addresses.contains(&0)
+        || handle == 0
+        || ![0, 90, 180, 270].contains(&rotation)
+    {
+        return Err(ReadError::InvalidInput(
+            "invalid drawing line bridge arguments",
+        ));
+    }
+    if !bbox.iter().all(|value| value.is_finite()) || bbox[2] <= bbox[0] || bbox[3] <= bbox[1] {
+        return Ok(None);
+    }
+    let api = Api {
+        count: std::mem::transmute::<usize, CountFn>(addresses[11]),
+        get: std::mem::transmute::<usize, GetFn>(addresses[12]),
+        point: std::mem::transmute::<usize, PointFn>(addresses[13]),
+        kind: std::mem::transmute::<usize, SegmentFlagFn>(addresses[14]),
+        closes: std::mem::transmute::<usize, SegmentFlagFn>(addresses[15]),
+        draw_mode: std::mem::transmute::<usize, DrawModeFn>(addresses[16]),
+        stroke_color: std::mem::transmute::<usize, StrokeColorFn>(addresses[17]),
+        stroke_width: std::mem::transmute::<usize, StrokeWidthFn>(addresses[18]),
+    };
+    let profile = std::env::var_os("DOCVORTEX_PROFILE_DRAWING_LINES").is_some();
+    let object_started = Instant::now();
+    let objects = objects::read_objects(addresses[..11].to_vec(), handle, 2, 15)?;
+    let object_ns = if profile {
+        object_started.elapsed().as_nanos() as u64
+    } else {
+        0
+    };
+    let path_started = Instant::now();
+    let mut geometry_ns = 0_u64;
+    let mut lines = Vec::new();
+    for (address, matrix, _parent, depth, clip) in objects {
+        if depth != 0 || clip.is_some() || matrix != [1.0, 0.0, 0.0, 1.0, 0.0, 0.0] {
+            return Ok(None);
+        }
+        let raw = address as Object;
+        let (mut fill_mode, mut stroke) = (0, 0);
+        if (api.draw_mode)(raw, &mut fill_mode, &mut stroke) == 0 {
+            continue;
+        }
+        if fill_mode != 0 {
+            return Ok(None);
+        }
+        if stroke == 0 {
+            continue;
+        }
+        let (mut red, mut green, mut blue, mut alpha) = (0, 0, 0, 255);
+        if (api.stroke_color)(raw, &mut red, &mut green, &mut blue, &mut alpha) != 0 && alpha == 0 {
+            continue;
+        }
+        let mut raw_width: c_float = 0.0;
+        let width = if (api.stroke_width)(raw, &mut raw_width) != 0 {
+            let value = f64::from(raw_width).abs();
+            if value.is_finite() {
+                value
+            } else {
+                0.0
+            }
+        } else {
+            0.0
+        };
+        let mut current: Option<(f64, f64)> = None;
+        let mut subpath_start: Option<(f64, f64)> = None;
+        for index in 0..(api.count)(raw).max(0) {
+            let segment = (api.get)(raw, index);
+            if segment.is_null() {
+                continue;
+            }
+            let (mut x, mut y) = (0.0, 0.0);
+            if (api.point)(segment, &mut x, &mut y) == 0 {
+                continue;
+            }
+            let point = (f64::from(x), f64::from(y));
+            let segment_type = (api.kind)(segment);
+            if segment_type == 2 {
+                current = Some(point);
+                subpath_start = Some(point);
+            } else if let Some(previous) = current {
+                if segment_type == 0 {
+                    if let Some(line) = measured_axis_line(
+                        previous,
+                        point,
+                        width,
+                        bbox,
+                        rotation,
+                        profile,
+                        &mut geometry_ns,
+                    ) {
+                        lines.push(line);
+                    }
+                }
+                current = Some(point);
+            } else {
+                current = Some(point);
+                subpath_start = Some(point);
+            }
+            if (api.closes)(segment) != 0 {
+                if let (Some(last), Some(first)) = (current, subpath_start) {
+                    if last != first {
+                        if let Some(line) = measured_axis_line(
+                            last,
+                            first,
+                            width,
+                            bbox,
+                            rotation,
+                            profile,
+                            &mut geometry_ns,
+                        ) {
+                            lines.push(line);
+                        }
+                    }
+                    current = Some(first);
+                }
+            }
+        }
+    }
+    if profile {
+        let segment_ns = (path_started.elapsed().as_nanos() as u64).saturating_sub(geometry_ns);
+        *LAST_STAGE_NS
+            .lock()
+            .unwrap_or_else(|poisoned| poisoned.into_inner()) =
+            (object_ns, segment_ns, geometry_ns);
+    }
+    Ok(Some(lines))
+}

{docvortex-0.5.5 → docvortex-0.5.6}/rust/docvortex-pdfium/src/lib.rs

@@ -2,6 +2,7 @@
 use std::collections::HashMap;
 use std::ffi::{c_double, c_float, c_int, c_uint, c_ulong, c_void};
 pub mod classification;
+pub mod drawing_lines;
 pub mod fonts;
 pub mod objects;
 pub mod paths;

{docvortex-0.5.5 → docvortex-0.5.6}/rust/docvortex-pdfium/src/objects.rs

@@ -134,9 +134,10 @@ impl Api {
                 continue;
             }
             let combined = multiply(matrix.values.map(f64::from), parent);
-            let clip = self.clip_bounds(raw, parent, inherited);
             let object_kind = (self.kind)(raw);
+            // 类型先于裁剪判断：类型不匹配的叶子（如纯路径页上的 Path）不必读 clip。
             if object_kind == 5 {
+                let clip = self.clip_bounds(raw, parent, inherited);
                 self.walk(
                     raw,
                     true,
@@ -148,6 +149,7 @@ impl Api {
                     output,
                 );
             } else if object_kind == kind {
+                let clip = self.clip_bounds(raw, parent, inherited);
                 output.push((raw as usize, combined, parent, depth, clip));
             }
         }

{docvortex-0.5.5 → docvortex-0.5.6}/rust/docvortex-python/src/lib.rs

@@ -80,8 +80,14 @@ fn _native(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_class::<pdfium::PdfiumCharacterBatches>()?;
     module.add_class::<pdfium::PdfiumVisualCharacterBatches>()?;
     module.add_class::<pdfium::PdfiumObjectBatches>()?;
+    module.add_class::<pdfium::PdfiumDrawingLineBatches>()?;
     module.add_function(wrap_pyfunction!(pdfium::read_pdfium_subpaths, module)?)?;
     module.add_function(wrap_pyfunction!(pdfium::read_pdfium_objects, module)?)?;
+    module.add_function(wrap_pyfunction!(pdfium::read_pdfium_drawing_lines, module)?)?;
+    module.add_function(wrap_pyfunction!(
+        pdfium::pdfium_drawing_line_stage_stats,
+        module
+    )?)?;
     module.add_function(wrap_pyfunction!(
         pdfium::read_pdfium_visual_batches,
         module

{docvortex-0.5.5 → docvortex-0.5.6}/rust/docvortex-python/src/pdfium.rs

@@ -96,6 +96,57 @@ pub fn read_pdfium_objects(
     })
 }
 
+/// 按固定批次向 Python 物化轴线数值记录，避免整页同时持有两份大列表。
+#[pyclass(module = "docvortex._native")]
+pub struct PdfiumDrawingLineBatches {
+    records: std::vec::IntoIter<docvortex_pdfium::drawing_lines::Line>,
+}
+
+#[pymethods]
+impl PdfiumDrawingLineBatches {
+    /// 返回当前迭代器以供页面作用域内同步消费。
+    fn __iter__(slf: PyRef<'_, Self>) -> PyRef<'_, Self> {
+        slf
+    }
+
+    /// 每次最多返回 1024 条线，剩余记录仍留在 Rust 内。
+    fn __next__(&mut self) -> Option<Vec<docvortex_pdfium::drawing_lines::Line>> {
+        let records: Vec<_> = self.records.by_ref().take(RECORD_BATCH_SIZE).collect();
+        if records.is_empty() {
+            None
+        } else {
+            Some(records)
+        }
+    }
+}
+
+/// 对简单描边 Path 批量提取轴线；不支持的复杂页返回 None 供参考实现处理。
+#[pyfunction]
+pub fn read_pdfium_drawing_lines(
+    addresses: Vec<usize>,
+    handle: usize,
+    bbox: [f64; 4],
+    rotation: i32,
+) -> PyResult<Option<PdfiumDrawingLineBatches>> {
+    let records = unsafe {
+        docvortex_pdfium::drawing_lines::read_fast_lines(addresses, handle, bbox, rotation)
+    }
+    .map_err(|error| match error {
+        ReadError::InvalidInput(message) => PyValueError::new_err(message),
+        ReadError::Pdfium(message) => PdfiumReadError::new_err(message),
+        ReadError::Allocation(message) => PyMemoryError::new_err(message),
+    })?;
+    Ok(records.map(|items| PdfiumDrawingLineBatches {
+        records: items.into_iter(),
+    }))
+}
+
+/// 暴露最近一次显式剖析的绘图线读取阶段耗时，单位为纳秒。
+#[pyfunction]
+pub fn pdfium_drawing_line_stage_stats() -> (u64, u64, u64) {
+    docvortex_pdfium::drawing_lines::stage_stats()
+}
+
 type VisualRecord = (
     u32,
     f64,

{docvortex-0.5.5 → docvortex-0.5.6}/src/docvortex/_compute_backend.py

@@ -10,7 +10,7 @@ from functools import lru_cache
 from pathlib import Path
 from types import ModuleType
 
-_PROTOCOL_VERSION = 23
+_PROTOCOL_VERSION = 24
 _SELECTED_MODE = None
 _LOAD_FAILURE = None
 

{docvortex-0.5.5 → docvortex-0.5.6}/src/docvortex/analyzers/native/pdf/auxiliary_text.py

@@ -49,6 +49,7 @@ def _classify_page_auxiliary_text(prepared: _PreparedPage) -> None:
         prepared.table_bboxes,
         prepared.drawing_lines,
         prepared.page_size,
+        prepared=prepared,
     )
     prepared.page_footnote_groups += _classify_page_footnotes(
         prepared.remaining_lines,
@@ -56,6 +57,7 @@ def _classify_page_auxiliary_text(prepared: _PreparedPage) -> None:
         prepared.drawing_lines,
         prepared.page_size,
         visual_bboxes=[block["bbox"] for block in prepared.fixed_blocks if block.get("type") == "image"],
+        prepared=prepared,
     )
 
 
@@ -163,6 +165,7 @@ def _classify_image_footnotes(
     page_size: tuple[float, float],
     *,
     reference_body_height: float | None = None,
+    prepared: _PreparedPage | None = None,
 ) -> None:
     """用图片、下缘长横线和紧凑小字的联合关系识别图表脚注。"""
 
@@ -202,12 +205,11 @@ def _classify_image_footnotes(
             body_samples = [_line_effective_height(line, bbox) for line, bbox in line_geometry]
         body_height = max(0.1, statistics.median(body_samples))
     local_images = [_rotate_bbox_to_upright(bbox, page_size, dominant_angle) for bbox in image_bboxes]
-    local_axis_lines = _transform_axis_lines(
-        drawing_lines,
-        page_size,
-        dominant_angle,
-    )
-
+    if prepared is None:
+        local_axis_lines = _transform_axis_lines(drawing_lines, page_size, dominant_angle)
+        table_lines = _confirmed_table_horizontal_lines(local_axis_lines, table_bboxes)
+    else:
+        local_axis_lines, table_lines = _prepared_local_axis_table_lines(prepared, dominant_angle)
     matched_source_indices: set[int] = set()
     for image_bbox in local_images:
         image_width = max(0.1, image_bbox[2] - image_bbox[0])
@@ -229,8 +231,7 @@ def _classify_image_footnotes(
             and 0.0 <= axis_line.bbox[1] - row_bottom <= max(0.01 * local_page_height, 0.75 * body_height)
             and not _rule_belongs_to_confirmed_table(
                 axis_line,
-                local_axis_lines,
-                table_bboxes,
+                table_lines,
                 local_page_width,
             )
         ]
@@ -270,6 +271,7 @@ def _classify_deferred_image_footnotes(
             prepared.drawing_lines,
             prepared.page_size,
             reference_body_height=body_height,
+            prepared=prepared,
         )
 
 
@@ -361,6 +363,7 @@ def _classify_page_footnotes(
     page_size: tuple[float, float],
     *,
     visual_bboxes: list[BBox] | None = None,
+    prepared: _PreparedPage | None = None,
 ) -> list[set[int]]:
     """识别主方向页脚注，并按触发分隔线返回来源编号分组。"""
 
@@ -401,11 +404,11 @@ def _classify_page_footnotes(
         # 脚注分隔线应对齐稳定栏锚点，不能被页眉或跨栏关键词的宽行扩张污染。
         recalculate_intervals=False,
     )
-    local_axis_lines = _transform_axis_lines(
-        drawing_lines,
-        page_size,
-        dominant_angle,
-    )
+    if prepared is None:
+        local_axis_lines = _transform_axis_lines(drawing_lines, page_size, dominant_angle)
+        table_lines = _confirmed_table_horizontal_lines(local_axis_lines, table_bboxes)
+    else:
+        local_axis_lines, table_lines = _prepared_local_axis_table_lines(prepared, dominant_angle)
 
     candidate_groups: list[set[int]] = []
     visual_bboxes = visual_bboxes or []
@@ -435,8 +438,7 @@ def _classify_page_footnotes(
         # 表格边界会产生断裂横线；除框内线段外，也排除与其同高且近邻的框外线段。
         if _rule_belongs_to_confirmed_table(
             axis_line,
-            local_axis_lines,
-            table_bboxes,
+            table_lines,
             local_page_width,
         ):
             continue
@@ -535,29 +537,52 @@ def _augment_footnote_groups_with_edge_markers(
                 group.add(line.source_index)
 
 
-def _rule_belongs_to_confirmed_table(
-    candidate: _LocalAxisLine,
+def _prepared_local_axis_table_lines(
+    prepared: _PreparedPage,
+    dominant_angle: int,
+) -> tuple[list[_LocalAxisLine], list[_LocalAxisLine]]:
+    """按页和主方向复用轴线变换及确认表格横线，输入身份变化时重新计算。"""
+
+    key = (dominant_angle, id(prepared.drawing_lines), id(prepared.table_bboxes))
+    cached = prepared.local_axis_table_cache.get(key)
+    if cached is not None:
+        return cached
+    local_axis_lines = _transform_axis_lines(prepared.drawing_lines, prepared.page_size, dominant_angle)
+    table_lines = _confirmed_table_horizontal_lines(local_axis_lines, prepared.table_bboxes)
+    result = (local_axis_lines, table_lines)
+    prepared.local_axis_table_cache[key] = result
+    return result
+
+
+def _confirmed_table_horizontal_lines(
     local_axis_lines: list[_LocalAxisLine],
     table_bboxes: list[BBox],
+) -> list[_LocalAxisLine]:
+    """按页预计算与确认表格框相交的横线，供所有候选排除判断复用。"""
+
+    return [
+        table_line
+        for table_line in local_axis_lines
+        if table_line.orientation == "horizontal"
+        and any(
+            _bbox_intersects(
+                _expand_bbox(table_line.original_bbox, max(0.5, table_line.width)),
+                table_bbox,
+            )
+            for table_bbox in table_bboxes
+        )
+    ]
+
+
+def _rule_belongs_to_confirmed_table(
+    candidate: _LocalAxisLine,
+    table_lines: list[_LocalAxisLine],
     local_page_width: float,
 ) -> bool:
     """把表格框内横线及其同高近邻断裂段一并排除，避免框外残段触发脚注。"""
 
-    if not table_bboxes:
-        return False
     maximum_segment_gap = 0.04 * local_page_width
-    for table_line in local_axis_lines:
-        if table_line.orientation != "horizontal":
-            continue
-        table_margin = max(0.5, table_line.width)
-        if not any(
-            _bbox_intersects(
-                _expand_bbox(table_line.original_bbox, table_margin),
-                table_bbox,
-            )
-            for table_bbox in table_bboxes
-        ):
-            continue
+    for table_line in table_lines:
         center_tolerance = max(1.0, candidate.width, table_line.width)
         if abs(_bbox_center_y(candidate.bbox) - _bbox_center_y(table_line.bbox)) > center_tolerance:
             continue
@@ -800,11 +825,7 @@ def _classify_rule_delimited_headers(pages: list[_PreparedPage]) -> None:
         ]
         heights = [_line_effective_height(line, bbox) for line, bbox in local_lines]
         median_height = statistics.median(heights) if heights else 1.0
-        local_axis_lines = _transform_axis_lines(
-            page.drawing_lines,
-            page.page_size,
-            dominant_angle,
-        )
+        local_axis_lines, table_lines = _prepared_local_axis_table_lines(page, dominant_angle)
         candidates = [
             axis_line
             for axis_line in local_axis_lines
@@ -814,8 +835,7 @@ def _classify_rule_delimited_headers(pages: list[_PreparedPage]) -> None:
             and any(bbox[3] <= _bbox_center_y(axis_line.bbox) for bbox in header_evidence_bboxes)
             and not _rule_belongs_to_confirmed_table(
                 axis_line,
-                local_axis_lines,
-                page.table_bboxes,
+                table_lines,
                 local_page_width,
             )
             and not _rule_overlaps_fixed_container(
@@ -856,11 +876,7 @@ def _classify_rule_delimited_footers(pages: list[_PreparedPage]) -> None:
         local_page_width, local_page_height = local_page_size
         if local_page_width <= 0 or local_page_height <= 0:
             continue
-        local_axis_lines = _transform_axis_lines(
-            page.drawing_lines,
-            page.page_size,
-            dominant_angle,
-        )
+        local_axis_lines, table_lines = _prepared_local_axis_table_lines(page, dominant_angle)
         rules = [
             rule
             for rule in local_axis_lines
@@ -869,8 +885,7 @@ def _classify_rule_delimited_footers(pages: list[_PreparedPage]) -> None:
             and rule.bbox[2] - rule.bbox[0] >= 0.2 * local_page_width
             and not _rule_belongs_to_confirmed_table(
                 rule,
-                local_axis_lines,
-                page.table_bboxes,
+                table_lines,
                 local_page_width,
             )
             and not _rule_overlaps_fixed_container(