Feature request: ALTO output - integrate IDNEXT attribute

[M3ssman]

Your Feature Request

Description

Since 2004 ALTO XML supports the attribute IDNEXT for Block-like elements to represent the reading sequence on a page.
This a useful information to determine the order for layout quality evaluation purposes.

Please integrate this attribute in the output.

If it's already integrated, please show how it can be activated, since in recent stable Tesseract it's not serialized per default.

[markman123]

If it's already integrated

Based on a review of the current code, IDNEXT is not implemented, see
https://github.com/tesseract-ocr/tesseract/blob/main/src/api/altorenderer.cpp#L179-L204

Implementing this will require a "lookahead" mechanism to determine the next block's ID before emitting the current one. This pattern isn't used in other renderers, so it would be a new addition to the ALTO renderer.

The current ID is generated via GetID("cblock", page_number, bcnt++). To compute IDNEXT, we could call this again with the next counter value, but we'd need to ensure the next block actually exists before referencing it. Maintainer - any guidance on how we could handle this?

Other question would be - does this get put behind a cli flag

[M3ssman]

@markman123 Thanks for your reply and pointing to recent implementation!
I wasn't aware of the ResultIterator mechanics. Probably it needs some kind of look-a-head or it consumes more than one item at time, which requires additional memory to store these relations?

How does this interfere with switching reading direction in mixtures of LTR and RTL fonts? We need to deal with pages which contain mixtures of Arabic, Farsi and Hebrew together with usual European languages like German, English, French and Russian, mostly.

[markman123]

@M3ssman the plot thickens, didn't consider RTL. Looks like we need awareness of tesseract::WritingDirection, which i can see in the standard pagerenderer is defaulted to LTR.

Can we just use that (tesseract::WritingDirection)? And as you say, it could be a mixed document, so need a lookback (easier than look ahead as we can cache it in a variable)... new to this codebase, so learning :)

[M3ssman]

@markman123 IIUC, the schema for PAGE XML 2019 defines ReadingOrder elements, containing OrderedGroup/RegionRefIndexed.

For layout analysis it's important to identify top-level structs like columns and paragraphs (=regions). PAGE XML regions might be nested (rarely seen on the wild side). From a pragmatic point of view I guess it's sufficient to keep this information on region level only. This could probably ease LTR-RTL confusions that take place on line level, which arise when an singular english / german author or term is cited in an otherwise arabic text (or vice versa) - a common constellation in my data.

Might be done like @kba 's great tool page-to-alto, which sets region order on page level (@kba please correct me if I got it wrong)

[kashifeqbal]

Proposal: Add IDNEXT Attribute Support to ALTO Renderer

Thanks @markman123 and @M3ssman — confirmed that IDNEXT isn’t currently implemented in the ALTO renderer.
The renderer writes each block as soon as it’s processed, so there’s no notion of a “next” block available at write time.
See the block iteration section here:
https://github.com/tesseract-ocr/tesseract/blob/main/src/api/altorenderer.cpp#L179-L204

💡 Proposed Plan (Safe Addition Behind a Flag)

1. Add a renderer option include_idnext_ (default false) and CLI flag --alto_include_idnext.
2. Introduce a small one-block buffer:
   • When writing block B, we already have its ID (cblock_x).
   • Keep the previous block’s serialized start tag in memory.
   • Before writing B, finalize the previous block by adding IDNEXT="{B_id}".
   • For the last block, flush without IDNEXT.
3. Use tesseract::WritingDirection to preserve correct reading order on mixed-script pages (LTR/RTL).
   The iterator order already handles this in most cases, so no extra sorting needed.

🧩 Minimal Pseudo-Diff

// altorenderer.h
class TessAltoRenderer : public TessResultRenderer {
  bool include_idnext_ = false;
  // ...
};

// altorenderer.cpp (constructor)
TessAltoRenderer::TessAltoRenderer(const char* outputbase, bool include_idnext)
  : TessResultRenderer(outputbase, ...), include_idnext_(include_idnext) {}

// altorenderer.cpp (inside RIL_BLOCK loop)
std::string pending_block_xml;
std::string pending_block_id;

auto make_block_id = [&](int page_number, int bcnt) {
  return GetID("cblock", page_number, bcnt);
};

int bcnt = 0;
for (/* iterate blocks */) {
  std::string cur_id = make_block_id(page_number, bcnt++);
  std::string cur_start = FormatTextBlockStart(cur_id);

  if (!pending_block_xml.empty()) {
    if (include_idnext_) {
      InjectAttr(pending_block_xml, "IDNEXT", cur_id);
    }
    out << pending_block_xml;
    // ... write previous block content + end tag
  }

  pending_block_xml = cur_start;
  pending_block_id  = cur_id;
}

// flush last block (no IDNEXT)
if (!pending_block_xml.empty()) {
  out << pending_block_xml;
  // ... write content + end tag
}

⚙️ CLI Integration

• Add --alto_include_idnext in tesseractmain.cpp and pass it to TessAltoRenderer.
• Default: false (to avoid changing existing output).

If maintainers agree, I can prepare a PR with this implementation and tests for:

• LTR
• RTL
• Mixed-script pages
• Single-block pages (no IDNEXT expected)