docling-parse 7.24.2__tar.gz → 7.25.0__tar.gz

{docling_parse-7.24.2 → docling_parse-7.25.0}/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [v7.25.0](https://github.com/docling-project/docling-parse/releases/tag/v7.25.0) - 2026-11-09
+
+### Feature
+
+* Working on parallel efficiency ([#435](https://github.com/docling-project/docling-parse/issues/435)) ([`c2b39af`](https://github.com/docling-project/docling-parse/commit/c2b39afa59d95caabec4707f63fca2838c516ae1))
+* Consolidate Blend2D rendering prs according to #428 ([#433](https://github.com/docling-project/docling-parse/issues/433)) ([`ec1dfed`](https://github.com/docling-project/docling-parse/commit/ec1dfed0ba7b58b4436ee912cfaae00f295bc866))
+* Read the tagged-PDF structure tree and link text cells to marked content ([#337](https://github.com/docling-project/docling-parse/issues/337)) ([`7a920a5`](https://github.com/docling-project/docling-parse/commit/7a920a5ad5347aa8ed72c5dd2dff1f2d9e3cb20e))
+
+### Fix
+
+* Add better error messaging ([#442](https://github.com/docling-project/docling-parse/issues/442)) ([`1b7a5fe`](https://github.com/docling-project/docling-parse/commit/1b7a5fe5e411480edefe669b5a805e8f97c2192e))
+* **render:** Stroke clipping, tiling patterns and soft masks, consolidated per #428 ([#439](https://github.com/docling-project/docling-parse/issues/439)) ([`f4b12cf`](https://github.com/docling-project/docling-parse/commit/f4b12cf2d114397dd1601027c3b0b586d7f3a594))
+* **text:** Word and cell segmentation fixes, consolidated per #428 ([#437](https://github.com/docling-project/docling-parse/issues/437)) ([`01cd139`](https://github.com/docling-project/docling-parse/commit/01cd1393fb0e3dd414a60de215fc106fe837bb61))
+* Transcode PDF names that are not UTF-8 before they reach Python ([#438](https://github.com/docling-project/docling-parse/issues/438)) ([`fa338f7`](https://github.com/docling-project/docling-parse/commit/fa338f7fb3129081d4f46a5af07b6cf1e2c24276))
+* **fonts:** Font and ToUnicode decoding fixes, consolidated per #428 ([#431](https://github.com/docling-project/docling-parse/issues/431)) ([`8aa5cac`](https://github.com/docling-project/docling-parse/commit/8aa5cacc860fd802bdc02b43252a69f66808880e))
+* Keep the /AcroForm JSON export out of the document behind a signature ([#410](https://github.com/docling-project/docling-parse/issues/410)) ([`eb19698`](https://github.com/docling-project/docling-parse/commit/eb19698df62b682dcea9b762af805f7e641167e7))
+
+### Documentation
+
+* Add pull request submission guidelines ([#430](https://github.com/docling-project/docling-parse/issues/430)) ([`6dbd6a8`](https://github.com/docling-project/docling-parse/commit/6dbd6a83d93b720637fd80629961f14ee6bb3df9))
+
 ## [v7.24.2](https://github.com/docling-project/docling-parse/releases/tag/v7.24.2) - 2026-10-29
 
 ### Fix

{docling_parse-7.24.2 → docling_parse-7.25.0}/CMakeLists.txt

@@ -228,6 +228,27 @@ set_target_properties(parse PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
 target_link_libraries(parse ${DEPENDENCIES} ${LIB_LINK})
 
+option(DOCLING_PARSE_BUILD_STRUCTURE_TESTS "Build the native structure concurrency harness" OFF)
+if(DOCLING_PARSE_BUILD_STRUCTURE_TESTS)
+    add_executable(structure_concurrency tests/cpp/test_structure_concurrency.cpp)
+    set_property(TARGET structure_concurrency PROPERTY CXX_STANDARD 20)
+    add_dependencies(structure_concurrency ${DEPENDENCIES})
+    target_link_libraries(structure_concurrency PRIVATE ${DEPENDENCIES} ${LIB_LINK})
+endif()
+
+# Test the native library directly: the renderer's curve-flattening workaround
+# (#407) otherwise bypasses the stroker routines patched for #396/#400/#401.
+option(DOCLING_PARSE_BUILD_BLEND2D_TESTS "Build native Blend2D patch regression tests" OFF)
+if(DOCLING_PARSE_BUILD_BLEND2D_TESTS)
+    enable_testing()
+    add_executable(blend2d_patch_regression tests/cpp/test_blend2d_patches.cpp)
+    target_link_libraries(blend2d_patch_regression PRIVATE blend2d)
+    foreach(case affine stall spike flat-return flat-overshoot)
+        add_test(NAME blend2d_${case} COMMAND blend2d_patch_regression ${case})
+        set_tests_properties(blend2d_${case} PROPERTIES TIMEOUT 60)
+    endforeach()
+endif()
+
 # ***************************
 # ***  Python-binding     ***
 # ***************************

{docling_parse-7.24.2 → docling_parse-7.25.0}/CONTRIBUTING.md

@@ -34,6 +34,67 @@ maintainers of each component affected.
 
 For a list of the maintainers, see the [MAINTAINERS.md](MAINTAINERS.md) page.
 
+## Submitting pull requests
+
+These rules keep pull requests reviewable. A pull request that does not follow
+them can be put on hold until it is resubmitted.
+
+### Scope
+
+- One topic per pull request. Changes that touch the same functions or files
+  belong to the same topic. One commit per logical fix within a pull request is
+  fine.
+- Rebase on current `main` before you submit, and use no merge commits. To
+  update a branch, run `git rebase upstream/main` and push with
+  `git push --force-with-lease`.
+- Do not stack pull requests. Open the next pull request in a topic only after
+  the previous one in that topic has been merged or closed.
+- When a pull request replaces earlier ones, close them and link them from the
+  description.
+
+### Evidence from real documents
+
+Every change must be shown on a real document. Synthetic test PDFs built with
+`tests/pdf_builder.py` are welcome as unit tests, but they do not show that a
+change matters in practice.
+
+- Use the [regression dataset](https://huggingface.co/datasets/docling-project/regression-dataset-for-docling-parse)
+  first. If a document in it already shows the problem, name the document and
+  the page numbers in the description, and do not open a dataset pull request.
+- Open a pull request against the regression dataset only when no existing
+  document reproduces the problem. It adds the new document, with a license
+  that allows redistribution, and says which problem the document reproduces.
+- Text, font and segmentation fixes: for each cited page, show a before/after
+  diff of the affected text cells or words.
+
+### Rendering changes
+
+A rendering change must show that the output improves, which in practice means
+that it moves closer to pypdfium2.
+
+- For each cited page, include a three-panel comparison: pypdfium2, before,
+  after. `tests/test_regression_pypdfium_render.py` writes these panels (see
+  [tests/README.md](tests/README.md#cross-renderer-comparison-against-pypdfium2)).
+- Include a before/after table of `mean_abs_error` and `changed_pixels_ratio`
+  against pypdfium2 over the whole regression corpus. The cited pages must
+  improve, and no page may get worse by more than `PYPDFIUM_IMAGE_TOLERANCE` in
+  `tests/test_regression_pypdfium_render.py`.
+- Add an image regression test that fails on `main` and passes with the change,
+  and that compares against pypdfium2 on the cited pages.
+  `test_regression_pypdfium_render.py` only reports differences and never
+  fails, so on its own it does not count as this test.
+- Blend2D patches also need a link to the issue or pull request filed upstream
+  with Blend2D, and a real document that crashes, hangs or renders incorrectly
+  without the patch.
+
+### Ground truth
+
+- Do not pin `HF_DATASET_REVISION` in `tests/constants.py` to a revision from an
+  open dataset pull request.
+- If a change alters the ground truth of existing regression pages, list those
+  pages in the description and say why each one changes. The maintainers update
+  the ground truth when they merge.
+
 
 ## Legal
 

{docling_parse-7.24.2 → docling_parse-7.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docling-parse
-Version: 7.24.2
+Version: 7.25.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.24.2 → docling_parse-7.25.0}/app/pybind_parse.cpp

@@ -360,6 +360,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
         max_num_bitmaps (int): Maximum number of bitmaps to keep (-1 means no cap) [default=-1].
         min_visible_clip_extent (float): Minimum clip width/height treated as a usable image clip [default=1e-3].
         apply_actual_text (bool): Honor /ActualText replacement text of marked-content spans during text extraction (PDF 32000-1, 14.9.4) [default=true].
+        do_char_normalization (bool): Fold typographic dashes (U+2012..U+2015) and the minus sign (U+2212) to `-` in cell text [default=true].
         keep_glyphs (bool): If true, keep GLYPH<...> fallback strings in output; if false, replace them with a space [default=false].
         keep_qpdf_warnings (bool): If true, QPDF warnings are emitted; if false, they are suppressed [default=false].
     )")
@@ -382,11 +383,13 @@ PYBIND11_MODULE(pdf_parsers, m) {
     .def_readwrite("do_thread_safe", &pdflib::decode_config::do_thread_safe)
     .def_readwrite("release_native_memory_every_n_pages", &pdflib::decode_config::release_native_memory_every_n_pages)
     .def_readwrite("apply_actual_text", &pdflib::decode_config::apply_actual_text)
+    .def_readwrite("do_char_normalization", &pdflib::decode_config::do_char_normalization)
     .def_readwrite("keep_glyphs", &pdflib::decode_config::keep_glyphs)
     .def_readwrite("keep_qpdf_warnings", &pdflib::decode_config::keep_qpdf_warnings)
     .def_readwrite("extract_font_programs", &pdflib::decode_config::extract_font_programs)
     .def_readwrite("extract_bitmap_pixels", &pdflib::decode_config::extract_bitmap_pixels)
     .def_readwrite("bitmap_target_pixels_per_unit", &pdflib::decode_config::bitmap_target_pixels_per_unit)
+    .def("to_string", &pdflib::decode_config::to_string)
     .def("__copy__", [](const pdflib::decode_config& self) { return self; })
     .def("__deepcopy__", [](const pdflib::decode_config& self, pybind11::dict) { return self; });
 
@@ -414,9 +417,14 @@ PYBIND11_MODULE(pdf_parsers, m) {
     .def_readonly("font_key", &pdflib::page_item<pdflib::PAGE_CELL>::font_key)
     .def_readonly("font_name", &pdflib::page_item<pdflib::PAGE_CELL>::font_name)
     .def_readonly("widget", &pdflib::page_item<pdflib::PAGE_CELL>::widget)
-    .def_readonly("left_to_right", &pdflib::page_item<pdflib::PAGE_CELL>::left_to_right);
+    .def_readonly("left_to_right", &pdflib::page_item<pdflib::PAGE_CELL>::left_to_right)
+    .def_readonly("mcid", &pdflib::page_item<pdflib::PAGE_CELL>::mcid)
+    .def_property_readonly("artifact_type", &pdflib::page_item<pdflib::PAGE_CELL>::get_artifact_type)
+    .def_property_readonly("artifact_subtype", &pdflib::page_item<pdflib::PAGE_CELL>::get_artifact_subtype);
 
   // PdfShape - graphic shape with coordinates
+  m.attr("PDF_CELL_SIZE") = sizeof(pdflib::page_item<pdflib::PAGE_CELL>);
+
   pybind11::class_<pdflib::page_item<pdflib::PAGE_SHAPE>>(m, "PdfShape")
     .def("get_x",
          static_cast<std::vector<double>& (pdflib::page_item<pdflib::PAGE_SHAPE>::*)()>(
@@ -599,6 +607,10 @@ PYBIND11_MODULE(pdf_parsers, m) {
     .def("get_char_cells", &pdflib::pdf_decoder<pdflib::PAGE>::get_char_cells,
 	 pybind11::return_value_policy::reference_internal,
 	 "Get individual character cells")
+    .def("get_marked_content", [](pdflib::pdf_decoder<pdflib::PAGE>& self) {
+      pybind11::gil_scoped_release release;
+      return self.get_marked_content();
+    }, "Batch export of character-cell linkage, text and geometry")
     .def("get_word_cells", &pdflib::pdf_decoder<pdflib::PAGE>::get_word_cells,
 	 pybind11::return_value_policy::reference_internal,
 	 "Get word cells (aggregated from char cells)")
@@ -725,6 +737,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
   m.attr("TIMING_KEY_PROCESS_DOCUMENT_FROM_BYTESIO") = pdflib::pdf_timings::KEY_PROCESS_DOCUMENT_FROM_BYTESIO;
   m.attr("TIMING_KEY_QPDF_PROCESS") = pdflib::pdf_timings::KEY_QPDF_PROCESS;
   m.attr("TIMING_KEY_EXTRACT_DOC_ANNOTATIONS") = pdflib::pdf_timings::KEY_EXTRACT_DOC_ANNOTATIONS;
+  m.attr("TIMING_KEY_EXTRACT_STRUCTURE") = pdflib::pdf_timings::KEY_EXTRACT_STRUCTURE;
   m.attr("TIMING_KEY_DECODE_DOCUMENT") = pdflib::pdf_timings::KEY_DECODE_DOCUMENT;
 
   m.attr("TIMING_PREFIX_DECODE_FONT") = pdflib::pdf_timings::PREFIX_DECODE_FONT;
@@ -960,9 +973,24 @@ PYBIND11_MODULE(pdf_parsers, m) {
     Returns:
         int: The number of pages in the document.)")
 
+    .def("get_structure", [](docling::docling_parser& self, const std::string& key) {
+      auto doc = self.get_document_decoder(key);
+      if(not doc) { throw std::runtime_error("Document key not found: " + key); }
+      pybind11::gil_scoped_release release;
+      return doc->get_structure();
+    }, pybind11::arg("key"))
+    .def("get_document_timings", [](docling::docling_parser& self, const std::string& key) {
+      auto doc = self.get_document_decoder(key);
+      if(not doc) { throw std::runtime_error("Document key not found: " + key); }
+      pybind11::gil_scoped_release release;
+      return doc->get_document_timings();
+    }, pybind11::arg("key"))
     .def("get_annotations",
 	 [](docling::docling_parser &self, const std::string &key) -> nlohmann::json {
-	   return self.get_annotations(key);
+           auto doc = self.get_document_decoder(key);
+           if(not doc) { return nullptr; }
+           pybind11::gil_scoped_release release;
+           return doc->get_annotations();
 	 },
 	 pybind11::arg("key"),
 	 R"(
@@ -1203,14 +1231,33 @@ PYBIND11_MODULE(pdf_parsers, m) {
 
     Returns:
         int: Number of pages that will be emitted by the threaded parser.)")
+    .def("get_structure", [](docling::docling_threaded_parser& self, const std::string& key) {
+      auto doc = self.get_document_decoder(key);
+      pybind11::gil_scoped_release release;
+      return doc->get_structure();
+    }, pybind11::arg("key"))
+    .def("get_document_timings", [](docling::docling_threaded_parser& self, const std::string& key) {
+      auto doc = self.get_document_decoder(key);
+      pybind11::gil_scoped_release release;
+      return doc->get_document_timings();
+    }, pybind11::arg("key"))
     .def("get_annotations",
          [](docling::docling_threaded_parser& self, const std::string& key) -> nlohmann::json {
-           return self.get_annotations(key);
+           // The lookup runs under the GIL, like unload_document; the pointer
+           // keeps the document alive once the GIL is released.
+           auto document = self.find_document(key);
+
+           pybind11::gil_scoped_release release;
+           return document->get_annotations();
          },
          pybind11::arg("key"),
          R"(
     Retrieve annotations for a loaded document and return them as JSON.
 
+    The first call for a document builds them, and may wait for a worker to
+    finish copying a page out of the document; the GIL is released meanwhile.
+    Later calls return the cached JSON.
+
     Parameters:
         key (str): The unique key identifying the document.
 
@@ -1270,6 +1317,7 @@ PYBIND11_MODULE(pdf_parsers, m) {
         render_shapes (bool): Paint vector shape instructions [default=true].
         render_shadings (bool): Paint shading instructions [default=true].
         render_non_rect_clip_masks (bool): Apply non-rectangular clip masks [default=true].
+        render_soft_masks (bool): Composite paint through ExtGState soft masks (/SMask) [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].
@@ -1285,10 +1333,12 @@ PYBIND11_MODULE(pdf_parsers, m) {
         canvas_height (int): Target canvas height in pixels; -1 means use PDF page size [default=-1].
     )")
     .def(pybind11::init<>())
+    .def("to_string", &pdflib::render_config::to_string)
     .def_readwrite("render_text",             &pdflib::render_config::render_text)
     .def_readwrite("render_shapes",           &pdflib::render_config::render_shapes)
     .def_readwrite("render_shadings",         &pdflib::render_config::render_shadings)
     .def_readwrite("render_non_rect_clip_masks", &pdflib::render_config::render_non_rect_clip_masks)
+    .def_readwrite("render_soft_masks",       &pdflib::render_config::render_soft_masks)
     .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)
@@ -1391,6 +1441,12 @@ PYBIND11_MODULE(pdf_parsers, m) {
         decode_config (DecodePageConfig): Configuration for page decoding.
         render_config (RenderConfig): Configuration for page rendering.)")
 
+    .def_property_readonly("decode_config",
+         [](const docling::docling_threaded_renderer& self) -> pdflib::decode_config {
+           return self.get_decode_config();
+         },
+         "Copy of the config the workers decode with, including the settings rendering forces on.")
+
     .def("load_document",
          [](docling::docling_threaded_renderer& self,
             const std::string& key,
@@ -1448,9 +1504,23 @@ PYBIND11_MODULE(pdf_parsers, m) {
            return self.scheduled_number_of_pages(key);
          },
          pybind11::arg("key"))
+    .def("get_structure", [](docling::docling_threaded_renderer& self, const std::string& key) {
+      auto doc = self.get_document_decoder(key);
+      pybind11::gil_scoped_release release;
+      return doc->get_structure();
+    }, pybind11::arg("key"))
+    .def("get_document_timings", [](docling::docling_threaded_renderer& self, const std::string& key) {
+      auto doc = self.get_document_decoder(key);
+      pybind11::gil_scoped_release release;
+      return doc->get_document_timings();
+    }, pybind11::arg("key"))
     .def("get_annotations",
          [](docling::docling_threaded_renderer& self, const std::string& key) -> nlohmann::json {
-           return self.get_annotations(key);
+           // See the parser binding of the same name.
+           auto document = self.find_document(key);
+
+           pybind11::gil_scoped_release release;
+           return document->get_annotations();
          },
          pybind11::arg("key"))
     .def("unload_document",

{docling_parse-7.24.2 → docling_parse-7.25.0}/app/render.cpp

@@ -13,8 +13,36 @@ struct bbox_render_options
   bool draw_word_bbox = false;
   bool draw_text_bbox = false;
   bool print_bbox = false;
+  bool display_char_on_cli = false;
+  bool display_word_on_cli = false;
+  bool display_text_on_cli = false;
 };
 
+void display_cells_on_cli(int page,
+                          const std::string& mode,
+                          pdflib::page_item<pdflib::PAGE_CELLS>& cells)
+{
+  static bool printed_header = false;
+  if(not printed_header)
+    {
+      std::cout << "page\tmode\tx0\ty0\tx1\ty1\tx2\ty2\tx3\ty3\tfont-name\ttext\n";
+      printed_header = true;
+    }
+  for(const auto& cell : cells)
+    {
+      if(not cell.active) { continue; }
+      std::ostringstream row;
+      row << page << '\t' << mode << std::fixed << std::setprecision(3)
+          << '\t' << cell.r_x0 << '\t' << cell.r_y0
+          << '\t' << cell.r_x1 << '\t' << cell.r_y1
+          << '\t' << cell.r_x2 << '\t' << cell.r_y2
+          << '\t' << cell.r_x3 << '\t' << cell.r_y3
+          << '\t' << std::quoted(cell.font_name)
+          << '\t' << std::quoted(cell.text) << '\n';
+      std::cout << row.str();
+    }
+}
+
 std::string table_text(std::string text)
 {
   constexpr std::size_t max_size = 30;
@@ -96,6 +124,19 @@ void draw_cell_bboxes(pdflib::pdf_decoder<pdflib::PAGE>& page,
                       Renderer& rnd,
                       const bbox_render_options& options)
 {
+  if(options.display_char_on_cli)
+    {
+      display_cells_on_cli(page.get_page_number(), "char", page.get_char_cells());
+    }
+  if(options.display_word_on_cli)
+    {
+      display_cells_on_cli(page.get_page_number(), "word", page.get_word_cells());
+    }
+  if(options.display_text_on_cli)
+    {
+      display_cells_on_cli(page.get_page_number(), "text", page.get_line_cells());
+    }
+
   if(options.print_bbox and options.draw_glyph_bbox)
     {
       for(const auto& glyph : page.get_instructions().get_text_instructions())
@@ -367,6 +408,9 @@ int main(int argc, char* argv[])
         ("draw-word-bbox",  "Draw contracted word-cell quads",                               cxxopts::value<bool>()->implicit_value("true"))
         ("draw-text-bbox",  "Draw contracted line/text-cell quads",                          cxxopts::value<bool>()->implicit_value("true"))
         ("print-bbox",      "Print enabled bbox modes as an aligned table on stdout",       cxxopts::value<bool>()->implicit_value("true"))
+        ("display-char-on-cli", "Print character corners, font name and text on stdout", cxxopts::value<bool>()->implicit_value("true"))
+        ("display-word-on-cli", "Print word corners, font name and text on stdout",      cxxopts::value<bool>()->implicit_value("true"))
+        ("display-text-on-cli", "Print line corners, font name and text on stdout",      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>>())
@@ -449,6 +493,9 @@ int main(int argc, char* argv[])
       bbox_options.draw_word_bbox = result.count("draw-word-bbox") and result["draw-word-bbox"].as<bool>();
       bbox_options.draw_text_bbox = result.count("draw-text-bbox") and result["draw-text-bbox"].as<bool>();
       bbox_options.print_bbox = result.count("print-bbox") and result["print-bbox"].as<bool>();
+      bbox_options.display_char_on_cli = result.count("display-char-on-cli") and result["display-char-on-cli"].as<bool>();
+      bbox_options.display_word_on_cli = result.count("display-word-on-cli") and result["display-word-on-cli"].as<bool>();
+      bbox_options.display_text_on_cli = result.count("display-text-on-cli") and result["display-text-on-cli"].as<bool>();
       if (result.count("page-boundary"))            { page_config.page_boundary             = result["page-boundary"].as<std::string>(); }
       if (result.count("do-sanitization"))          { page_config.do_sanitization            = result["do-sanitization"].as<bool>(); }
       if (result.count("keep-char-cells"))          { page_config.keep_char_cells            = result["keep-char-cells"].as<bool>(); }
@@ -465,9 +512,9 @@ int main(int argc, char* argv[])
       page_config.extract_bitmap_pixels = true;
       if (result.count("extract-font-programs"))    { page_config.extract_font_programs     = result["extract-font-programs"].as<bool>(); }
       if (result.count("populate-json"))            { page_config.populate_json_objects      = result["populate-json"].as<bool>(); }
-      if (bbox_options.draw_char_bbox) { page_config.keep_char_cells = true; }
-      if (bbox_options.draw_word_bbox) { page_config.create_word_cells = true; }
-      if (bbox_options.draw_text_bbox) { page_config.create_line_cells = true; }
+      if (bbox_options.draw_char_bbox or bbox_options.display_char_on_cli) { page_config.keep_char_cells = true; }
+      if (bbox_options.draw_word_bbox or bbox_options.display_word_on_cli) { page_config.create_word_cells = true; }
+      if (bbox_options.draw_text_bbox or bbox_options.display_text_on_cli) { page_config.create_line_cells = true; }
       bool export_bitmaps = result["export-bitmaps"].as<bool>();
       bool export_page_pdf_files = result["export-page-pdf"].as<bool>();