RT-DocLayout: Real-Time End-to-End Document Layout Analysis with Reading Order in the Wild¶

Conference: ECCV 2026
Paper: ECCV Official
Code: https://github.com/PaddlePaddle/PaddleOCR
Area: Object Detection
Keywords: document layout analysis, reading order prediction, end-to-end multi-task, pixel-level mask, real-time inference

TL;DR¶

RT-DocLayout unifies layout element classification, bounding-box regression, pixel-level segmentation, and reading order prediction inside a single query-based decoder built on RT-DETR, reaching the best full-document parsing accuracy on OmniDocBench v1.5 and Real5-OmniDocBench (94.50 / 92.05 Overall) with only 33M parameters, while running at 132.1 FPS on an A100 at batch size 32.

Background & Motivation¶

Document Layout Analysis (DLA) is the first stage of document intelligence: only after a page is cut into elements such as titles, body text, tables, formulas, and captions, and their order is determined, can a downstream OCR engine turn a two-dimensional page back into structured one-dimensional text. Deep learning has made layout element detection fairly mature, yet in real scenarios such as mobile photography or scans of bound volumes, pages are curled, bent, perspective-compressed, and rotated, and parsing quality still collapses quickly. The authors trace this back to two root causes: fragmented structural modeling and coarse geometric representation.

The two dominant lines of prior work each hit one of them. The first is the cascaded pipeline: a layout detector first boxes the elements, then a second-stage relation model (a GNN, or a heuristic sorter such as XYCut) infers the reading order. Localization errors propagate straight into the ordering stage, the two stages share no features, and the dependency between layout and topology is never learned. The second is the large pretrained Transformer and VLM route (LayoutLMv3, DiT, MinerU, Dolphin): accuracy goes up, but so does the compute bill — in the reported measurements MinerU2.5 runs at 2.4 FPS and Dolphin-v2 at 0.9 FPS. Worse, both families output axis-aligned rectangles: once the page is not captured fronto-parallel, a rectangle swallows background and neighbouring elements, so the downstream OCR receives a contaminated crop that no recognizer can repair.

The core tension therefore sits between geometric precision and efficiency: non-rigid deformation in real documents demands a pixel-level region representation, whereas existing systems offer either coarse rectangles (not precise enough) or a full generative model (not cheap enough). This paper's angle is to add to a real-time detector instead: RT-DETR is already a single-stage, NMS-free query-based detector, so pushing both pixel masks and reading order into the same set of object queries lets geometric precision and structural modeling be optimized on one shared feature set without paying for an extra model. Core idea: let every object query emit its class, box, pixel mask, and pairwise reading-order relations at once, decode the relation matrix into a single global sequence via an antisymmetric pairwise scorer plus voting-based ranking, and use a data augmentation that simulates paper deformation and camera projection to transfer this mask-level supervision to in-the-wild distorted documents.

Method¶

Overall Architecture¶

RT-DocLayout reformulates DLA as a mask-centric multi-task prediction problem. The input is a document image — a flat scan, or a phone photo of a curled, skewed, screen-captured page — and the output is a quadruple for every layout element: category, bounding box, pixel-level mask, and its absolute position in the reading order. The whole chain takes a single forward pass: the RT-DETR encoder extracts multi-scale features, \(N\) object queries are refined layer by layer in the decoder, and the refined queries feed parallel prediction heads — classification, box regression, mask generation, and a pairwise reading-order scorer — whose \(N \times N\) relation matrix is decoded into a unique global sequence by voting-based ranking. There is no NMS, no autoregressive decoding, and no external ordering model.

Compared with PP-DocLayoutV2, which is also built on RT-DETR, the differences concentrate in two places: a mask head is added and the pixel mask becomes a first-class output (the downstream OCR receives a region that hugs the element's true boundary rather than a rectangular crop), and reading order is moved from a decoupled pointer network outside the decoder into the decoder itself, so ordering and geometric localization share the same query features.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["Document image"] --> B["RT-DETR encoder<br/>multi-scale features"]
    B --> C["N object queries<br/>refined layer by layer"]
    C --> D["Mask-centric unified decoding<br/>class + box + pixel mask"]
    C --> E["Coupled reading order<br/>antisymmetric pairwise scoring + voting"]
    D --> F["Layout elements + reading order"]
    E --> F
    F --> G["Downstream OCR / parsing"]
    H["Physical spatial aware augmentation<br/>ISD surface warp + EPT projection"] -.->|training time| B

Key Designs¶

1. Mask-centric unified decoding: every query answers "what, where, and which pixels" at once

The failure of axis-aligned rectangles on distorted pages is visible: when a page is skewed or curled, the rectangle around a body-text block also covers background and the neighbouring block, so the OCR crop contains foreign content and the recognized text degrades. RT-DocLayout keeps the query-based detection paradigm — the decoder iteratively refines \(N\) object queries \(Q=\{q_i\}_{i=1}^{N}\), each encoding both spatial and structural semantics — but adds a mask output to every query so that a single query representation drives classification, box regression, and pixel segmentation simultaneously. Element boundaries are then no longer four axis-aligned edges but pixel-level regions that follow the actual deformation, and the input handed to the downstream OCR is purified.

Mask supervision follows MaskDINO: the BCE plus Dice loss on a mask is approximated by sampling \(K=12544\) points per mask, with 75% of them allocated to uncertain regions (typically near element boundaries). This sampling scheme is what keeps the design inside the real-time regime — it replaces dense per-pixel supervision with point sampling, so the mask head does not eat RT-DETR's speed advantage. A less obvious side benefit is that explicit pixel supervision forces the model to separate elements that sit tightly together or even overlap: replacing pure boxes with boxes plus masks lifts Overall on OmniDocBench v1.5 from 93.81 to 94.33. Those finer spatial cues are also the precondition for the augmentation in design 3 to do anything.

2. Coupled reading order prediction: put pairwise ordering inside the decoder and decode it by antisymmetric scoring plus voting

In cascaded systems reading order is an afterthought: PP-DocLayoutV2 appends a decoupled pointer network to RT-DETR, so the ordering module sees frozen boxes produced by the detector. Those boxes are already final — and possibly wrong — and the ordering module has no way to go back and fix the localization. The ablation quantifies the cost sharply: the decoupled ordering module yields a reading-order distance of 0.189 on OmniDocBench v1.5, far worse than the 0.041 of the coupled formulation here, and even worse than the plain XYCut heuristic (0.074). A separately trained ordering model operating on noisy boxes makes the order more confused, not less.

RT-DocLayout moves the ordering decision into the decoder itself. Refined queries are projected into a shared relational space, and the relative "who comes first" score between any two elements is a bilinear form:

\[S_{i,j}=\frac{(W_q q_i)^\top (W_k q_j)-(W_q q_j)^\top (W_k q_i)}{\sqrt{d_h}}\]

where \(W_q, W_k\) are learnable projections and \(d_h\) is the head dimension. The expression is antisymmetric by construction: swapping \(i\) and \(j\) flips the sign, so \(S_{i,j}=-S_{j,i}\) always holds. The relation matrix can never enter a self-contradictory state where \(i\) precedes \(j\) and \(j\) precedes \(i\) at the same time, and no extra symmetrization constraint is needed to repair it. \(S_{i,j}>0\) means element \(i\) comes before element \(j\).

At inference, turning pairwise relations into a global sequence uses voting rather than a greedy topological sort: for element \(j\), all incoming edges are passed through a sigmoid and summed to give its expected number of predecessors, \(V_j=\sum_{i=1}^{N}\sigma(S_{i,j})\) (with the diagonal set to zero), and the final order is the ascending sort of \(V_j\). This step is deterministic, non-autoregressive, and only \(O(N^2)\) — negligible for a page with a few dozen elements. It works because ordering and localization share the same query features: a query that misplaces a box is simultaneously contributing to the order scores, so the two are coupled through gradients, instead of one side failing while the other passively accepts it as in a cascade.

3. Physical spatial aware augmentation: transfer mask supervision to distorted documents via surface warping and camera projection

Public document datasets mostly provide axis-aligned boxes or flat polygon annotations; curling and perspective simply do not exist in them, so a model trained only on flat pages learns "masks" that are still rectangles. The insight here is to decompose real capture distortion into two physically meaningful processes and chain them into an online augmentation pipeline: first simulate the non-rigid deformation of the paper surface, then simulate the projective transformation induced by the camera viewpoint.

Stage one is Intrinsic Surface Deformation (ISD), aimed at non-rigid geometric priors such as page curling in bound volumes. It applies a mesh-style warp driven by smooth periodic displacement fields; for each pixel \((x,y)\):

\[x' = x + A\cdot f_x(\omega_y\cdot y)\cdot d_x,\qquad y' = y + A\cdot f_y(\omega_x\cdot x)\cdot d_y\]

where \(f_x, f_y \in \{\sin, \cos\}\) are sampled at random, the displacement amplitude \(A=\alpha\min(H,W)\) is proportional to image resolution, the spatial frequencies \(\omega_x=\beta\pi/W\) and \(\omega_y=\beta\pi/H\) are controlled by a uniformly sampled \(\beta\), and the directions \(d_x, d_y \in \{-1,1\}\) are flipped at random. Two modes are supported: a single-axis mode that displaces along one axis only (simulating unidirectional page curl) and an intense mode that displaces along both axes at once (simulating compound deformation). Images are resampled bilinearly and masks with nearest-neighbour interpolation, and border padding is computed dynamically from the maximum displacement so that no content is lost. Stage two is the Extrinsic Projective Transformation (EPT), which simulates hand-held viewpoint variation with a composite homography \(M = S\cdot R\cdot P\): \(P\) introduces perspective foreshortening through its projective parameters \(p_{20}, p_{21}\), while \(R\) and \(S\) account for in-plane rotation and shear. The final step is what makes the whole pipeline compatible with mask supervision — after the transformation the instance-level ground truth is re-derived by re-extracting axis-aligned boxes from the warped pixel-accurate masks, rather than transforming the original boxes, so box and mask labels stay self-consistent.

This augmentation is only meaningful together with masks: pixel-level masks remain exact under continuous deformation, so the supervision stays valid, whereas a box-only method attempting the same augmentation can only guess where the rectangle of a curled block should land — the annotation is already distorted before training starts. Its contribution is also the bluntest in the ablation: enabling it adds 4.57 points on the Warp subset and 14.11 points on the Skew subset.

Example: why one mis-scored adjacent pair does not derail the whole sequence¶

Consider a skewed photographed page with eight layout elements: header, title, body paragraph one, body paragraph two, table, figure, caption, footer. The decoder produces one query vector per element, pairwise scoring yields an \(8\times 8\) antisymmetric matrix, and summing each column (the edges pointing at that element) through a sigmoid gives eight expected predecessor counts.

In real documents the figure and its caption sit next to each other and the visual cues between them are weak, so suppose the scorer happens to get that one pair backwards. Under a greedy topological sort a single reversed edge is enough to create ambiguity or a deadlock; under voting, that pair only shifts the count by \(\pm1\), while the predecessor votes contributed by the other six elements are unchanged, so the caption's \(V\) still exceeds the figure's and the final sequence does not slip. This also explains why coupled scoring matters more than per-pair precision: \(O(N^2)\) weak judgements aggregated by summation average out individual noise.

In the same forward pass, the mask head returns not a rectangle but a quadrilateral region that hugs the skewed page, so the downstream OCR picks up no pixels from neighbouring blocks; and the ISD + EPT augmentation has already synthesized this kind of skewed, curled page many times during training, so the deformation in front of the model is one it has seen.

Loss & Training¶

The training objective is a weighted multi-task sum. The Hungarian algorithm first establishes the optimal bipartite matching between predictions and ground truth, and the losses are computed on that matching: \(\mathcal{L}_{\text{total}}=\sum_{k\in\mathcal{K}}\lambda_k\mathcal{L}_k\) with \(\mathcal{K}=\{\text{cls},\text{bbox},\text{giou},\text{mask},\text{dice},\text{order}\}\) and weights \(\lambda_{\text{cls}}=4\), \(\lambda_{\text{bbox}}=5\), \(\lambda_{\text{giou}}=2\), \(\lambda_{\text{mask}}=5\), \(\lambda_{\text{dice}}=5\), \(\lambda_{\text{order}}=50\). Classification uses focal loss (\(\alpha=0.25\), \(\gamma=2.0\)) against class imbalance, box regression uses \(\ell_1\) plus GIoU, and masks use BCE plus Dice with the point sampling described above.

The order loss carries the unusually high weight of 50 for two concrete reasons given by the authors. The first is gradient dilution: the order loss operates on \(O(N^2)\) element pairs, so each pairwise prediction receives gradients diluted by roughly a factor of \(N/2\), whereas the other losses are object-level and scale as \(O(N)\). The second is deep supervision: classification, detection, and segmentation all receive auxiliary losses from intermediate decoder layers (\(L\) decoder layers give \(L\) times the gradient updates), while the order loss is computed only at the final layer. Together, the weight has to be raised or the term barely trains.

The order loss itself gets two targeted treatments. One is locality-aware weighting: reading-order mistakes cluster between neighbouring elements, so pairs inside a dynamic neighbour window \(k=\max(5, 0.3N)\) receive a higher weight \(w_{\text{local}}=2.0\) (and 1 outside the window). The other is tolerance to annotation noise: generalized cross entropy (GCE, \(q=0.7\)) with label smoothing (\(\epsilon=0.01\)) replaces plain BCE so that isolated ambiguous annotations do not drag the gradients:

\[\mathcal{L}_{\text{order}}=\frac{1}{|P|}\sum_{(i,j)\in P} w_{i,j}\cdot \text{GCE}(S_{i,j}, T_{i,j})\]

where \(P\) is the set of valid upper-triangular pairs (diagonal excluded) and the target matrix is \(T_{i,j}=1\) if and only if the ground-truth order satisfies \(o_i<o_j\). Taking only the upper triangle follows directly from antisymmetry — the lower triangle is fully redundant.

The remaining setup: the model is initialized from PP-DocLayout_plus-L pretrained weights; the training corpus is an in-house set of 38k document images spanning academic papers, textbooks, market analysis, financial reports, slides, newspapers, supplementary teaching materials, exam papers, and invoices/receipts, manually annotated with 25 layout categories and their absolute reading order; the optimizer is AdamW with weight decay 0.0001 and a constant learning rate of \(2\times10^{-4}\) (the constant rate is stated to keep the antisymmetric scorer and the mask head converging stably); training runs for 150 epochs at a total batch size of 32.

Key Experimental Results¶

Main Results¶

Evaluation uses OmniDocBench v1.5 and the real-world-degradation-oriented Real5-OmniDocBench (with Scanning / Warping / Screen-Photography / Illumination / Skew subsets). Because no standard metric covers layout detection and reading order together, the paper scores everything by downstream parsing quality (Overall / TextEdit / FormulaCDM / TableTEDS / Reading Order Edit). The tables below show only the rows paired with the strongest downstream recognizer, PaddleOCR-VL-1.5-0.9B; results with the other recognizers are in the original Tables 1 and 2.

Layout analysis module	Params	FPS	Overall↑	TextEdit↓	FormulaCDM↑	TableTEDS↑	RO Edit↓
DocLayout-YOLO (+ XYCut ordering)	20M	107.4	87.29	0.127	88.74	85.83	0.169
MinerU2.5	1.2B	2.4	91.31	0.046	87.57	90.92	0.051
Dolphin-v2	3B	0.9	90.36	0.049	87.60	88.36	0.060
PP-DocLayoutV2	53M	110.9	93.56	0.034	92.09	92.03	0.042
RT-DocLayout	33M	132.1	94.50	0.035	94.21	92.76	0.042

Layout analysis module (+ PaddleOCR-VL-1.5-0.9B)	Overall↑	Scan↑	Warp↑	Screen↑	Illum↑	Skew↑
DocLayout-YOLO (+ XYCut ordering)	74.07	85.57	74.70	77.67	83.65	48.74
MinerU2.5	85.67	89.74	83.92	89.24	89.29	76.16
Dolphin-v2	67.66	88.66	52.58	81.06	66.15	49.84
PP-DocLayoutV2	85.83	92.04	86.00	83.28	90.80	77.03
RT-DocLayout	92.05	93.43	91.25	91.76	92.16	91.66

Ablation Study¶

The table below is taken from the original Table 4; for compactness only the Warp and Skew subsets are kept (Scan / Screen / Illum are in the original). All runs use PaddleOCR-VL-1.5-0.9B as the downstream recognizer.

Config	Localization	Ordering	Augmentation	OmniDoc O↑	OmniDoc RO↓	Warp O↑	Skew O↑	Skew RO↓
Boxes + heuristic ordering	bbox	XYCut	×	93.81	0.082	84.44	77.18	0.662
Boxes + masks + heuristic ordering	bbox+mask	XYCut	×	94.33	0.074	84.40	75.63	0.673
Boxes + masks + decoupled ordering	bbox+mask	Decoupled	×	93.87	0.189	85.91	76.24	0.325
Boxes + masks + coupled ordering	bbox+mask	Coupled	×	94.39	0.041	86.68	77.55	0.146
Full model	bbox+mask	Coupled	✓	94.50	0.042	91.25	91.66	0.061

To separate model design from training-data scale, PP-DocLayoutV2 was also retrained on the identical 38K in-house set and evaluated under exactly the same protocol:

Model (trained on the same 38K set)	Raw O↑	Raw RO↓	Warp O↑	Warp RO↓	Skew O↑	Skew RO↓
PP-DocLayoutV2 (53M)	93.56	0.174	84.67	0.236	75.28	0.320
RT-DocLayout (33M)	94.50	0.042	91.25	0.063	91.66	0.061

Key Findings¶

Masks alone give a moderate gain and cannot fix distortion by themselves. Swapping pure boxes for boxes plus masks lifts OmniDocBench v1.5 Overall from 93.81 to 94.33, but the Warp subset barely moves (84.44 → 84.40) and Skew actually drops (77.18 → 75.63). Pixel-level masks supply finer spatial cues; turning those cues into distortion robustness requires the augmentation to actually exploit them.
The augmentation is by far the largest lever in the wild, and it only pays off together with masks. Enabling it lifts Warp from 86.68 to 91.25 (+4.57) and Skew from 77.55 to 91.66 (+14.11) — the biggest jumps in the whole ablation — and reading order benefits too, with the Skew RO distance falling from 0.146 to 0.061. The reason is that masks stay exact under continuous deformation, while box ground truth is already distorted once the page is warped.
Decoupling the ordering module is not merely less useful — it is actively harmful. A separately trained ordering model yields an RO distance of 0.189 on OmniDocBench v1.5, more than double the XYCut heuristic (0.074), whereas joint optimization with detection and segmentation brings it down to 0.041 and cuts Warp from 0.721 (XYCut) to 0.092. This is the paper's most persuasive comparison: reading order is not something an extra module solves, because it depends on accurate localization and classification and must be trained together with perception.
The gains come from the design, not from data scale. Under the controlled same-data setup, PP-DocLayoutV2 reaches 93.56 / RO 0.174 on Raw and only 75.28 Overall / 0.320 RO on Skew, versus 94.50 / 0.042 and 91.66 / 0.061 for RT-DocLayout. With data scale equalized the gap remains, so mask-centric localization and coupled order optimization each contribute.
On efficiency the comparison crosses an order of magnitude. RT-DocLayout has fewer parameters than PP-DocLayoutV2 (33M vs 53M) yet the highest FPS (132.1); MinerU2.5 (1.2B) and Dolphin-v2 (3B) run at 2.4 FPS and 0.9 FPS — one to two orders of magnitude more parameters and one to two orders of magnitude slower.
The cost is small but real. The full model's RO distance on OmniDocBench v1.5 is 0.042, marginally above the 0.041 of the coupled variant without augmentation, and its TextEdit of 0.035 is slightly above PP-DocLayoutV2's 0.034. The improvement is holistic, but not every single metric improves monotonically.

Highlights & Insights¶

One query does four jobs, and the ordering score is self-consistent by construction. The antisymmetric scorer guarantees \(S_{i,j}=-S_{j,i}\) through the difference of two bilinear forms, baking consistency into the parameterization instead of repairing it in post-processing — far cleaner than training a symmetric matrix and averaging it. Any task that needs a global ranking from pairwise comparisons can reuse this block directly.
Voting-based ranking tolerates local errors. Compared with a greedy topological sort (where one reversed edge creates ambiguity or a deadlock), sorting by expected predecessor count aggregates all pairwise judgements into a scalar score and averages out noise on weak pairs. It is the same family of ideas as Bradley-Terry-style scoring used in language models, but computed from a single \(O(N^2)\) matrix in one forward pass.
The weight of 50 is not arbitrary — it has a gradient-level justification. Explaining it via "\(O(N^2)\) pairwise losses have their gradients diluted by roughly \(N/2\)" plus "the order loss receives no decoder deep supervision" is a reusable loss-balancing heuristic for any pairwise or set-level objective.
The crux of the augmentation is how the labels follow the transform. ISD uses periodic displacement fields to simulate curling and EPT uses a composite \(S\cdot R\cdot P\) homography for hand-held viewpoints, splitting distortion into intrinsic deformation and extrinsic projection; what actually makes the pipeline sound is the last step — boxes are re-extracted from the warped masks. Any mask-supervised augmentation should copy this ordering.
Transferable mechanisms: embedding an ordering head inside a detection decoder applies to other detection tasks with inherent order (UI screenshot element hierarchy and reading order, step order in flowcharts, cell reading order in tables) — in principle it needs only an antisymmetric scoring head plus voting on top of a DETR-style model. ISD + EPT also transfers to scene text detection and table structure recognition, where only flat polygon annotations exist.

Limitations & Future Work¶

The paper reports no direct geometric metric at all. There is no layout detection mAP, no mask IoU, and no reading-order accuracy; every conclusion rests on downstream parsing metrics (Overall / Edit / TEDS). The stated reason is the absence of a standard metric covering both layout detection and reading order, but this makes questions such as "how much more accurate is a mask than a box" unanswerable and complicates error attribution (when the downstream score drops, was it detection, ordering, or the recognizer?).
132.1 FPS is throughput at batch size 32, not single-image latency. No single-batch latency and no edge/mobile measurement are reported, even though real-time industrial deployment is the paper's selling point. For a real pipeline, 132 FPS throughput and 7.6 ms per image are not the same thing, especially when each page must then be fed serially into OCR.
The training data is not public. The 38k-image, 25-category in-house dataset is not released; the only reproducible entry points are the PP-DocLayout_plus-L pretrained weights and the PaddleOCR repository, so the controlled same-data numbers are hard to reproduce externally.
The coupling between the evaluation sets and the training distribution is not addressed. The training corpus covers exam papers, invoices, and slides, while OmniDocBench v1.5's evaluation dimensions are likewise concentrated on formulas, tables, and body text; the paper does not discuss whether same-source pages exist between the two. Nor are there directly comparable detection results on public layout datasets such as PubLayNet or DocLayNet.
Concrete improvements: report geometric metrics (mAP, mask IoU, order accuracy) even as an appendix; give per-image latency and quantized edge performance; and provide a training configuration reproducible from public data alone.

vs PP-DocLayoutV2: both build on RT-DETR and both target real-time document parsing. The differences are that this paper moves reading order from a pointer network outside the decoder into the decoder itself (the ablation shows the decoupled version's RO of 0.189 is worse than XYCut's 0.074) and adds a pixel-level mask head. The result is fewer parameters (33M vs 53M), higher speed (132.1 vs 110.9 FPS), and higher accuracy (94.50 vs 93.56 Overall). The disadvantage is that no geometric detection metric is reported, so the claim that masks beat boxes for every category cannot be verified.
vs DocLayout-YOLO: DocLayout-YOLO takes the YOLO speed route (20M / 107.4 FPS) and does not output reading order at all — evaluation must bolt on XYCut post-processing. That is tolerable on flat pages, but on the Skew subset of Real5 it collapses to 48.74 Overall, exposing the "fast detection without structural modeling" shortfall. This paper buys end-to-end ordering at a comparable FPS.
vs DLAFormer: also predicts layout regions and reading order jointly through a unified label space inside a DETR-based framework, the closest in spirit; but DLAFormer remains restricted to axis-aligned boxes and does not handle curling or perspective, which is where the mask and physical augmentation in this paper differ.
vs VLM parsers such as MinerU2.5 / Dolphin-v2 / dots.ocr: they produce structured full-page results and are more general, at the cost of 0.9-2.4 FPS and 1.2B-3B parameters. This paper positions itself as a front-end for such systems — the experiments show that placing RT-DocLayout ahead of MonkeyOCR, MinerU2.5, and Dolphin-v2 lifts all of their Overall scores, indicating that layout quality is a shared bottleneck for all of them.

Rating¶

Novelty: ⭐⭐⭐⭐ Unified query decoding plus antisymmetric scored ranking are combinations of existing ideas, but stringing mask-centric localization, coupled ordering, and physical augmentation together at real-time speed is a genuine design and engineering contribution.
Experimental Thoroughness: ⭐⭐⭐⭐ Two benchmarks, five degradation subsets, a same-data control, and a per-component ablation are solid; the one gap is the complete absence of geometric detection metrics and per-image latency.
Writing Quality: ⭐⭐⭐⭐ Method and motivation are clearly laid out and the loss weighting and deep-supervision trade-offs get a quantitative explanation; some equations are corrupted after OCR and the row attribution in Tables 1 and 2 needs checking against the original.
Value: ⭐⭐⭐⭐⭐ 33M parameters, 132.1 FPS, and lifting Skew from 75 to 91 in distorted scenarios is a drop-in win for industrial document parsing pipelines.