qpdf_ruby 0.1.0 → 0.2.0

data/ext/qpdf_ruby/figure_node.cpp

@@ -1,109 +1,134 @@
 #include "struct_node.hpp"
 
-static void add_bbox(PDFStructWalker& walker, QPDFObjectHandle node) {
-  int mcid = -std::numeric_limits<int>::infinity();
+#include <optional>
+#include <set>
 
-  if (node.getKey("/K").isInteger()) {
-    mcid = node.getKey("/K").getIntValue();
-  }
-
-  // Get the bbox from the walker or use defaults
-
-  QPDFObjectHandle pageObj;
-  QPDFObjectHandle currentNode = node;
-  bool found = false;
+namespace {
 
-  // Try to find /Pg by walking up the parent chain
-  while (currentNode.isDictionary()) {
-    if (currentNode.hasKey("/Pg")) {
-      pageObj = currentNode.getKey("/Pg");
-      found = true;
-      break;
-    }
-
-    if (currentNode.hasKey("/P")) {
-      currentNode = currentNode.getKey("/P");
-    } else {
-      break;  // No more parents to check
-    }
+// The page a structure element's content lives on: its own /Pg or the nearest ancestor's.
+QPDFObjectHandle page_of(QPDFObjectHandle elem) {
+  for (int guard = 0; elem.isDictionary() && guard < 256; ++guard) {
+    if (elem.getKey("/Pg").isDictionary()) return elem.getKey("/Pg");
+    elem = elem.getKey("/P");
   }
+  return QPDFObjectHandle::newNull();
+}
 
-  if (!found && node.hasKey("/K") && node.getKey("/K").isArray()) {
-    QPDFObjectHandle kids = node.getKey("/K");
-    for (int i = 0; i < kids.getArrayNItems(); ++i) {
-      QPDFObjectHandle kid = kids.getArrayItem(i);
-      if (kid.isDictionary() && kid.hasKey("/Pg")) {
-        pageObj = kid.getKey("/Pg");
-        found = true;
-        break;
-      }
-    }
+// Unites the bounds of every piece of marked content below `elem`: direct MCIDs (in the content of
+// the element's page), marked-content references (in their /Stm if given, else their own /Pg's
+// content) and nested structure elements.
+void collect_bounds(QPDFObjectHandle elem, qpdf_ruby::McidBounds const& bounds, std::optional<qpdf_ruby::Box>& out,
+                    std::set<QPDFObjGen>& seen, int depth = 0) {
+  if (depth > 256 || (elem.isIndirect() && !seen.insert(elem.getObjGen()).second)) return;
+  QPDFObjectHandle page = page_of(elem);
+
+  auto add = [&](QPDFObjectHandle on_page, QPDFObjectHandle owner, int mcid) {
+    if (!on_page.isDictionary() || !(owner.isDictionary() || owner.isStream())) return;
+    auto it = bounds.find({on_page.getObjGen(), owner.getObjGen(), mcid});
+    if (it == bounds.end()) return;
+    out = out ? qpdf_ruby::unite(*out, it->second) : it->second;
+  };
+
+  QPDFObjectHandle kids = elem.getKey("/K");
+  std::vector<QPDFObjectHandle> list;
+  if (kids.isArray()) {
+    for (auto kid : kids.aitems()) list.push_back(kid);
+  } else if (!kids.isNull()) {
+    list.push_back(kids);
   }
 
-  if (!found || !pageObj.isIndirect()) {
-    std::cerr << "No /Pg key found for MCID " << mcid << ", cannot add BBox." << std::endl;
-    return;
+  for (auto& kid : list) {
+    if (kid.isInteger()) {
+      add(page, page, kid.getIntValue());
+    } else if (kid.isDictionary() && kid.getKey("/Type").isNameAndEquals("/MCR") && kid.getKey("/MCID").isInteger()) {
+      QPDFObjectHandle on_page = kid.getKey("/Pg").isDictionary() ? kid.getKey("/Pg") : page;
+      // A /Stm that is not a stream names nothing we can look up: no bounds rather than the page's.
+      QPDFObjectHandle owner = kid.hasKey("/Stm") ? kid.getKey("/Stm") : on_page;
+      if (kid.hasKey("/Stm") && !owner.isStream()) continue;
+      add(on_page, owner, kid.getKey("/MCID").getIntValue());
+    } else if (kid.isDictionary() && kid.hasKey("/S")) {
+      collect_bounds(kid, bounds, out, seen, depth + 1);
+    }
   }
+}
 
-  auto media_box = walker.getPageCropBoxFor(pageObj);
-
-  double llx = media_box[0], lly = media_box[1], urx = media_box[2], ury = media_box[3];
-  auto const& bbox_map = walker.getMcidBboxMap();
+bool is_layout(QPDFObjectHandle attrs) {
+  return attrs.isDictionary() && attrs.getKey("/O").isNameAndEquals("/Layout");
+}
 
-  // Use a try/catch to prevent failures when accessing the map
-  try {
-    if (bbox_map.count(mcid) > 0) {
-      auto const& b = bbox_map.at(mcid);
-      llx = b[0];
-      lly = b[1];
-      urx = b[2];
-      ury = b[3];
+// The element's Layout attribute dictionary - /A itself, or the first one in an /A array - or null.
+QPDFObjectHandle layout_of(QPDFObjectHandle attrs) {
+  if (is_layout(attrs)) return attrs;
+  if (attrs.isArray()) {
+    for (auto item : attrs.aitems()) {
+      if (is_layout(item)) return item;
     }
-  } catch (const std::exception& e) {
-    std::cerr << "Error accessing mcid " << mcid << " in bbox map: " << e.what() << std::endl;
-    // Continue with default values
   }
+  return QPDFObjectHandle::newNull();
+}
 
-  QPDFObjectHandle attrs;
-  attrs = QPDFObjectHandle::newDictionary();
-  attrs.replaceKey("/O", QPDFObjectHandle::newName("/Layout"));
-
-  node.replaceKey("/A", attrs);
-
-  if (!attrs.hasKey("/BBox")) {
-    QPDFObjectHandle arr = QPDFObjectHandle::newArray();
-    arr.appendItem(QPDFObjectHandle::newReal(llx));
-    arr.appendItem(QPDFObjectHandle::newReal(lly));
-    arr.appendItem(QPDFObjectHandle::newReal(urx));
-    arr.appendItem(QPDFObjectHandle::newReal(ury));
-
-    attrs.replaceKey("/BBox", arr);
+// Structure types whose content is a line of text: a Figure among them is part of that line.
+const std::set<std::string> kInlineParents = {"/P",    "/H",        "/H1",      "/H2",  "/H3",  "/H4",   "/H5",
+                                              "/H6",   "/Lbl",      "/Span",    "/Quote", "/Note", "/Reference",
+                                              "/BibEntry", "/Code", "/Link",    "/Annot", "/Ruby", "/Warichu",
+                                              "/Strong", "/Em"};
+
+// True if the Figure sits in a line of text - its nearest parent that is not a NonStruct (which
+// only groups, ISO 32000-1 14.8.4.2) is one of kInlineParents.
+bool in_inline_context(QPDFObjectHandle elem) {
+  QPDFObjectHandle parent = elem.getKey("/P");
+  for (int guard = 0; guard < 64 && parent.isDictionary(); ++guard) {
+    if (!parent.getKey("/S").isNameAndEquals("/NonStruct")) break;
+    parent = parent.getKey("/P");
   }
+  QPDFObjectHandle type = parent.isDictionary() ? parent.getKey("/S") : QPDFObjectHandle::newNull();
+  return type.isName() && kInlineParents.count(type.getName()) > 0;
+}
+
+QPDFObjectHandle box_array(qpdf_ruby::Box const& box) {
+  QPDFObjectHandle array = QPDFObjectHandle::newArray();
+  for (double value : box) array.appendItem(QPDFObjectHandle::newReal(value, 4));
+  return array;
 }
 
+}  // namespace
+
+// Gives the Figure a Layout attribute with a /BBox (its painted bounds) and, outside a line of text,
+// /Placement /Block - without the placement PAC 2024 warns of a "possibly inappropriate use" of the
+// Figure (checked 2026-10-02). Existing values are kept; an existing attribute object is extended.
 void FigureNode::ensureLayoutBBox(PDFStructWalker& walker) {
   StructElemNode::ensureLayoutBBox(walker);
 
-  // Bail if a BBox is already present *anywhere* in /A
-  if (node.hasKey("/A")) {
-    QPDFObjectHandle A = node.getKey("/A");
-    auto has_bbox = [](QPDFObjectHandle const& dict) {
-      QPDFObjectHandle non_const_dict = dict;
-      return non_const_dict.isDictionary() && non_const_dict.hasKey("/O") &&
-             non_const_dict.getKey("/O").getName() == "/Layout" && non_const_dict.hasKey("/BBox");
-    };
-
-    if ((A.isDictionary() && has_bbox(A)) || (A.isArray() && [&]() -> bool {
-          for (int i = 0; i < A.getArrayNItems(); ++i) {
-            if (has_bbox(A.getArrayItem(i))) {
-              return true;
-            }
-          }
-          return false;
-        }())) {
-      return;  // nothing to do
-    }
+  QPDFObjectHandle attrs = node.getKey("/A");
+  QPDFObjectHandle layout = layout_of(attrs);
+  bool needs_bbox = !(layout.isDictionary() && layout.hasKey("/BBox"));
+  bool needs_placement = !(layout.isDictionary() && layout.hasKey("/Placement")) && !in_inline_context(node);
+  if (!needs_bbox && !needs_placement) return;
+
+  std::optional<qpdf_ruby::Box> box;
+  if (needs_bbox) {
+    std::set<QPDFObjGen> seen;
+    collect_bounds(node, walker.getMcidBounds(), box, seen);
+    QPDFObjectHandle page = page_of(node);
+    if (!box && page.isDictionary()) box = walker.getPageCropBoxFor(page);  // else nothing to anchor it to
   }
+  if (!box && !needs_placement) return;
 
-  add_bbox(walker, node);
-}
+  bool attached = layout.isDictionary();
+  if (!attached) {
+    layout = QPDFObjectHandle::newDictionary();
+    layout.replaceKey("/O", QPDFObjectHandle::newName("/Layout"));
+  }
+  if (box) layout.replaceKey("/BBox", box_array(*box));
+  if (needs_placement) layout.replaceKey("/Placement", QPDFObjectHandle::newName("/Block"));
+  if (attached) return;
+
+  // Keep every existing attribute object: append the new Layout dictionary to them.
+  if (attrs.isArray()) {
+    attrs.appendItem(layout);
+  } else if (attrs.isDictionary()) {
+    node.replaceKey("/A", QPDFObjectHandle::newArray({attrs, layout}));
+  } else {
+    node.replaceKey("/A", layout);
+  }
+}

data/ext/qpdf_ruby/mcid_bounds.cpp

@@ -0,0 +1,317 @@
+#include "mcid_bounds.hpp"
+#include "stroke_bounds.hpp"
+
+#include <qpdf/QPDFObjectHandle.hh>
+#include <qpdf/QPDFPageObjectHelper.hh>
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+#include <optional>
+#include <set>
+#include <stack>
+#include <vector>
+
+namespace qpdf_ruby {
+
+namespace {
+
+using Matrix = std::array<double, 6>;  // a b c d e f
+
+constexpr Matrix kIdentity = {1, 0, 0, 1, 0, 0};
+
+// m1 applied first, then m2 (PDF's row-vector convention: CTM' = m1 x CTM).
+Matrix multiply(Matrix const& m1, Matrix const& m2) {
+  return {m1[0] * m2[0] + m1[1] * m2[2],         m1[0] * m2[1] + m1[1] * m2[3],
+          m1[2] * m2[0] + m1[3] * m2[2],         m1[2] * m2[1] + m1[3] * m2[3],
+          m1[4] * m2[0] + m1[5] * m2[2] + m2[4], m1[4] * m2[1] + m1[5] * m2[3] + m2[5]};
+}
+
+std::pair<double, double> transform(Matrix const& m, double x, double y) {
+  return {m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]};
+}
+
+struct Extent {
+  double llx = std::numeric_limits<double>::infinity();
+  double lly = std::numeric_limits<double>::infinity();
+  double urx = -std::numeric_limits<double>::infinity();
+  double ury = -std::numeric_limits<double>::infinity();
+
+  bool empty() const { return llx > urx || lly > ury; }
+  void add(double x, double y) {
+    llx = std::min(llx, x);
+    lly = std::min(lly, y);
+    urx = std::max(urx, x);
+    ury = std::max(ury, y);
+  }
+  void add_box(Matrix const& m, double x0, double y0, double x1, double y1) {
+    for (auto [x, y] : {transform(m, x0, y0), transform(m, x1, y0), transform(m, x1, y1), transform(m, x0, y1)}) {
+      add(x, y);
+    }
+  }
+  Box box() const { return {llx, lly, urx, ury}; }
+};
+
+std::optional<Matrix> matrix_of(QPDFObjectHandle array) {
+  if (!array.isArray() || array.getArrayNItems() != 6) return std::nullopt;
+  Matrix m;
+  for (int i = 0; i < 6; ++i) {
+    if (!array.getArrayItem(i).isNumber()) return std::nullopt;
+    m[i] = array.getArrayItem(i).getNumericValue();
+  }
+  return m;
+}
+
+int mcid_of(QPDFObjectHandle properties, QPDFObjectHandle resources) {
+  if (properties.isName() && resources.isDictionary()) {
+    QPDFObjectHandle named = resources.getKey("/Properties");
+    properties = named.isDictionary() ? named.getKey(properties.getName()) : QPDFObjectHandle::newNull();
+  }
+  if (properties.isDictionary() && properties.getKey("/MCID").isInteger()) {
+    return properties.getKey("/MCID").getIntValue();
+  }
+  return -1;
+}
+
+constexpr int kMaxFormDepth = 16;
+
+// The parts of the graphics state that decide where paint lands; q/Q save and restore all of it.
+struct GraphicsState {
+  Matrix ctm = kIdentity;
+  paths::StrokeStyle stroke;
+};
+
+class BoundsCollector : public QPDFObjectHandle::ParserCallbacks {
+ public:
+  // `owner` is the stream the content's MCIDs are numbered in (the page, or a Form XObject);
+  // `state` the graphics state it is drawn with; `active` the forms being walked (cycle guard).
+  BoundsCollector(QPDFObjGen page, QPDFObjGen owner, QPDFObjectHandle resources, McidBounds& out,
+                  GraphicsState state, std::set<QPDFObjGen>& active, int depth = 0)
+      : page_(page), owner_(owner), resources_(std::move(resources)), out_(out), state_(state), active_(active),
+        depth_(depth) {}
+
+  void handleObject(QPDFObjectHandle obj, size_t, size_t) override {
+    if (!obj.isOperator()) {
+      operands_.push_back(obj);
+      return;
+    }
+    std::string const op = obj.getOperatorValue();
+
+    if (op == "q") {
+      state_stack_.push(state_);
+    } else if (op == "Q") {
+      if (!state_stack_.empty()) {
+        state_ = state_stack_.top();
+        state_stack_.pop();
+      }
+    } else if (op == "cm") {
+      std::vector<QPDFObjectHandle> six(operands_.end() - std::min<size_t>(6, operands_.size()), operands_.end());
+      if (auto m = matrix_of(QPDFObjectHandle::newArray(six))) state_.ctm = multiply(*m, state_.ctm);
+    } else if (op == "w" && number(1)) {
+      state_.stroke.width = *number(1);
+    } else if (op == "J" && number(1)) {
+      state_.stroke.cap = static_cast<int>(*number(1));
+    } else if (op == "j" && number(1)) {
+      state_.stroke.join = static_cast<int>(*number(1));
+    } else if (op == "M" && number(1)) {
+      state_.stroke.miter_limit = *number(1);
+    } else if (op == "gs" && !operands_.empty() && operands_.back().isName()) {
+      apply_ext_gstate(operands_.back().getName());
+    } else if (op == "BDC") {
+      mcids_.push(operands_.size() >= 2 ? mcid_of(operands_.back(), resources_) : -1);
+    } else if (op == "BMC") {
+      mcids_.push(-1);
+    } else if (op == "EMC") {
+      if (!mcids_.empty()) mcids_.pop();
+    } else if (op == "m" && point(1)) {
+      path_.push_back({*point(1), {}, false});
+      current_ = *point(1);
+    } else if (op == "l" && point(1)) {
+      add_segment(false, current_, current_, *point(1));
+    } else if (op == "c" && point(3)) {
+      add_segment(true, *point(3), *point(2), *point(1));
+    } else if (op == "v" && point(2)) {
+      add_segment(true, current_, *point(2), *point(1));
+    } else if (op == "y" && point(2)) {
+      add_segment(true, *point(2), *point(1), *point(1));
+    } else if (op == "h") {
+      close_subpath();
+    } else if (op == "re" && number(4)) {
+      double x = *number(4), y = *number(3), w = *number(2), h = *number(1);
+      path_.push_back({{x, y}, {}, false});
+      current_ = {x, y};
+      for (paths::Point p : {paths::Point{x + w, y}, paths::Point{x + w, y + h}, paths::Point{x, y + h}}) {
+        add_segment(false, current_, current_, p);
+      }
+      close_subpath();
+    } else if (op == "f" || op == "F" || op == "f*") {
+      paint(true, false);
+    } else if (op == "S") {
+      paint(false, true);
+    } else if (op == "s") {
+      close_subpath();
+      paint(false, true);
+    } else if (op == "B" || op == "B*") {
+      paint(true, true);
+    } else if (op == "b" || op == "b*") {
+      close_subpath();
+      paint(true, true);
+    } else if (op == "n") {
+      path_.clear();
+    } else if (op == "Do" && !operands_.empty() && operands_.back().isName()) {
+      draw_xobject(operands_.back().getName());
+    }
+    operands_.clear();
+  }
+
+  void handleEOF() override {}
+
+ private:
+  // The n-th numeric operand from the end (1 = the last), if there is one.
+  // (A copy of the handle: QPDF 11's accessors are not const.)
+  std::optional<double> number(size_t from_end) const {
+    if (operands_.size() < from_end) return std::nullopt;
+    QPDFObjectHandle operand = operands_[operands_.size() - from_end];
+    if (!operand.isNumber()) return std::nullopt;
+    return operand.getNumericValue();
+  }
+
+  // The n-th coordinate pair from the end (1 = the last two operands).
+  std::optional<paths::Point> point(size_t from_end) const {
+    auto x = number(2 * from_end);
+    auto y = number(2 * from_end - 1);
+    if (!x || !y) return std::nullopt;
+    return paths::Point{*x, *y};
+  }
+
+  // After h, a segment without a new m starts a new subpath at the closed one's start.
+  void add_segment(bool curve, paths::Point p1, paths::Point p2, paths::Point p3) {
+    if (path_.empty()) return;  // no current point
+    if (path_.back().closed) path_.push_back({current_, {}, false});
+    path_.back().segments.push_back({curve, {current_, p1, p2, p3}});
+    current_ = p3;
+  }
+
+  void close_subpath() {
+    if (path_.empty() || path_.back().closed) return;
+    paths::Subpath& subpath = path_.back();
+    paths::Point start = subpath.start;
+    if (std::hypot(current_.x - start.x, current_.y - start.y) > 1e-9) add_segment(false, current_, current_, start);
+    path_.back().closed = true;
+    current_ = start;
+  }
+
+  void paint(bool fill, bool stroke) {
+    std::optional<Box> box;
+    auto unite_with = [&](std::optional<Box> const& more) {
+      if (more) box = box ? unite(*box, *more) : *more;
+    };
+    if (fill) unite_with(paths::fill_bounds(path_, state_.ctm));
+    if (stroke) unite_with(paths::stroke_bounds(path_, state_.ctm, state_.stroke));
+    if (box) record(*box);
+    path_.clear();
+  }
+
+  // Line width, cap, join and miter limit set through an ExtGState (/LW /LC /LJ /ML).
+  void apply_ext_gstate(std::string const& name) {
+    QPDFObjectHandle states = resources_.isDictionary() ? resources_.getKey("/ExtGState") : QPDFObjectHandle::newNull();
+    QPDFObjectHandle gs = states.isDictionary() ? states.getKey(name) : QPDFObjectHandle::newNull();
+    if (!gs.isDictionary()) return;
+    if (gs.getKey("/LW").isNumber()) state_.stroke.width = gs.getKey("/LW").getNumericValue();
+    if (gs.getKey("/LC").isInteger()) state_.stroke.cap = gs.getKey("/LC").getIntValueAsInt();
+    if (gs.getKey("/LJ").isInteger()) state_.stroke.join = gs.getKey("/LJ").getIntValueAsInt();
+    if (gs.getKey("/ML").isNumber()) state_.stroke.miter_limit = gs.getKey("/ML").getNumericValue();
+  }
+
+  void draw_xobject(std::string const& name) {
+    QPDFObjectHandle xobjects = resources_.isDictionary() ? resources_.getKey("/XObject") : QPDFObjectHandle::newNull();
+    QPDFObjectHandle xobject = xobjects.isDictionary() ? xobjects.getKey(name) : QPDFObjectHandle::newNull();
+    if (!xobject.isStream()) return;
+    QPDFObjectHandle dict = xobject.getDict();
+    Extent extent;
+    if (dict.getKey("/Subtype").isNameAndEquals("/Image")) {
+      extent.add_box(state_.ctm, 0, 0, 1, 1);  // an image fills the unit square
+    } else if (dict.getKey("/Subtype").isNameAndEquals("/Form")) {
+      QPDFObjectHandle bbox = dict.getKey("/BBox");
+      if (!bbox.isArray() || bbox.getArrayNItems() != 4) return;
+      Matrix m = multiply(matrix_of(dict.getKey("/Matrix")).value_or(kIdentity), state_.ctm);
+      extent.add_box(m, bbox.getArrayItem(0).getNumericValue(), bbox.getArrayItem(1).getNumericValue(),
+                     bbox.getArrayItem(2).getNumericValue(), bbox.getArrayItem(3).getNumericValue());
+      walk_form(xobject, m);
+    }
+    if (!extent.empty()) record(extent.box());
+  }
+
+  // The form's own MCIDs, keyed by the form; it starts from the graphics state it is drawn with,
+  // and its resources default to the ones it is drawn with.
+  void walk_form(QPDFObjectHandle form, Matrix const& m) {
+    if (depth_ >= kMaxFormDepth || !active_.insert(form.getObjGen()).second) return;
+    QPDFObjectHandle resources = form.getDict().getKey("/Resources");
+    GraphicsState inner_state = state_;
+    inner_state.ctm = m;
+    BoundsCollector inner(page_, form.getObjGen(), resources.isDictionary() ? resources : resources_, out_,
+                          inner_state, active_, depth_ + 1);
+    form.parseAsContents(&inner);
+    active_.erase(form.getObjGen());
+  }
+
+  void record(Box const& box) {
+    int mcid = -1;
+    std::stack<int> copy = mcids_;
+    while (!copy.empty() && mcid < 0) {
+      mcid = copy.top();
+      copy.pop();
+    }
+    if (mcid < 0) return;
+    McidKey key{page_, owner_, mcid};
+    auto it = out_.find(key);
+    out_[key] = it == out_.end() ? box : unite(it->second, box);
+  }
+
+  QPDFObjGen page_;
+  QPDFObjGen owner_;
+  QPDFObjectHandle resources_;
+  McidBounds& out_;
+  std::vector<QPDFObjectHandle> operands_;
+  GraphicsState state_;
+  std::set<QPDFObjGen>& active_;
+  int depth_;
+  std::stack<GraphicsState> state_stack_;
+  std::stack<int> mcids_;
+  std::vector<paths::Subpath> path_;
+  paths::Point current_;
+};
+
+}  // namespace
+
+Box unite(Box const& a, Box const& b) {
+  return {std::min(a[0], b[0]), std::min(a[1], b[1]), std::max(a[2], b[2]), std::max(a[3], b[3])};
+}
+
+McidBounds find_mcid_bounds(QPDF& pdf) {
+  McidBounds bounds;
+  for (QPDFObjectHandle page : pdf.getAllPages()) {
+    QPDFPageObjectHelper helper(page);
+    McidBounds on_page;
+    std::set<QPDFObjGen> active;
+    BoundsCollector collector(page.getObjGen(), page.getObjGen(), helper.getAttribute("/Resources", false), on_page,
+                              GraphicsState{}, active);
+    helper.parseContents(&collector);
+
+    QPDFObjectHandle crop = helper.getCropBox();  // falls back to the MediaBox; never copies
+    for (auto& [key, box] : on_page) {
+      if (crop.isArray() && crop.getArrayNItems() == 4) {
+        box[0] = std::max(box[0], crop.getArrayItem(0).getNumericValue());
+        box[1] = std::max(box[1], crop.getArrayItem(1).getNumericValue());
+        box[2] = std::min(box[2], crop.getArrayItem(2).getNumericValue());
+        box[3] = std::min(box[3], crop.getArrayItem(3).getNumericValue());
+      }
+      // Content entirely outside the crop box is invisible: no bounds rather than an inverted box.
+      if (box[0] > box[2] || box[1] > box[3]) continue;
+      bounds[key] = box;
+    }
+  }
+  return bounds;
+}
+
+}  // namespace qpdf_ruby

data/ext/qpdf_ruby/mcid_bounds.hpp

@@ -0,0 +1,33 @@
+#pragma once
+#define POINTERHOLDER_TRANSITION 1
+
+#include <qpdf/QPDF.hh>
+#include <qpdf/QPDFObjGen.hh>
+
+#include <array>
+#include <map>
+#include <tuple>
+
+namespace qpdf_ruby {
+
+// [llx, lly, urx, ury] in default user space.
+using Box = std::array<double, 4>;
+
+// MCIDs are unique per content stream only: the page's own content, or a Form XObject's (which a
+// marked-content reference names with /Stm). Bounds are keyed by (page, stream, MCID); for the
+// page's own content the stream is the page itself.
+using McidKey = std::tuple<QPDFObjGen, QPDFObjGen, int>;
+using McidBounds = std::map<McidKey, Box>;
+
+// The area each piece of marked content paints: images, Form XObjects (their /BBox under their
+// /Matrix), filled paths and stroked paths with their line width, caps and joins (stroke_bounds.hpp),
+// under the full CTM (cm concatenates, q/Q save and restore the whole graphics state), clipped
+// to the page's crop box (content wholly outside it gets no entry). Text adds nothing: its extent
+// needs font metrics, so a Figure made only of text falls back to the crop box. Content belongs to
+// the innermost enclosing MCID of its own stream; a Form XObject's content is also walked, under its
+// /Matrix and the CTM it is drawn with, for the MCIDs numbered in that form.
+McidBounds find_mcid_bounds(QPDF& pdf);
+
+Box unite(Box const& a, Box const& b);
+
+}  // namespace qpdf_ruby

data/ext/qpdf_ruby/pdf_struct_walker.cpp

@@ -1,8 +1,8 @@
 #include "pdf_struct_walker.hpp"
 #include "struct_node.hpp"
 
-PDFStructWalker::PDFStructWalker(std::ostream& out, const std::unordered_map<int, std::array<double, 4>>& mcid2bbox)
-    : out(out), mcid2bbox(const_cast<std::unordered_map<int, std::array<double, 4>>&>(mcid2bbox)) {}
+PDFStructWalker::PDFStructWalker(std::ostream& out, qpdf_ruby::McidBounds bounds)
+    : out(out), mcid_bounds(std::move(bounds)) {}
 
 std::string PDFStructWalker::get_structure_as_string(QPDFObjectHandle const& node) {
   std::unique_ptr<StructNode> structNode = StructNode::fromQPDF(node);
@@ -19,28 +19,21 @@ void PDFStructWalker::ensureLayoutBBox(QPDFObjectHandle const& node) {
 void PDFStructWalker::buildPageObjectMap(QPDF& pdf) {
   pageObjToNumMap.clear();
   std::vector<QPDFObjectHandle> pages = pdf.getAllPages();
-  for (int i = 0; i < pages.size(); ++i) {
+  for (size_t i = 0; i < pages.size(); ++i) {
     // Map the page's object ID to its 1-based page number
-    pageObjToNumMap[pages.at(i).getObjGen()] = i + 1;
+    pageObjToNumMap[pages.at(i).getObjGen()] = static_cast<int>(i) + 1;
   }
 }
 
 const std::map<QPDFObjGen, int>& PDFStructWalker::getPageObjectMap() const { return pageObjToNumMap; }
 
 std::array<double, 4> PDFStructWalker::getPageCropBoxFor(QPDFObjectHandle const& page_oh) const {
-  auto inherited = [](QPDFObjectHandle node, char const* key) -> QPDFObjectHandle {
-    while (!node.isNull()) {
-      if (auto val = node.getKey(key); !val.isNull()) return val;
-      node = node.getKey("/Parent");
-    }
-    return QPDFObjectHandle();  // null ⇒ not found
-  };
-
-  QPDFObjectHandle crop = inherited(page_oh, "/CropBox");
-  if (crop.isNull()) crop = inherited(page_oh, "/MediaBox");  // spec default
-
-  std::array<double, 4> r;
-  for (size_t i = 0; i < 4; ++i) r[i] = crop.getArrayItem(i).getNumericValue();
-
+  // getCropBox() follows inheritance through the page tree and falls back to the MediaBox. Its
+  // arguments would copy an inherited box into the page - a write in what is a read.
+  QPDFObjectHandle crop = QPDFPageObjectHelper(page_oh).getCropBox();
+  std::array<double, 4> r = {0, 0, 0, 0};
+  if (crop.isArray() && crop.getArrayNItems() == 4) {
+    for (int i = 0; i < 4; ++i) r[i] = crop.getArrayItem(i).getNumericValue();
+  }
   return r;
 }

data/ext/qpdf_ruby/pdf_struct_walker.hpp

@@ -2,6 +2,8 @@
 
 #pragma once
 
+#define POINTERHOLDER_TRANSITION 1
+
 #include <qpdf/QPDF.hh>
 #include <qpdf/QPDFWriter.hh>
 #include <qpdf/QPDFPageObjectHelper.hh>
@@ -14,14 +16,16 @@
 #include <regex>
 #include <map>
 
+#include "mcid_bounds.hpp"
+
 class PDFStructWalker {
  private:
   std::ostream& out;
   std::map<QPDFObjGen, int> pageObjToNumMap;
-  std::unordered_map<int, std::array<double, 4>>& mcid2bbox;
+  qpdf_ruby::McidBounds mcid_bounds;
 
  public:
-  PDFStructWalker(std::ostream& out = std::cout, const std::unordered_map<int, std::array<double, 4>>& mcid2bbox = {});
+  explicit PDFStructWalker(std::ostream& out = std::cout, qpdf_ruby::McidBounds bounds = {});
 
   void buildPageObjectMap(QPDF& pdf);
   std::string get_structure_as_string(QPDFObjectHandle const& node);
@@ -30,5 +34,5 @@ class PDFStructWalker {
   const std::map<QPDFObjGen, int>& getPageObjectMap() const;
   std::array<double, 4> getPageCropBoxFor(QPDFObjectHandle const& elem) const;
 
-  const std::unordered_map<int, std::array<double, 4>>& getMcidBboxMap() const { return mcid2bbox; }
+  const qpdf_ruby::McidBounds& getMcidBounds() const { return mcid_bounds; }
 };