docling-parse 7.9.0__tar.gz → 7.10.0__tar.gz

{docling_parse-7.9.0 → docling_parse-7.10.0}/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [v7.10.0](https://github.com/docling-project/docling-parse/releases/tag/v7.10.0) - 2026-08-05
+
+### Feature
+
+* Added the rendering-regression with pypdfium ([#305](https://github.com/docling-project/docling-parse/issues/305)) ([`2229782`](https://github.com/docling-project/docling-parse/commit/22297826037cff8582edf31d49174063b273f60c))
+
 ## [v7.9.0](https://github.com/docling-project/docling-parse/releases/tag/v7.9.0) - 2026-08-04
 
 ### Feature

{docling_parse-7.9.0 → docling_parse-7.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.9.0
+Version: 7.10.0
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.9.0 → docling_parse-7.10.0}/app/pybind_parse.cpp

@@ -74,6 +74,7 @@ namespace
       size["type"] = instruction_name(pdflib::SIZE_INSTRUCTION);
       size["media_bbox"] = instr.media_bbox;
       size["crop_bbox"] = instr.crop_bbox;
+      size["angle"] = instr.angle;
       root["size_instruction"] = size;
     }
 

{docling_parse-7.9.0 → docling_parse-7.10.0}/docling_parse.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.9.0
+Version: 7.10.0
 Summary: Simple package to extract text with coordinates from programmatic PDFs
 Author-email: Peter Staar <taa@zurich.ibm.com>, Christoph Auer <cau@zurich.ibm.com>, Michele Dolfi <dol@zurich.ibm.com>, Panos Vagenas <pva@zurich.ibm.com>, Maxim Lysak <mly@zurich.ibm.com>
 License-Expression: MIT

{docling_parse-7.9.0 → docling_parse-7.10.0}/docling_parse.egg-info/SOURCES.txt

@@ -670,6 +670,7 @@ tests/test_embedded_fonts.py
 tests/test_load_failure.py
 tests/test_locale_safety.py
 tests/test_parse.py
+tests/test_pypdfium_render.py
 tests/test_standard_font_widths.py
 tests/test_threaded_parse.py
 tests/test_threaded_render.py

{docling_parse-7.9.0 → docling_parse-7.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.9.0"
+version = "7.10.0"
 description = "Simple package to extract text with coordinates from programmatic PDFs"
 license = "MIT"
 keywords = ["docling", "pdf", "parser"]
@@ -167,7 +167,8 @@ python_version = "3.10"
 module = [
     "tabulate.*",
     "botocore.*",
-    "boto3.*"
+    "boto3.*",
+    "pypdfium2.*"
 ]
 ignore_missing_imports = true
 

{docling_parse-7.9.0 → docling_parse-7.10.0}/src/parse/page_items/page_dimension.h

@@ -291,6 +291,20 @@ namespace pdflib
 	  }
       }
 
+    // A rectangle may be written with any pair of opposite corners, and shall
+    // be normalised so that the first corner is the lower-left one
+    // (ISO 32000-1, 7.9.5). Without this, a page box written top-down has a
+    // negative extent, which propagates into every page size derived from it.
+    if(result[0] > result[2])
+      {
+	std::swap(result[0], result[2]);
+      }
+
+    if(result[1] > result[3])
+      {
+	std::swap(result[1], result[3]);
+      }
+
     return result;
   }
 

{docling_parse-7.9.0 → docling_parse-7.10.0}/src/parse/page_items/render_instructions.h

@@ -156,8 +156,19 @@ namespace pdflib
   public:
     const static RENDER_INSTRUCTION_NAME instr = SIZE_INSTRUCTION;
 
-    std::array<int, 4> media_bbox;
-    std::array<int, 4> crop_bbox;
+    // Page boxes in PDF units (ISO 32000-1, 14.11.2). They are real-valued
+    // rectangles and are kept as written: truncating them to integers both
+    // shifts the page origin and shrinks the page by up to a point, which a
+    // renderer would turn into a misplaced and undersized canvas.
+    std::array<double, 4> media_bbox;
+    std::array<double, 4> crop_bbox;
+
+    // The page's /Rotate value (ISO 32000-1, Table 30): the number of degrees
+    // by which the page shall be rotated clockwise when displayed. The boxes
+    // above are the ones written in the PDF, so they are stated before that
+    // rotation is applied, and so are all following render instructions. A
+    // renderer therefore has to rotate its finished canvas by this angle.
+    int angle = 0;
   };
 
 
@@ -689,7 +700,8 @@ namespace pdflib
     // add instruction methods
 
     void set_size_instruction(std::array<double, 4> media_bbox,
-                              std::array<double, 4> crop_bbox);
+                              std::array<double, 4> crop_bbox,
+                              int angle);
 
     void add_size_instruction(size_instruction& instr);
     void add_text_instruction(text_instruction_type instr);
@@ -727,13 +739,13 @@ namespace pdflib
   };
 
   inline void pdf_render_instructions::set_size_instruction(std::array<double, 4> media_bbox,
-                                                            std::array<double, 4> crop_bbox)
+                                                            std::array<double, 4> crop_bbox,
+                                                            int angle)
   {
-    for(int i = 0; i < 4; i++)
-      {
-        size_instr.media_bbox[i] = static_cast<int>(media_bbox[i]);
-        size_instr.crop_bbox[i] = static_cast<int>(crop_bbox[i]);
-      }
+    size_instr.media_bbox = media_bbox;
+    size_instr.crop_bbox = crop_bbox;
+
+    size_instr.angle = angle;
   }
 
   inline void pdf_render_instructions::add_size_instruction(size_instruction& instr)

{docling_parse-7.9.0 → docling_parse-7.10.0}/src/parse/pdf_decoders/page.h

@@ -914,8 +914,12 @@ namespace pdflib
 
     page_dimension.execute(qpdf_page);
 
+    // The angle is captured here, before rotate_contents() normalizes it away:
+    // the render instructions are emitted in unrotated page space, so the
+    // renderer needs the original /Rotate to orient its canvas.
     instructions.set_size_instruction(page_dimension.get_media_bbox(),
-                                      page_dimension.get_crop_bbox());
+                                      page_dimension.get_crop_bbox(),
+                                      page_dimension.get_angle());
   }
 
   void pdf_decoder<PAGE>::decode_resources(const decode_config& config)

{docling_parse-7.9.0 → docling_parse-7.10.0}/src/render/blend2d_renderer.h

@@ -61,6 +61,12 @@ namespace pdflib
     // Initializes the page canvas from the PDF crop box and render_config. This
     // computes the PDF-to-canvas scale/origin, creates a PRGB32 Blend2D image,
     // starts the page context, and fills the canvas with opaque white.
+    //
+    // All drawing happens in unrotated page space, which is the space the
+    // render instructions are expressed in. When the page carries a /Rotate,
+    // the canvas is allocated in that space (so width and height are swapped
+    // with respect to the reported shape) and the finished canvas is rotated
+    // into display orientation before it leaves the renderer.
     void set_size(size_instruction& instr);
 
     // Renders one text cell into the page canvas. The method converts the PDF
@@ -89,12 +95,14 @@ namespace pdflib
     // axis-aligned rectangular clips. Curve segments render as true cubics.
     void render_shape(shape_instruction& instr);
 
-    // Returns the rendered canvas as RGBA bytes, row-major top-to-bottom.
-    // The associated shape is {height, width, 4}.
+    // Returns the rendered canvas as RGBA bytes, row-major top-to-bottom, in
+    // display orientation. The associated shape is {height, width, 4}.
     std::shared_ptr<std::vector<uint8_t>> get_canvas() const;
 
-    // Returns the current canvas shape as {height, width, channels}. Before
-    // set_size() this is {0, 0, 4}.
+    // Returns the canvas shape in display orientation as {height, width,
+    // channels}. Before set_size() this is {0, 0, 4}. This is the shape the
+    // canvas has once it is handed out, so for a page rotated by 90 or 270
+    // degrees it is already the transpose of the internal drawing canvas.
     const std::array<int, 3>& get_shape() const { return shape_; }
 
     // Save the canvas to a file.  The format is inferred from the extension
@@ -139,12 +147,22 @@ namespace pdflib
     mutable BLImage    image_;  // internal canvas (PRGB32 format)
     mutable BLContext  context_;
     mutable bool       context_active_ = false;
-    std::array<int, 3> shape_;  // {height, width, 4}
+    std::array<int, 3> shape_;  // {height, width, 4}, display orientation
+    int canvas_width_ = 0;     // internal canvas width (unrotated page space)
+    int canvas_height_ = 0;    // internal canvas height (unrotated page space)
     double scale_x_ = 1.0;     // pdf-to-canvas scale along x
     double scale_y_ = 1.0;     // pdf-to-canvas scale along y
     double origin_x_ = 0.0;    // crop_bbox x origin (pdf units)
     double origin_y_ = 0.0;    // crop_bbox y origin (pdf units, y-up)
 
+    // Quarter turns clockwise that take the internal canvas into display
+    // orientation, derived from the page's /Rotate. In [0, 3].
+    int quarter_turns_ = 0;
+
+    // Guards the one-shot canvas rotation, so that repeated canvas access
+    // (get_canvas() followed by save(), for instance) rotates only once.
+    mutable bool rotation_applied_ = false;
+
     std::shared_ptr<blend2d_font_resolver> font_resolver_;
     std::shared_ptr<blend2d_embedded_font_cache> embedded_font_cache_;
     std::shared_ptr<freetype_embedded_font_cache> freetype_font_cache_;
@@ -154,16 +172,33 @@ namespace pdflib
     // necessary. Throws when called before a non-empty canvas has been created.
     BLContext& page_context();
 
-    // Ends the active Blend2D context if one is open. This flushes pending
-    // drawing operations before canvas extraction or file output.
+    // Ends the active Blend2D context if one is open and rotates the finished
+    // canvas into display orientation. This flushes pending drawing operations
+    // before canvas extraction or file output.
     void finish_page_context() const;
 
+    // Rotates the drawing canvas clockwise by quarter_turns_ so that it leaves
+    // the renderer in display orientation. Multiples of 90 degrees permute
+    // pixels exactly, so this neither resamples nor loses precision. Does
+    // nothing for an unrotated page or an already rotated canvas, and must run
+    // only after the Blend2D context has been ended.
+    void apply_page_rotation() const;
+
+    // Number of quarter turns clockwise for a /Rotate angle, normalized to
+    // [0, 3]. Angles that are not a multiple of 90 are not representable in
+    // PDF (ISO 32000-1, Table 30) and are reported and treated as unrotated.
+    static int quarter_turns_from_angle(int angle);
+
+    // True once set_size() has allocated a canvas to draw on.
+    bool has_canvas() const { return canvas_width_ > 0 and canvas_height_ > 0; }
+
     // Convert PDF coordinates (origin at crop_bbox bottom-left, y-up) to
-    // canvas coordinates (origin top-left, y-down), applying scale.
+    // canvas coordinates (origin top-left, y-down), applying scale. These are
+    // coordinates on the internal, unrotated canvas.
     double canvas_x(double pdf_x) const { return (pdf_x - origin_x_) * scale_x_; }
     double canvas_y(double pdf_y) const
     {
-      return static_cast<double>(shape_[0]) - (pdf_y - origin_y_) * scale_y_;
+      return static_cast<double>(canvas_height_) - (pdf_y - origin_y_) * scale_y_;
     }
 
     // Decides whether a text cell should use glyph-bbox fitting when glyph bbox
@@ -711,7 +746,7 @@ namespace pdflib
         return context_;
       }
 
-    if (shape_[0] == 0 or shape_[1] == 0)
+    if (not has_canvas())
       {
         throw std::runtime_error("renderer<BLEND2D>::page_context: canvas is empty");
       }
@@ -730,19 +765,128 @@ namespace pdflib
 
   inline void renderer<BLEND2D>::finish_page_context() const
   {
-    if (not context_active_)
+    if (context_active_)
+      {
+        const BLResult err = context_.end();
+        context_active_ = false;
+        if (err != BL_SUCCESS)
+          {
+            throw std::runtime_error(
+              "renderer<BLEND2D>::finish_page_context: failed to end Blend2D context "
+              "(BLResult=" + std::to_string(err) + ")");
+          }
+      }
+
+    apply_page_rotation();
+  }
+
+  inline int renderer<BLEND2D>::quarter_turns_from_angle(int angle)
+  {
+    int normalised = angle % 360;
+    if (normalised < 0)
+      {
+        normalised += 360;
+      }
+
+    if ((normalised % 90) != 0)
+      {
+        LOG_S(ERROR) << "the /Rotate angle should be a multiple of 90, got: "
+                     << angle << " -> rendering the page unrotated";
+        return 0;
+      }
+
+    return normalised / 90;
+  }
+
+  inline void renderer<BLEND2D>::apply_page_rotation() const
+  {
+    if (rotation_applied_ or quarter_turns_ == 0 or image_.is_empty())
       {
         return;
       }
 
-    const BLResult err = context_.end();
-    context_active_ = false;
-    if (err != BL_SUCCESS)
+    rotation_applied_ = true;
+
+    const int src_w = image_.width();
+    const int src_h = image_.height();
+    if (src_w <= 0 or src_h <= 0)
+      {
+        return;
+      }
+
+    BLImageData src_data;
+    const BLResult src_res = image_.get_data(&src_data);
+    if (src_res != BL_SUCCESS)
       {
         throw std::runtime_error(
-          "renderer<BLEND2D>::finish_page_context: failed to end Blend2D context "
-          "(BLResult=" + std::to_string(err) + ")");
+          "renderer<BLEND2D>::apply_page_rotation: failed to read canvas data "
+          "(BLResult=" + std::to_string(src_res) + ")");
+      }
+
+    const bool transposed = (quarter_turns_ % 2) != 0;
+    const int dst_w = transposed ? src_h : src_w;
+    const int dst_h = transposed ? src_w : src_h;
+
+    BLImage rotated;
+    const BLResult create_res = rotated.create(dst_w, dst_h, BL_FORMAT_PRGB32);
+    if (create_res != BL_SUCCESS)
+      {
+        throw std::runtime_error(
+          "renderer<BLEND2D>::apply_page_rotation: failed to create rotated canvas "
+          "(BLResult=" + std::to_string(create_res) + ")");
+      }
+
+    BLImageData dst_data;
+    const BLResult dst_res = rotated.make_mutable(&dst_data);
+    if (dst_res != BL_SUCCESS)
+      {
+        throw std::runtime_error(
+          "renderer<BLEND2D>::apply_page_rotation: failed to lock rotated canvas "
+          "(BLResult=" + std::to_string(dst_res) + ")");
+      }
+
+    const auto* src_base = static_cast<const uint8_t*>(src_data.pixel_data);
+    auto* dst_base = static_cast<uint8_t*>(dst_data.pixel_data);
+
+    for (int y = 0; y < src_h; ++y)
+      {
+        const auto* src_row =
+          reinterpret_cast<const uint32_t*>(src_base + y * src_data.stride);
+
+        for (int x = 0; x < src_w; ++x)
+          {
+            // clockwise: the source top-left corner moves to the top-right for
+            // one quarter turn, to the bottom-right for two, and so on
+            int dst_x = 0;
+            int dst_y = 0;
+            switch (quarter_turns_)
+              {
+              case 1:
+                dst_x = src_h - 1 - y;
+                dst_y = x;
+                break;
+              case 2:
+                dst_x = src_w - 1 - x;
+                dst_y = src_h - 1 - y;
+                break;
+              default:
+                dst_x = y;
+                dst_y = src_w - 1 - x;
+                break;
+              }
+
+            auto* dst_row =
+              reinterpret_cast<uint32_t*>(dst_base + dst_y * dst_data.stride);
+            dst_row[dst_x] = src_row[x];
+          }
       }
+
+    image_ = rotated;
+
+    LOG_S(INFO) << "apply_page_rotation:"
+                << " quarter_turns=" << quarter_turns_
+                << " canvas=" << src_w << "x" << src_h
+                << " -> " << dst_w << "x" << dst_h;
   }
 
   // ---------------------------------------------------------------------------
@@ -754,24 +898,45 @@ namespace pdflib
     finish_page_context();
 
     const auto& bbox = instr.crop_bbox;
-    const int pdf_w  = bbox[2] - bbox[0];
-    const int pdf_h  = bbox[3] - bbox[1];
+    const double pdf_w = bbox[2] - bbox[0];
+    const double pdf_h = bbox[3] - bbox[1];
+
+    if (pdf_w <= 0.0 or pdf_h <= 0.0) { return; }
 
-    if (pdf_w <= 0 or pdf_h <= 0) { return; }
+    quarter_turns_ = quarter_turns_from_angle(instr.angle);
+    rotation_applied_ = false;
 
-    const auto [width, height] = resolve_canvas_size(pdf_w, pdf_h, config_);
+    // The requested canvas size describes the page as displayed, so it is
+    // resolved against the displayed page size and mapped back onto the
+    // unrotated canvas we actually draw on.
+    const bool transposed = (quarter_turns_ % 2) != 0;
+    const double display_pdf_w = transposed ? pdf_h : pdf_w;
+    const double display_pdf_h = transposed ? pdf_w : pdf_h;
 
+    const auto [display_width, display_height] =
+      resolve_canvas_size(display_pdf_w, display_pdf_h, config_);
+
+    const int width  = transposed ? display_height : display_width;
+    const int height = transposed ? display_width  : display_height;
+
+    // The page box is mapped onto the whole canvas, so the effective scale is
+    // the pixel count over the page extent. Since the canvas covers a
+    // fractional page extent, that is marginally more than the requested scale.
     scale_x_ = static_cast<double>(width)  / pdf_w;
     scale_y_ = static_cast<double>(height) / pdf_h;
-    origin_x_ = static_cast<double>(bbox[0]);
-    origin_y_ = static_cast<double>(bbox[1]);
+    origin_x_ = bbox[0];
+    origin_y_ = bbox[1];
 
-    shape_ = {height, width, 4};
+    canvas_width_ = width;
+    canvas_height_ = height;
+    shape_ = {display_height, display_width, 4};
 
     LOG_S(INFO) << "set_size:"
                 << " crop_bbox=[" << bbox[0] << "," << bbox[1] << "," << bbox[2] << "," << bbox[3] << "]"
                 << " pdf_size=" << pdf_w << "x" << pdf_h
+                << " angle=" << instr.angle
                 << " canvas=" << width << "x" << height
+                << " display=" << display_width << "x" << display_height
                 << " scale=(" << scale_x_ << "," << scale_y_ << ")";
 
     image_.create(width, height, BL_FORMAT_PRGB32);
@@ -1233,7 +1398,7 @@ namespace pdflib
   {
     // LOG_S(INFO) << __FUNCTION__;
 
-    if (shape_[0] == 0 or shape_[1] == 0) { return; }
+    if (not has_canvas()) { return; }
 
     const text_geometry geom = make_text_geometry(instr);
 
@@ -1550,7 +1715,7 @@ namespace pdflib
   {
     LOG_S(INFO) << __FUNCTION__ << " for xobject_key=" << instr.get_key();
 
-    if (shape_[0] == 0 or shape_[1] == 0)
+    if (not has_canvas())
       {
         LOG_S(WARNING) << __FUNCTION__ << ": canvas not initialised, skipping";
         return;
@@ -1702,7 +1867,7 @@ namespace pdflib
   {
     LOG_S(INFO) << __FUNCTION__ << "  text='" << instr.get_text() << "'";
 
-    if (shape_[0] == 0 or shape_[1] == 0) { return; }
+    if (not has_canvas()) { return; }
 
     BLPath path;
     path.move_to(canvas_x(instr.get_r_x0()), canvas_y(instr.get_r_y0()));
@@ -1821,7 +1986,7 @@ namespace pdflib
 
   inline void renderer<BLEND2D>::render_shape(shape_instruction& instr)
   {
-    if (shape_[0] == 0 or shape_[1] == 0) { return; }
+    if (not has_canvas()) { return; }
     if (not config_.render_shapes) { return; }
 
     BLRect bbox;

{docling_parse-7.9.0 → docling_parse-7.10.0}/src/render/config.h

@@ -99,15 +99,30 @@ namespace pdflib
       }
   }
 
+  // Number of pixels needed to cover a page extent expressed in canvas units.
+  // The page box is a real-valued rectangle, so a page of 595.2756 points at
+  // scale 2 needs 1191 pixels, not 1190: rounding down would drop the last
+  // fractional column of the page. Rounding up is also what PDFium does
+  // (FPDF_GetPageWidthF times the scale, rounded up), which keeps our canvas
+  // dimensions identical to a pypdfium2 render of the same page.
+  //
+  // The epsilon absorbs the noise of the box subtraction that produced the
+  // extent, so a page that is an exact 612 x 792 does not gain a pixel from a
+  // 612.0000000000001 arithmetic result.
+  inline int pixels_for_extent(double extent)
+  {
+    return static_cast<int>(std::ceil(extent - 1e-6));
+  }
+
   inline std::pair<int, int> resolve_canvas_size(
-      int pdf_width,
-      int pdf_height,
+      double pdf_width,
+      double pdf_height,
       const render_config& config)
   {
     validate_render_config(config);
 
-    int width = pdf_width;
-    int height = pdf_height;
+    int width = pixels_for_extent(pdf_width);
+    int height = pixels_for_extent(pdf_height);
 
     const bool have_width = config.canvas_width > 0;
     const bool have_height = config.canvas_height > 0;
@@ -115,8 +130,8 @@ namespace pdflib
 
     if(have_scale)
       {
-        width = static_cast<int>(std::round(static_cast<double>(pdf_width) * config.scale));
-        height = static_cast<int>(std::round(static_cast<double>(pdf_height) * config.scale));
+        width = pixels_for_extent(pdf_width * config.scale);
+        height = pixels_for_extent(pdf_height * config.scale);
       }
     else if(have_width and have_height)
       {
@@ -126,14 +141,12 @@ namespace pdflib
     else if(have_width)
       {
         width = config.canvas_width;
-        height = static_cast<int>(
-            std::round(static_cast<double>(pdf_height) * width / pdf_width));
+        height = pixels_for_extent(pdf_height * width / pdf_width);
       }
     else if(have_height)
       {
         height = config.canvas_height;
-        width = static_cast<int>(
-            std::round(static_cast<double>(pdf_width) * height / pdf_height));
+        width = pixels_for_extent(pdf_width * height / pdf_height);
       }
 
     if(width <= 0)

{docling_parse-7.9.0 → docling_parse-7.10.0}/src/render/naive_renderer.h

@@ -48,8 +48,8 @@ namespace pdflib
   {
     auto& bbox = instr.crop_bbox;
 
-    const int pdf_width = bbox[2] - bbox[0];
-    const int pdf_height = bbox[3] - bbox[1];
+    const double pdf_width = bbox[2] - bbox[0];
+    const double pdf_height = bbox[3] - bbox[1];
 
     const auto [width, height] = resolve_canvas_size(pdf_width, pdf_height, config_);