feat(tableformer): replicate docling's table-crop preprocessing (page→1024px→bbox→448)

The decode is byte-exact on docling's input tensor; the live pipeline must feed
the same pixels. docling resizes the whole page to 1024px height (cv2.INTER_AREA),
crops the table bbox out of that, then resizes the crop to 448² (bilinear). The
tf_otsl example now does the page→1024px (box-average) crop, and predict_otsl's
448 resize is bilinear, matching docling's two distinct interpolations.

This lands the correct method and confirms the crop geometry matches docling
(434×172px bbox at the same position on 2305v1-pg9). It does NOT yet reproduce
docling's OTSL live: the model is hyper-sensitive to exact pixels, and matching
docling's full raster pipeline byte-for-byte across different libraries (pdfium
render anti-aliasing, cv2 INTER_AREA, torchvision bilinear) is a separate, hard
parity problem — different filter choices swing the token count (54 target vs
88/121 observed). Recorded as the gating step in PDF_CONFORMANCE.md before
OTSL→grid, cell matching, and serialization.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: artiz

crates/fleischwolf-pdf/examples/tf_otsl.rs

@@ -31,13 +31,19 @@ fn main() {
         let regions = layout
             .predict(&page.image, page.width, page.height)
             .expect("layout");
+        // docling resizes the whole page to 1024px height, then crops the table
+        // bbox out of *that*. Replicate so the model sees the same pixels.
+        let sf = 1024.0 / page.image.height() as f32;
+        let pw1024 = (page.image.width() as f32 * sf).round() as u32;
+        let page1024 = imageops::thumbnail(&page.image, pw1024, 1024);
         for r in regions.iter().filter(|r| r.label == "table") {
-            let s = page.scale;
-            let x = (r.l * s).max(0.0) as u32;
-            let y = (r.t * s).max(0.0) as u32;
-            let w = ((r.r - r.l) * s) as u32;
-            let h = ((r.b - r.t) * s) as u32;
-            let crop = imageops::crop_imm(&page.image, x, y, w, h).to_image();
+            // bbox (points) → 1024px-page coords: scale*sf = 1024/page_h_pt.
+            let k = 1024.0 / page.height;
+            let x = (r.l * k).max(0.0) as u32;
+            let y = (r.t * k).max(0.0) as u32;
+            let w = ((r.r - r.l) * k) as u32;
+            let h = ((r.b - r.t) * k) as u32;
+            let crop = imageops::crop_imm(&page1024, x, y, w, h).to_image();
             let otsl = tf.predict_otsl(&crop).expect("predict");
             let rows = otsl.iter().filter(|&&t| t == 9).count();
             let cols = otsl.iter().take_while(|&&t| t != 9).count();

crates/fleischwolf-pdf/src/tableformer.rs

@@ -4,7 +4,6 @@
 //! autoregressively to emit an OTSL structure-token sequence (the same model
 //! docling runs). See PDF_CONFORMANCE.md.
 
-use image::imageops::FilterType;
 use image::RgbImage;
 use ort::session::Session;
 use ort::value::Tensor;
@@ -65,7 +64,10 @@ impl TableFormer {
     /// Predict the OTSL structure-token sequence for a table-region image.
     pub fn predict_otsl(&mut self, img: &RgbImage) -> Result<Vec<i64>, String> {
         // Preprocess: resize to 448², normalize per channel, lay out CHW.
-        let resized = image::imageops::resize(img, SIDE, SIDE, FilterType::Triangle);
+        // docling's final 448 resize is BILINEAR (the page→1024px step that
+        // box-averages happens earlier, in the caller).
+        let resized =
+            image::imageops::resize(img, SIDE, SIDE, image::imageops::FilterType::Triangle);
         let n = (SIDE * SIDE) as usize;
         let mut data = vec![0f32; 3 * n];
         for (i, px) in resized.pixels().enumerate() {