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

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

@@ -1,3 +1,16 @@
+## [v7.11.0](https://github.com/docling-project/docling-parse/releases/tag/v7.11.0) - 2026-08-07
+
+### Feature
+
+* Improve PDF rendering fidelity across color, image, transparency, and writing-mode cases ([#307](https://github.com/docling-project/docling-parse/issues/307)) ([`bc55397`](https://github.com/docling-project/docling-parse/commit/bc55397a19bcf22df50d0a45e0aa147c8b44521f))
+* Render PDF shadings (sh), parse the full ExtGState, and add rendering quality benchmarks ([#306](https://github.com/docling-project/docling-parse/issues/306)) ([`ee2e265`](https://github.com/docling-project/docling-parse/commit/ee2e265c38e1632eaee3319355e766cca5cdceda))
+
+## [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.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.9.0
+Version: 7.11.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.11.0}/app/analyse.cpp

@@ -40,6 +40,7 @@ struct yellow_box_inspector
   void render_text(pdflib::text_instruction&)           {}
   void render_widget(pdflib::text_widget_instruction&)  {}
   void render_shape(pdflib::shape_instruction&)         {}
+  void render_shading(pdflib::shading_instruction&)     {}
 
   void render_bitmap(pdflib::bitmap_instruction& instr)
   {

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

@@ -37,6 +37,7 @@ namespace
       case pdflib::TEXT_WIDGET_RENDER_INSTRUCTION: return "widget";
       case pdflib::BITMAP_RENDER_INSTRUCTION: return "bitmap";
       case pdflib::SHAPE_RENDER_INSTRUCTION: return "shape";
+      case pdflib::SHADING_RENDER_INSTRUCTION: return "shading";
       default: return "unknown";
       }
   }
@@ -74,6 +75,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;
     }
 
@@ -190,6 +192,33 @@ namespace
       row["fill_alpha"] = instr.get_fill_alpha();
       instructions.append(row);
     }
+
+    void render_shading(pdflib::shading_instruction& instr)
+    {
+      pybind11::dict row;
+      row["type"] = instruction_name(pdflib::SHADING_RENDER_INSTRUCTION);
+      row["shading_key"] = instr.get_key();
+      row["geometry"] = static_cast<int>(instr.get_geometry());
+      row["coords"] = instr.get_coords();
+      row["matrix"] = instr.get_matrix();
+      row["extend_start"] = instr.get_extend_start();
+      row["extend_end"] = instr.get_extend_end();
+      row["fill_alpha"] = instr.get_fill_alpha();
+
+      // The colour ramp is a fixed-resolution resampling; only its endpoints
+      // and its length are stable enough to be worth exporting.
+      pybind11::list stops;
+      for(const auto& stop : instr.get_stops())
+        {
+          pybind11::dict entry;
+          entry["offset"] = stop.get_offset();
+          entry["rgb"] = stop.get_rgb();
+          stops.append(entry);
+        }
+      row["stops"] = stops;
+
+      instructions.append(row);
+    }
   };
 
   struct bitmap_artifact_export_visitor
@@ -201,6 +230,7 @@ namespace
     void render_text(pdflib::text_instruction&) {}
     void render_widget(pdflib::text_widget_instruction&) {}
     void render_shape(pdflib::shape_instruction&) {}
+    void render_shading(pdflib::shading_instruction&) {}
 
     void render_bitmap(pdflib::bitmap_instruction& instr)
     {
@@ -1108,8 +1138,11 @@ PYBIND11_MODULE(pdf_parsers, m) {
 
     Attributes:
         render_text (bool): Render glyph outlines for text cells [default=true].
+        min_stroke_width (float): Minimum stroke width in device pixels for hairlines and sub-pixel vector strokes [default=1.0].
         draw_text_bbox (bool): Draw bounding quad for each text cell [default=false].
         draw_text_basepoint (bool): Draw the text baseline origin as a small red dot [default=false].
+        display_widgets (bool): Draw the bounds of each widget (form-field) annotation as a translucent overlay; the field content itself is rendered regardless [default=false].
+        color_widgets (list[int]): RGB triple (0-255) for the widget overlay [default=[0, 153, 255]].
         fit_glyph_bbox_to_target (bool): Uniformly rescale measured glyph outlines so the rendered bbox fits inside the target glyph bbox, with either width or height matching exactly [default=false].
         resolve_fonts (bool): Resolve PDF font names to system fonts [default=true].
         use_embedded_fonts (bool): Prefer embedded font programs (TrueType/OpenType via Blend2D, Type 1/CFF via FreeType outlines) over system font resolution [default=true].
@@ -1120,8 +1153,11 @@ PYBIND11_MODULE(pdf_parsers, m) {
     )")
     .def(pybind11::init<>())
     .def_readwrite("render_text",             &pdflib::render_config::render_text)
+    .def_readwrite("min_stroke_width",        &pdflib::render_config::min_stroke_width)
     .def_readwrite("draw_text_bbox",          &pdflib::render_config::draw_text_bbox)
     .def_readwrite("draw_text_basepoint",     &pdflib::render_config::draw_text_basepoint)
+    .def_readwrite("display_widgets",         &pdflib::render_config::display_widgets)
+    .def_readwrite("color_widgets",           &pdflib::render_config::color_widgets)
     .def_readwrite("fit_glyph_bbox_to_target",&pdflib::render_config::fit_glyph_bbox_to_target)
     .def_readwrite("resolve_fonts",           &pdflib::render_config::resolve_fonts)
     .def_readwrite("use_embedded_fonts",      &pdflib::render_config::use_embedded_fonts)

{docling_parse-7.9.0 → docling_parse-7.11.0}/app/render.cpp

@@ -211,8 +211,11 @@ int main(int argc, char* argv[])
 
         // ---- render_config ----
         ("render-text",    "Render glyph outlines for text cells (default: true)",          cxxopts::value<bool>()->implicit_value("true"))
+        ("min-stroke-width", "Minimum stroke width in device pixels for hairlines and sub-pixel vector strokes (default: 1.0)", cxxopts::value<float>())
         ("draw-text-bbox", "Draw bounding quad around each text cell",                      cxxopts::value<bool>()->implicit_value("true"))
         ("draw-text-basepoint", "Draw the text base point as a small red dot",              cxxopts::value<bool>()->implicit_value("true"))
+        ("display-widgets", "Draw the bounds of each widget (form-field) annotation",       cxxopts::value<bool>()->implicit_value("true"))
+        ("color-widgets",  "RGB triple (0-255) for the widget overlay, e.g. 0,153,255",     cxxopts::value<std::vector<int>>())
         ("fit-glyph-bbox-to-target",
          "Uniformly rescale measured glyph outlines so the rendered bbox fits inside the target glyph bbox and matches either its width or height",
          cxxopts::value<bool>()->implicit_value("true"))
@@ -317,8 +320,20 @@ int main(int argc, char* argv[])
       // --- render_config ---
       pdflib::render_config cfg;
       if (result.count("render-text"))    { cfg.render_text    = result["render-text"].as<bool>(); }
+      if (result.count("min-stroke-width")) { cfg.min_stroke_width = result["min-stroke-width"].as<float>(); }
       if (result.count("draw-text-bbox")) { cfg.draw_text_bbox = result["draw-text-bbox"].as<bool>(); }
       if (result.count("draw-text-basepoint")) { cfg.draw_text_basepoint = result["draw-text-basepoint"].as<bool>(); }
+      if (result.count("display-widgets")) { cfg.display_widgets = result["display-widgets"].as<bool>(); }
+      if (result.count("color-widgets"))
+        {
+          auto rgb = result["color-widgets"].as<std::vector<int>>();
+          if (rgb.size() != 3)
+            {
+              LOG_F(ERROR, "--color-widgets expects three comma-separated values (R,G,B).");
+              return 1;
+            }
+          cfg.color_widgets = {rgb[0], rgb[1], rgb[2]};
+        }
       if (result.count("fit-glyph-bbox-to-target")) { cfg.fit_glyph_bbox_to_target = result["fit-glyph-bbox-to-target"].as<bool>(); }
       if (result.count("resolve-fonts"))          { cfg.resolve_fonts          = result["resolve-fonts"].as<bool>(); }
       if (result.count("font-similarity-cutoff")) { cfg.font_similarity_cutoff = result["font-similarity-cutoff"].as<float>(); }

{docling_parse-7.9.0 → docling_parse-7.11.0}/app/run_scaling.cpp

@@ -313,8 +313,10 @@ namespace
   {
     pdflib::render_config config;
     config.render_text = true;
+    config.min_stroke_width = 1.0f;
     config.draw_text_bbox = false;
     config.draw_text_basepoint = false;
+    config.display_widgets = false;
     config.fit_glyph_bbox_to_target = false;
     config.resolve_fonts = true;
     config.font_similarity_cutoff = 0.75f;
@@ -760,8 +762,10 @@ namespace
               << std::setw(32) << "parameter" << "value\n"
               << std::string(44, '-') << "\n"
               << std::setw(32) << "render_text" << config.render_text << "\n"
+              << std::setw(32) << "min_stroke_width" << config.min_stroke_width << "\n"
               << std::setw(32) << "draw_text_bbox" << config.draw_text_bbox << "\n"
               << std::setw(32) << "draw_text_basepoint" << config.draw_text_basepoint << "\n"
+              << std::setw(32) << "display_widgets" << config.display_widgets << "\n"
               << std::setw(32) << "fit_glyph_bbox_to_target" << config.fit_glyph_bbox_to_target << "\n"
               << std::setw(32) << "resolve_fonts" << config.resolve_fonts << "\n"
               << std::setw(32) << "font_similarity_cutoff" << config.font_similarity_cutoff << "\n"

{docling_parse-7.9.0 → docling_parse-7.11.0}/docling_parse/pdf_parser.py

@@ -1416,6 +1416,7 @@ class PageParseResult:
 def _copy_render_config(src: RenderConfig) -> RenderConfig:
     dst = RenderConfig()
     dst.render_text = src.render_text
+    dst.min_stroke_width = src.min_stroke_width
     dst.draw_text_bbox = src.draw_text_bbox
     dst.resolve_fonts = src.resolve_fonts
     dst.use_embedded_fonts = src.use_embedded_fonts
@@ -1437,6 +1438,8 @@ def _validate_render_config(src: RenderConfig) -> None:
         raise ValueError("render_config.canvas_width must be > 0 or -1")
     if src.canvas_height != -1 and src.canvas_height <= 0:
         raise ValueError("render_config.canvas_height must be > 0 or -1")
+    if src.min_stroke_width < 0:
+        raise ValueError("render_config.min_stroke_width must be >= 0")
     if have_scale and (have_width or have_height):
         raise ValueError(
             "render_config.scale cannot be combined with canvas_width or canvas_height"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.9.0
+Version: 7.11.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.11.0}/docling_parse.egg-info/SOURCES.txt

@@ -523,10 +523,13 @@ src/parse/pdf_resources/page_font.h
 src/parse/pdf_resources/page_fonts.h
 src/parse/pdf_resources/page_grph.h
 src/parse/pdf_resources/page_grphs.h
+src/parse/pdf_resources/page_shading.h
+src/parse/pdf_resources/page_shadings.h
 src/parse/pdf_resources/page_xobject_form.h
 src/parse/pdf_resources/page_xobject_image.h
 src/parse/pdf_resources/page_xobject_postscript.h
 src/parse/pdf_resources/page_xobjects.h
+src/parse/pdf_resources/pdf_function.h
 src/parse/pdf_resources/page_font/base_font.h
 src/parse/pdf_resources/page_font/base_fonts.h
 src/parse/pdf_resources/page_font/char_description.h
@@ -560,6 +563,7 @@ src/parse/utils/timer.h
 src/parse/utils/values.h
 src/parse/utils/bitmap/bitmap_exporter.h
 src/parse/utils/ccitt/ccitt_utils.h
+src/parse/utils/color/device_cmyk.h
 src/parse/utils/color/icc_utils.h
 src/parse/utils/jpeg/jpeg_utils.h
 src/parse/utils/jpx/jpx_utils.h
@@ -666,11 +670,16 @@ tests/constants.py
 tests/data_utils.py
 tests/rendering_regression.py
 tests/test_actual_text.py
+tests/test_colorspace.py
 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_shading.py
 tests/test_standard_font_widths.py
 tests/test_threaded_parse.py
 tests/test_threaded_render.py
+tests/test_transparency.py
+tests/test_vertical_writing.py
 tests/update_groundtruth.py

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

@@ -1,6 +1,6 @@
 [project]
 name = "docling-parse"
-version = "7.9.0"
+version = "7.11.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.11.0}/src/parse/enums.h

@@ -217,12 +217,143 @@ namespace pdflib
     COLOR_SPACE_LAB,        // Lab (approximated by its L* component)
 
     COLOR_SPACE_INDEXED,    // palette lookup into a base space
-    COLOR_SPACE_SEPARATION, // single tint (tint transform not evaluated)
-    COLOR_SPACE_DEVICE_N,   // multiple tints (tint transform not evaluated)
+    COLOR_SPACE_SEPARATION, // single tint, through a tint transform
+    COLOR_SPACE_DEVICE_N,   // multiple tints, through a tint transform
 
     COLOR_SPACE_PATTERN
   };
 
+  // The /ShadingType of a shading dictionary (Table 78). Only the axial and
+  // radial types are painted; the others are recognised so that an
+  // unsupported shading is reported by name instead of dropped silently.
+  enum shading_type_name {
+    SHADING_UNKNOWN               = 0,
+    SHADING_FUNCTION_BASED        = 1,
+    SHADING_AXIAL                 = 2,
+    SHADING_RADIAL                = 3,
+    SHADING_FREE_FORM_GOURAUD     = 4,
+    SHADING_LATTICE_FORM_GOURAUD  = 5,
+    SHADING_COONS_PATCH           = 6,
+    SHADING_TENSOR_PATCH          = 7,
+  };
+
+  std::string to_string(shading_type_name name)
+  {
+    switch(name)
+      {
+      case SHADING_FUNCTION_BASED:       { return "function-based (1)"; }
+      case SHADING_AXIAL:                { return "axial (2)"; }
+      case SHADING_RADIAL:               { return "radial (3)"; }
+      case SHADING_FREE_FORM_GOURAUD:    { return "free-form Gouraud triangle mesh (4)"; }
+      case SHADING_LATTICE_FORM_GOURAUD: { return "lattice-form Gouraud triangle mesh (5)"; }
+      case SHADING_COONS_PATCH:          { return "Coons patch mesh (6)"; }
+      case SHADING_TENSOR_PATCH:         { return "tensor-product patch mesh (7)"; }
+
+      default: { return "unknown (0)"; }
+      }
+  }
+
+  shading_type_name to_shading_type_name(int type)
+  {
+    switch(type)
+      {
+      case 1: { return SHADING_FUNCTION_BASED; }
+      case 2: { return SHADING_AXIAL; }
+      case 3: { return SHADING_RADIAL; }
+      case 4: { return SHADING_FREE_FORM_GOURAUD; }
+      case 5: { return SHADING_LATTICE_FORM_GOURAUD; }
+      case 6: { return SHADING_COONS_PATCH; }
+      case 7: { return SHADING_TENSOR_PATCH; }
+
+      default: { return SHADING_UNKNOWN; }
+      }
+  }
+
+  // Blend modes of an ExtGState /BM entry (11.3.5). The separable modes are
+  // composited; the four non-separable ones (Table 137) are parsed so that
+  // documents relying on them are identifiable instead of silently rendered
+  // as Normal.
+  enum blend_mode_name {
+    BLEND_MODE_UNKNOWN,
+
+    // separable blend modes (Table 136)
+    BLEND_MODE_NORMAL,
+    BLEND_MODE_MULTIPLY,
+    BLEND_MODE_SCREEN,
+    BLEND_MODE_OVERLAY,
+    BLEND_MODE_DARKEN,
+    BLEND_MODE_LIGHTEN,
+    BLEND_MODE_COLOR_DODGE,
+    BLEND_MODE_COLOR_BURN,
+    BLEND_MODE_HARD_LIGHT,
+    BLEND_MODE_SOFT_LIGHT,
+    BLEND_MODE_DIFFERENCE,
+    BLEND_MODE_EXCLUSION,
+
+    // non-separable blend modes (Table 137)
+    BLEND_MODE_HUE,
+    BLEND_MODE_SATURATION,
+    BLEND_MODE_COLOR,
+    BLEND_MODE_LUMINOSITY,
+  };
+
+  // State of an ExtGState /SMask entry. A present soft mask is the one
+  // transparency parameter whose omission makes the output wrong rather than
+  // merely approximate, so absent and /None are kept apart.
+  enum soft_mask_state {
+    SOFT_MASK_ABSENT,   // key not in the dictionary: inherit the current mask
+    SOFT_MASK_NONE,     // /None: clear the current soft mask
+    SOFT_MASK_PRESENT,  // a mask dictionary (not applied)
+  };
+
+  std::string to_string(blend_mode_name name)
+  {
+    switch(name)
+      {
+      case BLEND_MODE_NORMAL:      { return "/Normal"; }
+      case BLEND_MODE_MULTIPLY:    { return "/Multiply"; }
+      case BLEND_MODE_SCREEN:      { return "/Screen"; }
+      case BLEND_MODE_OVERLAY:     { return "/Overlay"; }
+      case BLEND_MODE_DARKEN:      { return "/Darken"; }
+      case BLEND_MODE_LIGHTEN:     { return "/Lighten"; }
+      case BLEND_MODE_COLOR_DODGE: { return "/ColorDodge"; }
+      case BLEND_MODE_COLOR_BURN:  { return "/ColorBurn"; }
+      case BLEND_MODE_HARD_LIGHT:  { return "/HardLight"; }
+      case BLEND_MODE_SOFT_LIGHT:  { return "/SoftLight"; }
+      case BLEND_MODE_DIFFERENCE:  { return "/Difference"; }
+      case BLEND_MODE_EXCLUSION:   { return "/Exclusion"; }
+      case BLEND_MODE_HUE:         { return "/Hue"; }
+      case BLEND_MODE_SATURATION:  { return "/Saturation"; }
+      case BLEND_MODE_COLOR:       { return "/Color"; }
+      case BLEND_MODE_LUMINOSITY:  { return "/Luminosity"; }
+
+      default: { return "/Unknown"; }
+      }
+  }
+
+  // /Compatible is a deprecated synonym of /Normal (11.3.5.2)
+  blend_mode_name to_blend_mode_name(const std::string& name)
+  {
+    if(name=="/Normal" or name=="/Compatible") { return BLEND_MODE_NORMAL; }
+    if(name=="/Multiply")                      { return BLEND_MODE_MULTIPLY; }
+    if(name=="/Screen")                        { return BLEND_MODE_SCREEN; }
+    if(name=="/Overlay")                       { return BLEND_MODE_OVERLAY; }
+    if(name=="/Darken")                        { return BLEND_MODE_DARKEN; }
+    if(name=="/Lighten")                       { return BLEND_MODE_LIGHTEN; }
+    if(name=="/ColorDodge")                    { return BLEND_MODE_COLOR_DODGE; }
+    if(name=="/ColorBurn")                     { return BLEND_MODE_COLOR_BURN; }
+    if(name=="/HardLight")                     { return BLEND_MODE_HARD_LIGHT; }
+    if(name=="/SoftLight")                     { return BLEND_MODE_SOFT_LIGHT; }
+    if(name=="/Difference")                    { return BLEND_MODE_DIFFERENCE; }
+    if(name=="/Exclusion")                     { return BLEND_MODE_EXCLUSION; }
+    if(name=="/Hue")                           { return BLEND_MODE_HUE; }
+    if(name=="/Saturation")                    { return BLEND_MODE_SATURATION; }
+    if(name=="/Color")                         { return BLEND_MODE_COLOR; }
+    if(name=="/Luminosity")                    { return BLEND_MODE_LUMINOSITY; }
+
+    return BLEND_MODE_UNKNOWN;
+  }
+
 }
 
 #endif

{docling_parse-7.9.0 → docling_parse-7.11.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.11.0}/src/parse/page_items/page_image.h

@@ -86,6 +86,13 @@ namespace pdflib
     int  device_n_components = 0; // number of components from /DeviceN names array; 0 if not DeviceN
     std::vector<std::string> device_n_names;
 
+    // /Separation and /DeviceN (8.6.6.4, 8.6.6.5): the resolved colour space,
+    // so the samples -- which are tints, not colours -- can be put through its
+    // tint transform. Null unless the space is one of those two and both its
+    // transform and its alternate space decoded.
+    std::shared_ptr<pdf_resource<PAGE_COLORSPACE>> tint_colorspace;
+    int tint_components = 0;
+
     // /Indexed color space support
     int              indexed_hival  = -1;
     std::string      indexed_base_cs;