#157 stage 3: OCR table interiors so browser tables fill

The browser scanned path never recognized text inside table regions —
prep_region_lines skips non-text labels and there's no pdfium text layer —
so a detected table had no words for the matcher and rendered empty. Add
ocr_prep::prep_table_words: crop each table region, split into lines, then
split each line into word tokens by a vertical ink-projection profile
(segment_words), and prep each word for recognition with its own page-point
box. The browser add_page now OCRs those word crops and appends them to the
page cells; assemble routes them into the table region (geometric or
TableFormer) instead of stray paragraphs. Word-level boxes are what let the
matcher distribute a row across its columns. Native untouched (it reads
word boxes from pdfium).

Refs #157

Signed-off-by: artiz <artem.kustikov@gmail.com>
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EY5KAiquN4YpVf2PXEQkVT

Author: artiz

crates/docling-pdf/src/ocr_prep.rs

@@ -212,6 +212,99 @@ pub fn prep_region_lines(
     (bboxes, lines)
 }
 
+/// Split a text line into word tokens by a vertical ink-projection profile:
+/// runs of ink columns separated by whitespace wider than ~0.6× the line
+/// height (an inter-word/-column gap, not an inter-character one). Returns tight
+/// `(l, 0, r, h)` boxes in line-crop pixels. The browser table path recognizes
+/// these individually so each word carries its own box for column matching —
+/// the native pipeline gets word boxes from the pdfium text layer instead.
+pub fn segment_words(line: &RgbImage) -> Vec<(u32, u32, u32, u32)> {
+    let (w, h) = line.dimensions();
+    if w == 0 || h == 0 {
+        return Vec::new();
+    }
+    let mean: f32 = line.pixels().map(luma).sum::<f32>() / (w * h) as f32;
+    let thresh = mean * 0.7;
+    let mut col_ink = vec![0u32; w as usize];
+    for y in 0..h {
+        for x in 0..w {
+            if luma(line.get_pixel(x, y)) < thresh {
+                col_ink[x as usize] += 1;
+            }
+        }
+    }
+    let min_gap = ((h as f32) * 0.6).max(4.0) as u32;
+    let mut words = Vec::new();
+    let mut start: Option<u32> = None;
+    let mut last_ink = 0u32;
+    let mut gap = 0u32;
+    for x in 0..w {
+        if col_ink[x as usize] > 0 {
+            if start.is_none() {
+                start = Some(x);
+            }
+            last_ink = x;
+            gap = 0;
+        } else if let Some(s) = start {
+            gap += 1;
+            if gap >= min_gap {
+                words.push((s, 0, last_ink + 1, h));
+                start = None;
+            }
+        }
+    }
+    if let Some(s) = start {
+        words.push((s, 0, last_ink + 1, h));
+    }
+    words
+}
+
+/// Gather word crops from a page's *table* regions (browser table path, #157
+/// stage 3): crop each table region, split it into lines, split each line into
+/// words ([`segment_words`]), prep each word for recognition, and keep the
+/// word's page-point bbox. Recognizing table interiors is what gives the cell
+/// matcher the word boxes it needs — the native pipeline reads those from
+/// pdfium's text layer, which the browser doesn't have. NOT used by native.
+pub fn prep_table_words(
+    img: &RgbImage,
+    regions: &[crate::layout::Region],
+    scale: f32,
+) -> (Vec<LineBox>, Vec<PrepLine>) {
+    let (iw, ih) = img.dimensions();
+    let mut bboxes = Vec::new();
+    let mut lines = Vec::new();
+    for region in regions {
+        if !crate::assemble::is_table_like(region.label) {
+            continue;
+        }
+        let l = (region.l * scale).max(0.0) as u32;
+        let t = (region.t * scale).max(0.0) as u32;
+        let r = ((region.r * scale).max(0.0) as u32).min(iw);
+        let b = ((region.b * scale).max(0.0) as u32).min(ih);
+        if r <= l || b <= t {
+            continue;
+        }
+        let crop = imageops::crop_imm(img, l, t, r - l, b - t).to_image();
+        for (lx, ly, rx, ry) in segment_lines(&crop) {
+            let line = imageops::crop_imm(&crop, lx, ly, rx - lx, ry - ly).to_image();
+            for (wx0, _, wx1, _) in segment_words(&line) {
+                let word = imageops::crop_imm(&line, wx0, 0, wx1 - wx0, ry - ly).to_image();
+                let Some(pl) = prep_line(&word) else {
+                    continue;
+                };
+                bboxes.push((
+                    (l + lx + wx0) as f32 / scale,
+                    (t + ly) as f32 / scale,
+                    (l + lx + wx1) as f32 / scale,
+                    (t + ry) as f32 / scale,
+                ));
+                lines.push(pl);
+            }
+        }
+    }
+    (bboxes, lines)
+}
+
 /// Normalize an image to the scan polarity every stage assumes — dark ink
 /// on light paper (the segmentation threshold and the recognition model's
 /// training data both bake it in): a predominantly dark page (mean luma

crates/docling-wasm/src/scanned.rs

@@ -22,8 +22,8 @@
 
 use docling_pdf::layout::{decode_layout, layout_input, SIDE};
 use docling_pdf::ocr_prep::{
-    batch_input, decode_row, dict_chars, normalize_polarity, prep_region_lines, width_batches,
-    REC_HEIGHT,
+    batch_input, decode_row, dict_chars, normalize_polarity, prep_region_lines, prep_table_words,
+    width_batches, PrepLine, REC_HEIGHT,
 };
 use docling_pdf::pdfium_backend::{PdfPage, TextCell};
 use docling_pdf::scanned::{assemble_page_with_tables, finish_document, refine_regions};
@@ -112,6 +112,33 @@ impl ScannedConverter {
 }
 
 impl ScannedConverter {
+    /// Recognize a set of prepared line/word crops: width-batch them and run
+    /// each batch through the JS recognition session, greedy-CTC-decoding the
+    /// probabilities. Returns one string per input crop, in order.
+    async fn ocr_lines(&self, rec: &RecSession, lines: &[PrepLine]) -> Result<Vec<String>, JsError> {
+        let mut texts = vec![String::new(); lines.len()];
+        for (w, chunk) in width_batches(lines) {
+            let data = batch_input(w, &chunk, lines);
+            let out = rec
+                .run(
+                    chunk.len() as u32,
+                    REC_HEIGHT,
+                    w as u32,
+                    js_sys::Float32Array::from(data.as_slice()),
+                )
+                .await
+                .map_err(|e| JsError::new(&format!("rec session.run: {e:?}")))?;
+            let (probs, t_len, nc) = tensor_parts(&out)?;
+            if probs.len() < chunk.len() * t_len * nc {
+                return Err(JsError::new("rec session.run returned a short tensor"));
+            }
+            for (i, &ix) in chunk.iter().enumerate() {
+                texts[ix] = decode_row(&self.chars, &probs[i * t_len * nc..(i + 1) * t_len * nc], nc);
+            }
+        }
+        Ok(texts)
+    }
+
     #[allow(clippy::too_many_arguments)]
     async fn add_page_impl(
         &mut self,
@@ -168,30 +195,7 @@ impl ScannedConverter {
 
         // OCR the text regions (same gather/batch/decode as native ocr_page).
         let (bboxes, lines) = prep_region_lines(&img, &regions, scale);
-        let mut texts = vec![String::new(); lines.len()];
-        for (w, chunk) in width_batches(&lines) {
-            let data = batch_input(w, &chunk, &lines);
-            let out = rec
-                .run(
-                    chunk.len() as u32,
-                    REC_HEIGHT,
-                    w as u32,
-                    js_sys::Float32Array::from(data.as_slice()),
-                )
-                .await
-                .map_err(|e| JsError::new(&format!("rec session.run: {e:?}")))?;
-            let (probs, t_len, nc) = tensor_parts(&out)?;
-            if probs.len() < chunk.len() * t_len * nc {
-                return Err(JsError::new("rec session.run returned a short tensor"));
-            }
-            for (i, &ix) in chunk.iter().enumerate() {
-                texts[ix] = decode_row(
-                    &self.chars,
-                    &probs[i * t_len * nc..(i + 1) * t_len * nc],
-                    nc,
-                );
-            }
-        }
+        let texts = self.ocr_lines(rec, &lines).await?;
         let mut cells = Vec::new();
         for ((l, t, r, b), text) in bboxes.into_iter().zip(texts) {
             let text = text.trim().to_string();
@@ -201,6 +205,21 @@ impl ScannedConverter {
             cells.push(TextCell { text, l, t, r, b });
         }
 
+        // Table interiors carry no words yet (prep_region_lines skips non-text
+        // labels, and the browser has no pdfium text layer). Recognize their
+        // word crops so the cell matcher — geometric or TableFormer — can fill
+        // the grid; assemble routes these cells into the table region, not into
+        // stray paragraphs.
+        let (tbboxes, tlines) = prep_table_words(&img, &regions, scale);
+        let ttexts = self.ocr_lines(rec, &tlines).await?;
+        for ((l, t, r, b), text) in tbboxes.into_iter().zip(ttexts) {
+            let text = text.trim().to_string();
+            if text.is_empty() {
+                continue;
+            }
+            cells.push(TextCell { text, l, t, r, b });
+        }
+
         // TableFormer (opt-in): resolve each table region's structure through
         // the ONNX graphs + shared matcher; other regions stay `None` (geometric
         // fallback). The lite path passes no session → all geometric.