WorksComputer Science
Prism: Hierarchical Text Detection with Minimalist Design
Abstract
Hierarchical text detection aims to localize words, text lines, and paragraphs while parsing their structural relationships. It provides essential structural cues for visual text understanding. To maximize accuracy, existing methods typically rely on complex multi-scale feature fusion necks and heavy-weight heads, resulting in bloated architectures and low inference efficiency. In this paper, we argue that a sufficiently pre-trained backbone can effectively replace these sophisticated external modules, while simple geometric inclusion suffices for hierarchical text structural parsing. Thus, we propose Prism, a minimalist framework for hierarchical text detection. Prism performs multi-granularity detection by attaching parallel lightweight heads to a single-scale backbone feature map, covering words, text lines, and paragraphs, and reconstructs the structural hierarchy via an efficient geometric inclusion algorithm. In addition, we systematically compare representative lightweight head archetypes and show that pixel-level regression offers the best accuracy-efficiency trade-off in this setting. Experiments on multiple public benchmarks show that our significantly simplified architecture achieves state-of-the-art (SOTA) performance with remarkable efficiency. Specifically, it runs faster than LRANet on CTW1500 while achieving higher accuracy, and surpasses the current SOTA method, OmniParser V2, by over 6 PQ points on the hierarchical HierText dataset. Code will be released soon.
Introduction
Text detection aims to localize textual instances in images. Hierarchical text detection goes one step further by detecting text at multiple granularities (e.g., words, lines, and paragraphs) and parsing their structural relationships. Such structured outputs provide richer layout information for text-rich natural scenes and electronic documents [10, 11]. However, an efficient and accurate hierarchical text detection framework remains lacking, limiting its applicability in many real-world scenarios.
To pursue higher accuracy, existing text detection methods typically adopt an “architectural stacking” paradigm at the expense of efficiency. Specifically, mainstream solutions rely on increasingly elaborate designs: 1) Complex Necks–the feature pyramid network (FPN) [21] and its variants (e.g., PANet [22], BiFPN [32]) have become the standard for handling multi-scale objects, and complex multi-scale deformable attention modules [42, 50] have also been widely adopted; 2) Heavy-weight Heads–bottom-up methods leverage computationally intensive high-resolution heads for precise pixel-level prediction [20, 43, 48], while top-down methods use multiple parallel heads [25, 31, 51] or global attention modules [2, 30, 35] to handle multi-scale text instances. Furthermore, for hierarchical text detection, complex relation-reasoning modules, such as the explicit word-to-line and line-to-paragraph relationship modeling in LayoutFormer [18], are typically needed to parse the structural inclusion across different text granularities.
We depart from this complexity-first paradigm and instead revisit text detection from a minimalist perspective, exploring whether a simple architecture can be sufficient when backed by strong pre-training. In general object detection, plain ViT [9] backbones pre-trained with MAE [13] have been shown to achieve competitive performance with simple multi-scale adaptation, as demonstrated by ViTDet [17]. This raises a natural question: can text detection be simplified even further? We base our minimalist design on three task-specific observations: 1) Text detection fundamentally targets a single foreground category composed of a finite set of structural primitives (e.g., strokes and characters). We thus hypothesize that a single-scale feature map from a sufficiently powerful, extensively pre-trained backbone is discriminative enough to render multi-scale fusion necks like FPN redundant. 2) Text detection is inherently a purely perceptual task that requires only intrinsic visual features of each text instance, without the need for complex semantic reasoning (e.g., differentiating headings from body text). Therefore, lightweight heads are likely sufficient for the final prediction. 3) The spatial layout of text inherently encodes its hierarchical inclusion. Thus, simple geometric calculations can naturally replace complex word-line-paragraph relation modules.
Building upon these insights, we propose Prism, a minimalist hierarchical text detection framework. True to its name, just as a prism refracts a single beam of light into a vibrant spectrum, Prism decomposes the single-scale feature into a diverse set of structural outputs, as illustrated in Figure 2. Specifically, it consists solely of a backbone and a set of parallel, lightweight expert heads built upon a single-scale feature map. Conceptually, this resembles a multi-expert architecture, with each head specializing in a specific task (e.g., word or line detection). Finally, we employ a box-approximation geometric inclusion algorithm to efficiently and accurately parse the hierarchical structure.

Figure 2. Visualization of Prism. Like a prism refracting light, our framework decomposes a single-scale feature into a rich spectrum of hierarchical outputs, spanning words, lines, paragraphs, and their geometric layouts.
To fully realize this minimalist framework, the design of the lightweight head is crucial. Thus, we categorize and systematically analyze lightweight implementations of four head archetypes: pixel-level regression (e.g., YOLO-style [37]), query-based regression (e.g., DETR-style [3]), pixel-level segmentation (e.g., DB-style [19]), and query-level segmentation (e.g., MaskFormer-style [5]). Our study shows that a pixel-level regression head, which explicitly leverages spatial priors and perceives instances holistically, achieves the best balance of accuracy and efficiency.
Owing to its minimalist design, Prism yields remarkable inference speed. As shown in Figure 1, Prism is faster than the leading real-time detector LRANet [29] while maintaining superior accuracy. Moreover, on the hierarchical dataset HierText [26], our method surpasses the SOTA Omniparser V2 [45] by at least 6% in Panoptic Quality (PQ).
Figure 1. Comparison between Prism and other mainstream text detection methods on Total-Text. (a) shows a breakdown of the inference time across different components for each method at a uniform input resolution of . (b) compares their F-measures, evaluated at each method’s optimal resolution. † denotes our method adopts sufficient pre-training.
The main contributions of this work are as follows:
We introduce a minimalist design paradigm for unified hierarchical text detection, demonstrating that as backbone models and pre-training data scale up, complex multi-scale necks and heavy heads become increasingly redundant.
We propose Prism, a simple framework that couples single-scale multi-granularity detection with parameter-free geometric inclusion, enabling efficient word-line-paragraph hierarchy parsing without multi-scale necks or learnable relation modules.
Extensive experiments over multiple challenging benchmarks show that Prism achieves superior detection accuracy and computational efficiency despite its significantly simplified architecture.
Related Work
Text detection has evolved from conventional document-oriented scenarios to more challenging in-the-wild settings, where text instances often exhibit arbitrary shapes, large scale variations, cluttered backgrounds, and complex illumination. According to the representation of text instances, existing methods can be broadly grouped into segmentation-based and regression-based approaches. We review these two families first, then discuss hierarchical text detection and recent minimalist detection designs that motivate our work.
Segmentation-Based Text Detection
Segmentation-based methods, mainly inspired by instance segmentation [1, 4, 5, 40], treat text detection as a segmentation problem. These methods have evolved along two primary paradigms: bottom-up pixel-level classification and top-down query-level mask prediction.
Pixel-level segmentation approaches typically predict dense pixel-wise segmentation maps, which are then grouped into individual text instances. For example, PSENet [39] reconstructs instance contours using a multi-scale kernel expansion strategy, while TextPMs [46] uses an iterative region growing algorithm. DB series [19, 20] introduce a groundbreaking differentiable binarization module to simplify post-processing. KAC [49] proposes a kernel adaptive convolution module to enhance segmentation results.
However, computationally intensive post-processing remains a bottleneck. For example, as shown in Figure 1, the post-processing stage of the highly-optimized DB++ [20] still accounts for more than 20% of the total inference time.
Query-level segmentation approaches address the aforementioned limitations from a top-down perspective. Following the instance segmentation method MaskFormer [5], they use a set of learnable object queries to predict the overall mask for each instance, and thus avoid the complex post-processing. For instance, DocSAM [16] introduces semantic queries to interact with standard instance queries to handle heterogeneous text detection, segmentation, and layout analysis tasks.
However, while simplifying the post-processing, the quality of mask prediction depends heavily on complex multi-layered Transformer decoders and multi-scale fusion necks.
Regression-Based Text Detection
Regression-based methods represent text instances as parameterized vectors for regression. Based on the positive sample assignment strategy, they can be divided into two main paradigms: pixel-level regression and query-level regression.
Pixel-level regression approaches typically perform pixel-by-pixel regression on feature maps and then use non-maximum suppression (NMS) to filter redundant prediction results. For example, ABCNet [24] adopts the Bernstein polynomial to transform the long sides of the text into Bezier curves, and performs regression using the FCOS [34] architecture. To fully exploit text shape relevance and reduce post-processing time, LRANet [29] proposes low-rank approximate text shape representations and a dual allocation strategy for positive samples.
Query-level regression approaches, pioneered by DETR [3], frame parameterized text shape regression as a set prediction problem with sparse positive samples, eliminating the need for NMS. For instance, DPText-DETR [42] proposes an explicit point-coordinate query modeling method to handle the varying scales and shapes of text instances. SRFormer [2] further introduces a segmentation branch in shallow layers to provide pixel-level priors.
Although they eliminate NMS, this does not inherently lead to superior efficiency, as the complexity is transferred to the heavy-weight Transformer decoder itself, which must perform a similar function of redundancy removal through its self-attention modules.
Hierarchical Text Detection
Hierarchical text detection aims to detect multi-granularity text and then perform geometric layout analysis. UniDec [26] first proposes unifying scene text detection and geometric layout analysis, using a query-level segmentation-based method to predict words, lines, and paragraphs, and an affinity matrix to determine paragraph grouping. LayoutFormer [18] introduces a unified framework with three parallel Transformer decoders (for words, lines, and paragraphs, respectively), complemented by modules that explicitly model word-to-line and line-to-paragraph relationships. DAT [36] proposes a cross-granularity interactive attention module for multi-granularity text detection. Moreover, OmniParser V2 [45] frames the task as a sequence generation problem, generating complete hierarchical relationships by inserting line and paragraph tags into its structured point sequences.
However, these approaches typically rely on complex multi-scale necks and heavy-weight heads, as well as intricate hierarchical modeling modules to reason about the relationships across different text granularities, leading to low efficiency, which is a core issue our work seeks to challenge.
Methodology
Minimalist Design Philosophy
Current text detection methods typically follow general object detection or segmentation paradigm, relying on multi-scale fusion necks to adapt to varying text scales and shapes, coupled with increasingly heavy-weight heads to refine predictions. However, this “complexity-first” consensus overlooks the first principles of text detection. Unlike general object detection, it is a single-category task without inter-class confusion, and image text is a structured visual pattern composed of a finite set of primitives such as strokes and characters.
Based on these first principles, we hypothesize that these elaborately designed necks and heavy heads are essentially crutches devised to mitigate the weak representational power of less capable backbones or those with limited pre-training. With the emergence of more powerful backbones and the availability of large-scale pre-training, this complexity may no longer be necessary. Thus, a text detection model requires only two indispensable components: an extensively pre-trained backbone for extracting generic features and a set of heads for mapping those features to specific task outputs. Furthermore, for hierarchical text detection, learnable relation reasoning modules are unnecessary, as natural geometric calculations of spatial relationships are sufficient to parse the structural layout.
This hypothesis presents a critical design choice: whether to integrate these task heads into the backbone or to separate them. We argue strongly for their separation. A task-agnostic backbone can learn more universal representations, while separate, task-specific heads provide crucial modularity and flexibility. This decoupled design supports features like on-demand task activation and avoids the need to retrain the entire model when adding new tasks. Thus, our architectural blueprint is a single backbone followed by parallel, lightweight, and independent heads for different text granularities.
Overall Framework
Following the design philosophy outlined above, the overall framework of Prism is radically simple, as illustrated in Figure 3. Prism utilizes only the single-scale feature map from a single deep stage of the backbone as the unified entry point for all subsequent tasks. True to its name, the framework operates like an optical prism: it maps this single feature representation to a spectrum of structured outputs through parallel lightweight heads. We refer to these granularity-specific heads as Expert Heads, as each one is responsible for a particular output level, such as word, text-line, or paragraph detection. Furthermore, a task-specific activation mechanism selectively routes features to the required heads, enabling flexible on-demand inference and targeted training on datasets with different annotations.
Figure 3. The overview of our Prism. It consists of only two main components: a backbone and a set of parallel, lightweight heads. “Task-specific activation” denotes selectively activating a specific expert head based on the required task configuration.
Notably, the selection of an appropriate output feature scale is key to the success of this minimalist design. Standard hierarchical backbones produce feature maps at various downsampling rates (e.g., 4x, 8x, 16x, 32x). Deeper features (e.g., 32x), while semantically rich, have a low spatial resolution that is detrimental to localizing small text instances. Conversely, shallower features (e.g., 4x or 8x) significantly increase the computational overhead of the subsequent prediction heads due to their large spatial size. Therefore, we adopt the downsampled feature map (e.g., the stage of ResNet) as the sole feature source. This scale strikes an ideal balance between semantic abstraction and spatial resolution, while also allowing for the truncation of deeper backbone stages to further reduce computational cost without compromising performance.
Finally, we adopt simple geometric calculations to parse hierarchical relationships. However, iterative intersection operations on irregular text contours are highly time-consuming, especially for dense predictions. To ensure high efficiency, we approximate the text instances with their minimum bounding boxes and calculate their intersection-of-sets (IoS). Crucially, rather than relying on complex polygon intersections, we reconstruct the structural hierarchy through a bottom-up sequence of vectorized box-level IoS calculations, establishing the layout (from words to lines, then lines to paragraphs) with remarkable efficiency.
Lightweight Head Archetypes
To identify a suitable lightweight head design for the proposed single-scale framework, we systematically explore four representative archetypes corresponding to mainstream detection paradigms.
Pixel-level regression head. As shown in Figure 4(a), this head consists of two parallel branches: a classification branch and a regression branch. Each adopts two convolutional layers to extract task-specific features. Following the dual-path scheme in [29], both branches are split into a dense text region (TR) path and a sparse sample region (SSR) path. The dense TR path provides ample supervision signals by treating all locations within the ground-truth text region as positive samples for contour coefficient regression, ensuring robust feature learning. In contrast, the sparse SSR path is dedicated to accelerating inference. Its positive samples are determined via the Hungarian algorithm, which strictly assigns one positive sample per instance to eliminate the time spent filtering redundant predictions. For each granularity, the same regression branch and assignment strategy are applied independently, while the prediction targets are derived from the corresponding word-, line-, or paragraph-level annotations.

Figure 4. Detailed architectures of the four lightweight head archetypes.
Pixel-level segmentation head. As shown in Figure 4(b), this head first upscales the input features by to recover spatial details, followed by two convolutional layers for refinement. Following [49], we predict four parallel maps: a text segmentation (TR) map, a distance map, and two pixel-wise direction maps (X and Y). The direction maps serve as auxiliary supervision during training to separate adjacent instances. During inference, only the TR and distance maps are utilized. Specifically, the text center region is extracted by thresholding the distance map, while the TR map acts as auxiliary information to filter false positives. Finally, these preserved centers are expanded to reconstruct the text contours.
Query-level regression head. As shown in Figure 4(c), this head adopts an encoder-only DETR-like paradigm. It first employs a lightweight convolutional branch to predict the top- (e.g., top-100) most salient center points from the feature map . These points are then encoded as a set of learnable queries with discriminative positional cues. To simplify the structure, these queries are concatenated with the flattened feature map to form a single, composite input sequence, enabling a “dual-path” optimization within a unified Transformer Encoder consisting of three layers. Specifically, unlike conventional DETR-like structures that utilize an encoder for visual features followed by a decoder for query refinement, our design achieves both functions within the single encoder. This structure allows the queries to attend to the full context of while simultaneously refining ’s own representations, effectively achieving an implicit cross-attention. This strategic simplification eliminates the need for a separate, heavyweight Transformer Decoder. Finally, the output features corresponding to the refined queries are fed into two parallel linear layers to generate the final classification and regression results.
Query-level segmentation head. As shown in Figure 4(d), this head adopts an encoder-only paradigm similar to that of our query-level regression head (Figure 4(c)). The key distinction lies in the output stage, where the regression branch is replaced by a MaskFormer-style segmentation module. Specifically, the refined query features are fed into a Linear layer for classification and an MLP to generate mask embeddings. Concurrently, the refined visual features are upscaled by to serve as high-resolution pixel embeddings. The final segmentation masks are generated via the dot product of the query-specific mask embeddings and the pixel embeddings. Notably, to accelerate convergence, the convolutional center-point prediction branches in both query-level heads (Figure 4(c)(Figure 4d)) are initialized with pre-trained weights from the pixel-level segmentation head.
Accordingly, we use the pixel-level regression head in Prism, with detailed quantitative justification provided in § 4.4.
Optimization and Post-processing
Mixed-Granularity Training. To effectively train our unified model on diverse datasets that often contain incomplete annotations (e.g., some datasets provide only word-level labels, while others provide only line-level labels), we adopt a mixed-granularity training strategy. The total training objective is defined as the conditional sum of task-specific losses for each granularity :
Here, is a binary indicator set to 1 if the ground-truth for granularity is present in the current sample, and 0 otherwise. This conditional objective allows Prism to seamlessly leverage datasets with incomplete or single-granularity annotations, while producing multi-granularity predictions within a unified model. In addition, the trained model can infer missing granularities on datasets without complete hierarchical labels, making it useful for pseudo-label generation.
Geometric Post-processing. During post-processing, Prism reconstructs the hierarchy using box-level geometric inclusion. The parsing is performed in a bottom-up manner with two successive assignment steps: word-to-line and line-to-paragraph. For both steps, we use the same Box-IoS criterion. Specifically, given a lower-level text box and a higher-level text box , we define their Box-IoS as
For each lower-level instance , we first find the higher-level candidate with the maximum Box-IoS:
The assignment is then accepted only when the maximum score exceeds a threshold :
By estimating inclusion at the box level, Prism computes all pairwise IoS scores in each assignment step as an matrix, where and denote the numbers of lower-level and higher-level instances, respectively. The row-wise maximum directly gives the parent assignments, reducing hierarchy parsing from words to lines and lines to paragraphs into two simple, parameter-free matrix operations.
Experiments
Datasets
HierText [26] is a large-scale dataset featuring hierarchical annotations for word, text-line, and paragraph positions. It contains 8,281 training, 1,724 validation, and 1,634 test images. Total-Text [6] is a key arbitrary-shaped text benchmark, containing 1,000 training and 255 test images. CTW1500 [23] is another arbitrary-shaped benchmark, providing 1,000 training and 500 test images annotated at the text-line level. MSRA-TD500 [41] is a multi-oriented dataset with 300 training and 200 test images. ArT [7] is a large-scale arbitrary-shaped text detection dataset, containing 5603 training images and 4563 test images. Synth150K [24] is a synthetic pre-training dataset, comprising about 150K images. ICDAR 2013 (IC13) [14] is a horizontal dataset that contains 229 training and 233 test images. ICDAR 2015 (IC15) [15] is a multi-oriented dataset with 1,000 training and 500 test images, labeled at the word-level. ICDAR17 MLT (MLT17) [27] is a large multi-language dataset providing 9,000 images for training. TextOCR [28] is a large real-world scene text dataset, composed of 21,749 training, 3,153 validation, and 3,232 test images.
Implementation Details
We utilize a simplified ResNet50-DCN backbone, truncated after the C4 stage, and adopt the pixel-level regression head (Figure 4(a)) as our default Expert Head. During training, we pre-train for 450K iterations on a mixture of Synth150K, IC13, IC15, MLT17, and TextOCR, using an ABCNet v2 recognition head for joint training. We use the AdamW optimizer (batch size 16) with an initial learning rate of 0.0001, which is decayed by a factor of 0.1 at 375K iterations. Then, we fine-tune for 300 epochs on each evaluated dataset. Data augmentations include RandomCrop, RandomRotate, RandomFlip, and ColorJitter. During inference, we resize the short sides of the input images to 704, 1000, 800, 1600, and 2048 for CTW1500, Total-Text, MSRA-TD500, ArT, and HierText, respectively, while keeping the original aspect ratio. The IoS threshold is set to 0.3. Inference is performed on a single NVIDIA RTX 3090 GPU. For the HierText dataset, we follow [26, 43] and adopt Panoptic Quality (PQ) and F-measure (F) as primary metrics to evaluate the detection and geometric layout performance.
Comparison with State-of-the-art Methods
Single-granularity Text Detection. We evaluate the performance of Prism on the most widely used benchmarks for single-granularity scene text detection, i.e., MSRA-TD500 and CTW1500 for text-line detection, and Total-Text and ArT for word detection. As shown in Table 1, Prism consistently demonstrates top-tier performance across these datasets. Specifically, on MSRA-TD500, our method outperforms the leading method MTD [12] by 1.1% (92.3% vs. 91.2%) in F-measure. On the arbitrary-shaped text benchmarks ArT and Total-Text, Prism also achieves SOTA performance with F-measures of 81.1% and 91.2%, respectively. Most importantly, Prism exhibits a significant advantage in inference speed. Benefiting from its minimalist design, it runs at 65.1 FPS on CTW1500, which is 1.7 faster than LRANet and 7.9 faster than SRFormer, establishing a new optimal trade-off between accuracy and efficiency.
| Method | MSRA-TD500 R | MSRA-TD500 P | MSRA-TD500 F | ICDAR19 ArT R | ICDAR19 ArT P | ICDAR19 ArT F | Total-Text R | Total-Text P | Total-Text F | CTW1500 R | CTW1500 P | CTW1500 F | FPS |
| PCR [8] | 83.5 | 90.8 | 87.0 | 66.1 | 84.0 | 74.0 | 82.0 | 88.5 | 85.2 | 82.3 | 87.2 | 84.7 | – |
| FSG [33] | 84.8 | 91.6 | 88.1 | – | – | – | 85.7 | 90.7 | 88.1 | 82.4 | 88.1 | 85.2 | – |
| TextPMs [46] | 87.0 | 91.0 | 88.9 | – | – | – | 87.7 | 90.0 | 88.8 | 83.8 | 87.8 | 85.7 | 14.4 |
| DB++ [20] | 83.3 | 91.5 | 87.2 | – | – | – | 83.2 | 88.9 | 86.0 | 82.8 | 87.9 | 85.3 | 38.3 |
| TPSNet [38] | – | – | – | 73.3 | 84.3 | 78.4 | 86.8 | 89.5 | 88.1 | 85.1 | 87.7 | 86.4 | 17.9 |
| TextBPN++ [47] | 86.8 | 93.7 | 90.1 | 77.1 | 84.5 | 80.6 | 87.9 | 92.4 | 90.1 | 84.7 | 88.3 | 86.5 | 13.9 |
| DPText-DETR [42] | – | – | – | 73.7 | 83.0 | 78.1 | 86.4 | 91.8 | 89.0 | 86.2 | 91.7 | 88.8 | 14.8 |
| SRFormer [2] | – | – | – | 73.5 | 86.1 | 79.3 | 87.9 | 91.5 | 89.7 | 89.8 | 89.4 | 89.6 | 8.2 |
| LRANet [29] | 86.3 | 92.3 | 89.2 | – | – | – | 87.8 | 90.3 | 89.0 | 85.5 | 89.4 | 87.4 | 37.2 |
| LayoutFormer [18] | 88.3 | 92.0 | 90.1 | – | – | – | 85.0 | 89.3 | 87.1 | 84.3 | 88.2 | 86.2 | – |
| KAC [49] | 88.1 | 93.9 | 90.8 | 77.3 | 83.0 | 80.0 | 88.1 | 94.1 | 91.0 | 85.4 | 88.6 | 86.8 | – |
| FastTCM-TESTR [44] | – | – | – | – | – | – | – | – | 89.0 | – | – | 87.4 | – |
| DAT-DET [36] | 86.6 | 95.1 | 90.7 | – | – | – | 88.2 | 94.0 | 91.0 | 89.3 | 89.3 | 89.3 | – |
| ERRNet [30] | 87.1 | 93.8 | 90.3 | 75.5 | 84.1 | 79.6 | 87.3 | 92.6 | 89.9 | 87.9 | 91.0 | 89.4 | 31.5 |
| DocSAM [16] | – | – | – | – | – | – | 82.6 | 72.1 | 77.0 | 88.1 | 80.5 | 84.2 | – |
| MTD [12] | 88.0 | 94.6 | 91.2 | – | – | – | 87.1 | 90.1 | 88.6 | 87.1 | 90.2 | 88.6 | – |
| OmniParser V2 [45] | – | – | – | – | – | – | 88.2 | 90.6 | 89.4 | 87.1 | 89.7 | 88.4 | – |
| Prism | 89.5 | 95.3 | 92.3 | 77.9 | 84.6 | 81.1 | 89.6 | 92.9 | 91.2 | 88.5 | 92.0 | 90.2 | 65.1 |
Table 1. Scene text detection results on typical benchmarks. All FPS values are uniformly measured using a single NVIDIA RTX 3090 GPU.
Hierarchical Text Detection. We compare Prism with existing frameworks on the challenging HierText test and validation sets (Table 2). Despite its minimalist design, Prism achieves a significant lead over existing methods that rely on complex architectures. On the test set, Prism surpasses the SOTA OmniParser V2 by substantial margins across all hierarchical levels: +14.2% in Word PQ (75.8 vs. 61.6), +6.6% in Line PQ (71.1 vs. 64.5), and +11.6% in Paragraph PQ (66.8 vs. 55.2). This gap stems primarily from three factors (with detailed ablations in Sec. 4.4). First, hierarchical relationships can be naturally derived from detection outputs (words, lines, paragraphs) through simple post-processing. Unlike methods such as LayoutFormer [18] that use relationship prediction modules and thus risk propagating cumulative errors, we obtain them by directly calculating the intersection-of-sets (IoS) between the minimum bounding boxes of the level-specific predictions, which is also highly efficient due to parallelization. Second, previous methods all adopt query-level heads; however, pixel-level heads have clear superiority over query-based ones for this task. Finally, our lightweight architecture allows us to efficiently adopt high-resolution inputs (). This is crucial because HierText contains a massive number of dense, small text instances that require high resolution for accurate detection.
| Method | Validation Set Word PQ | Validation Set Word F | Validation Set Line PQ | Validation Set Line F | Validation Set Para. PQ | Validation Set Para. F | Test Set Word PQ | Test Set Word F | Test Set Line PQ | Test Set Line F | Test Set Para. PQ | Test Set Para. F |
| UniDec [26] | 48.5 | 61.7 | 61.3 | 78.7 | 52.9 | 67.7 | 48.2 | 61.5 | 62.2 | 79.9 | 53.6 | 68.6 |
| LayoutFormer [18] | – | – | – | – | – | – | 49.2 | 64.9 | 46.2 | 60.7 | 43.0 | 56.4 |
| Hi-SAM-B [43] | 59.2 | 77.5 | 62.9 | 81.4 | 55.7 | 72.6 | 59.7 | 78.3 | 63.3 | 82.2 | 54.5 | 71.2 |
| Hi-SAM-L [43] | 62.6 | 81.0 | 65.6 | 84.0 | 58.8 | 75.8 | 63.1 | 81.8 | 66.2 | 84.9 | 57.6 | 74.5 |
| Omniparser V2 [45] | 60.0 | – | 63.4 | – | 55.9 | – | 61.6 | – | 64.5 | – | 55.2 | – |
| Prism | 75.3 | 90.1 | 70.6 | 85.9 | 67.6 | 82.2 | 75.8 | 90.4 | 71.1 | 86.0 | 66.8 | 81.4 |
Table 2. Hierarchical text detection results on the HierText dataset.
Ablation Study
Pre-training. Compared to the leading real-time method LRANet [29], Prism adopts a lighter head, discards the FPN, and truncates the backbone at C4. As shown in Table 3, when training from scratch, Prism lags LRANet by 1.6% in F-measure. This deficit arises because all representation pressure is concentrated onto the single C4 feature map, demanding sufficient pre-training to learn robust representations for varying text scales and shapes. Thus, with more pre-training data, the performance gap incrementally shrinks. Crucially, our model surpasses LRANet when utilizing End-to-End (E2E) Training (joint training with a recognition head), achieving an F-measure of 91.2% compared to LRANet’s 91.0%. This is attributed to the fine-grained semantic information introduced by E2E training, which compels the heavily tasked C4 feature to become more discriminative. We further verify this finding on Vision Transformer (ViT) architectures using the challenging HierText dataset. As shown in Table 5(b), when using a ViT-B backbone without pre-training, Prism noticeably underperforms LRANet. Yet, under the full pre-training setup, Prism closes this gap, matching or slightly exceeding LRANet across all hierarchical levels. Overall, these experiments demonstrate that rich pre-training (including both training data and training paradigms) is the essential prerequisite for our minimalist architecture.
| Pre-train Data | Method | Total-Text | CTW1500 | ||||
| R | P | F | R | P | F | ||
| None | LRANet | 85.7 | 90.5 | 88.1 | 84.9 | 89.1 | 86.9 |
| Ours | 84.7 | 88.3 | 86.5 | 83.5 | 86.1 | 84.8 | |
| + Synth150K | LRANet | 87.8 | 90.3 | 89.0 | 85.5 | 89.4 | 87.4 |
| Ours | 87.1 | 89.5 | 88.3 | 85.6 | 87.5 | 86.5 | |
| + IC13, IC15, MLT17 | LRANet | 87.6 | 90.9 | 89.2 | 87.8 | 89.9 | 88.8 |
| Ours | 88.1 | 90.0 | 89.0 | 87.1 | 90.0 | 88.5 | |
| + TextOCR | LRANet | 88.1 | 91.2 | 89.6 | 88.5 | 90.5 | 89.5 |
| Ours | 88.3 | 90.9 | 89.6 | 88.3 | 90.5 | 89.4 | |
| + E2E Training | LRANet | 89.7 | 92.3 | 91.0 | 88.8 | 91.7 | 90.2 |
| Ours | 89.6 | 92.9 | 91.2 | 88.5 | 92.0 | 90.2 |
Table 3. Pre-training. Ablation study of pre-training setups on Total-Text and CTW1500. E2E training means adding a recognition head for joint training.
| Backbone | Model | Word PQ | Line PQ | Para. PQ |
| ViT-T | LRANet | 69.8 | 64.5 | 59.8 |
| Ours | 66.7 | 61.1 | 55.6 | |
| ViT-S | LRANet | 73.4 | 67.7 | 63.5 |
| Ours | 72.6 | 66.7 | 62.3 | |
| ViT-B | LRANet | 76.3 | 71.2 | 66.6 |
| Ours | 76.3 | 71.4 | 66.7 | |
| Pretrain | Model | Word PQ | Line PQ | Para. PQ |
| None | LRANet | 73.2 | 68.4 | 63.5 |
| Ours | 71.8 | 66.9 | 62.0 | |
| Synth150K | LRANet | 74.9 | 69.8 | 65.1 |
| Ours | 74.5 | 69.2 | 64.6 | |
| Full | LRANet | 76.3 | 71.2 | 66.6 |
| Ours | 76.3 | 71.4 | 66.7 |
Table 5. Backbone capacity and pre-training on ViT. (a) Backbone scaling with the full pre-training setup from Table 3. (b) Pre-training ablation using ViT-B.
Backbone Capacity. We evaluate our hypothesis that a powerful backbone is the core prerequisite for minimalist design across both CNN and Transformer architectures. As shown in Table 4, when employing lighter backbones such as ResNet18 and ResNet50, Prism’s F-measure significantly lags LRANet. This deficit is mainly due to insufficient feature representation ability in these backbones, where LRANet’s multi-scale neck and multi-layer heads act as compensatory mechanisms to cover this shortfall. However, as the backbone is enhanced, these compensatory mechanisms become redundant, as our method achieves comparable performance with LRANet when using ResNet50-DCN. Crucially, our minimalist architecture maintains a substantial efficiency advantage, requiring less than half the parameters and GFLOPs of LRANet while delivering a inference speedup (65.1 vs. 37.2 FPS). Interestingly, further scaling to ResNet101-DCN yields negligible gains for both methods, suggesting ResNet50-DCN already provides sufficient feature discriminativeness for the purely perceptual task of text detection. This scaling law generalizes to Vision Transformers (Table 5(a)): while Prism noticeably trails LRANet with a ViT-T backbone (66.7% vs. 69.8% Word PQ), scaling to ViT-B entirely eliminates this gap, confirming that a capable backbone intrinsically renders sophisticated necks obsolete.
| Backbone | Method | Params (M) | GFLOPs | FPS | Total-Text | CTW1500 |
| F | F | |||||
| ResNet18 | LRANet | 18.0 | 62.1 | 65.4 | 84.5 | 83.1 |
| ResNet18* | Ours | 5.9 | 18.4 | 158.6 | 79.3 | 77.7 |
| ResNet50 | LRANet | 31.0 | 81.9 | 40.5 | 87.8 | 86.5 |
| ResNet50* | Ours | 11.8 | 34.1 | 78.6 | 85.2 | 83.7 |
| ResNet50-DCN | LRANet | 32.7 | 97.2 | 37.2 | 91.2 | 90.3 |
| ResNet50-DCN* | Ours | 12.8 | 48.3 | 65.1 | 91.2 | 90.2 |
| ResNet101-DCN | LRANet | 53.8 | 144.8 | 26.3 | 91.5 | 90.4 |
| ResNet101-DCN* | Ours | 33.9 | 95.5 | 37.1 | 91.6 | 90.4 |
Table 4. Backbone Capacity. Influence of different backbone networks. All models use the full pre-training setup (i.e., the E2E Training setting in Table 3). * means truncation of C5. GFLOPs and FPS are evaluated at a short-side resolution of 704.
Expert Head. In Table 7, we evaluate four lightweight head archetypes discussed in § 3.3. To accommodate the massive number of dense text instances in HierText, we set the number of queries in query-level heads to 500, 300, and 100 for word, line, and paragraph detection, respectively. However, query-level heads consistently and substantially underperform their pixel-level counterparts. This is primarily because optimizing such a large set of queries for tiny, densely packed instances remains a significant challenge. Moreover, the global interaction of query-level heads offers limited benefits for this purely perceptual task, as text detection mainly relies on local patterns rather than contextual reasoning. Such interaction may be more suitable for logical layout analysis (e.g., distinguishing footers from body text). In contrast, pixel-level heads can fully leverage the explicit local spatial priors on the feature map, which is better suited to text detection. Of the two pixel-level variants, the regression head has a clear advantage, achieving the highest performance across all granularities: Word (75.8 PQ), Line (71.1 PQ), and Paragraph (66.8 PQ). This superiority is mainly because of its holistic instance perception. Compared to the complex bottom-up pixel grouping required by Pixel-Seg, holistic regression is a more natural and effective paradigm for predicting boundaries directly from the highly abstract C4 feature map. Consequently, we adopt Pixel-Reg as the default head instantiation for Prism.
| Type | Word PQ | Word F | Line PQ | Line F | Para. PQ | Para. F | Head |
| Query-Seg. | 65.7 | 82.8 | 60.5 | 77.3 | 55.4 | 71.2 | 27.2 |
| Query-Reg. | 67.9 | 85.1 | 63.3 | 80.5 | 58.2 | 74.9 | 24.8 |
| Pixel-Seg. | 73.1 | 88.5 | 67.3 | 83.2 | 62.5 | 77.7 | 20.6 |
| Pixel-Reg. | 75.8 | 90.4 | 71.1 | 86.0 | 66.8 | 81.4 | 16.1 |
Table 7. Head design. Comparisons of different lightweight heads in Figure 4 on HierText test set.
Hierarchy Parsing. As Table 8 shows, due to hierarchical inclusion being naturally encoded in spatial layouts, simple geometric post-processing yields inherently higher accuracy than a strong learnable module (illustrated in Figure 5). Specifically, we construct this strong baseline to explicitly model the structural hierarchy. It first selects top-scoring initial predictions and constructs queries by injecting level-specific embeddings and positional encodings. These queries are then iteratively refined through a complex decoding block repeated 6 times. Each block comprises independent self-attention within each granularity, unified self-attention to model cross-granularity context, and cross-attention interacting with the backbone feature map. Finally, the features of adjacent levels (e.g., word-line and line-paragraph pairs) are fused via element-wise multiplication and processed by an MLP-based relation head to explicitly predict their affiliations. However, such an intricate design is redundant and prone to cumulative errors.
| Hierarchy Parsing | Word | Line | Para. | Latency (ms) | |||
| PQ | F | PQ | F | PQ | F | Parsing Time | |
| Learnable Module | 74.7 | 89.2 | 69.1 | 83.9 | 64.7 | 79.2 | 8.5 |
| Polygon-level IoS | 75.8 | 90.4 | 71.3 | 86.2 | 66.9 | 81.6 | 32.4 |
| Box-level IoS | 75.8 | 90.4 | 71.1 | 86.0 | 66.8 | 81.4 | 1.2 |
Table 8. Hierarchy parsing. Comparisons of different hierarchical relationship parsing strategies on HierText test set.
Figure 5. Detailed architecture of the learnable relation module used for comparison against our parameter-free geometric hierarchy parsing.
Instead of relying on heavyweight learnable modules, we leverage geometric calculations. However, since text instances are arbitrarily shaped, directly computing exact polygon intersections (Polygon-level IoS) is highly time-consuming. By adopting the Box-level IoS approximation, the accuracy loss is practically negligible (e.g., only a 0.1% drop in Line PQ). To further validate the effectiveness of the box-level approximation, we compare polygon-level and box-level IoU computation in NMS on a highly curved subset of CTW1500, following the subset definition in [30]. As shown in Table 10, box-level IoU achieves nearly identical detection performance to polygon-level IoU, indicating that the box approximation introduces negligible accuracy loss even in this challenging setting. More importantly, this approximation transforms complex geometric calculations into parallelized matrix operations, substantially improving the processing speed and reducing latency to 1.2 ms.
| IoU | R | P | F |
| Polygon-level | 85.3 | 87.8 | 86.5 |
| Box-level | 85.1 | 87.8 | 86.4 |
Table 10. Comparison of polygon-level and box-level IoU computation for NMS on a highly curved subset of CTW1500.
Unified vs. Separate. In Table 9, we compare our unified learning paradigm against training three independent models for word, line, and paragraph detection, respectively. The unified model consistently outperforms the separate baseline across all metrics. We attribute this to two factors: 1) Hierarchical Synergy: Text entities exhibit inherent physical inclusion constraints (e.g., lines encompass words). Joint training allows the model to implicitly internalize these constraints, utilizing high-level context to verify and refine low-level
| Method | Word | Line | Para. | |||
| PQ | F | PQ | F | PQ | F | |
| Separate | 75.6 | 90.2 | 70.8 | 84.2 | 66.5 | 79.8 |
| Unified | 75.8 | 90.4 | 71.1 | 86.0 | 66.8 | 81.4 |
Table 9. Unified vs. Separate Paradigms. Comparison on the HierText test set. “Separate” denotes adopting three independent models for each granularity detection.
Visualization Analysis
detections. 2) Geometric Consistency: Since layout analysis depends heavily on the spatial alignment between granularities, sharing a unified feature encoder ensures that predictions for words and lines are spatially coherent, thereby reducing matching errors. Furthermore, the unified framework is inherently more concise and parameter-efficient.
Choice of Backbone Feature Map. In Table 11, we investigate the optimal single-scale feature map from the ResNet50-DCN backbone by comparing the , , and outputs. As observed, the high-resolution feature map yields a lower paragraph-level F-measure due to its limited receptive field. Conversely, the feature map suffers from a lower word-level F-measure owing to its low spatial resolution. The feature map effectively balances resolution and receptive field, achieving the highest F-measure across all granularities. Interestingly, while achieves a higher paragraph F-measure than (77.3 vs. 74.9), its paragraph Panoptic Quality (PQ) is actually lower (61.1 vs. 62.2). This discrepancy occurs because ’s low resolution drastically degrades word-level detection, which subsequently propagates errors up the bottom-up hierarchical parsing. Additionally, extracting requires deeper backbone computations, whereas imposes a heavy computational burden on the detection heads due to its large spatial dimensions. As a result, the centrally positioned achieves the fastest inference speed. In summary, serves as the optimal compromise between accuracy and efficiency.
| Feat. | Word | Line | Para. | FPS | |||
| PQ | F | PQ | F | PQ | F | ||
| 75.0 | 89.6 | 69.6 | 83.7 | 62.2 | 74.9 | 8.0 | |
| 75.8 | 90.4 | 71.1 | 86.0 | 66.8 | 81.4 | 8.1 | |
| 68.0 | 86.1 | 64.8 | 82.0 | 61.1 | 77.3 | 7.4 |
Table 11. Backbone feature selection. Comparisons of different single-scale backbone feature maps on the HierText test set. , , and represent features at 1/8, 1/16, and 1/32 scales, respectively.
Input Image Size. In Table 6, we investigate the impact of input image scale. As the short-side length increases from 1,024 to 2,048, performance improves substantially, especially for the Word PQ metric (rising from 65.2% to 75.8%). This is mainly because the HierText dataset contains a vast number of small-scale text instances. Increasing feature resolution is indispensable for accurately extracting such tiny text features. In this regard, our minimalist architecture holds a significant computational advantage compared to other methods.
| Scale | Word PQ | Word F | Line PQ | Line F | Paragraph PQ | Paragraph F | Backb. | Head | Post. | FPS |
| S: 1024 | 65.2 | 82.5 | 63.2 | 79.6 | 60.9 | 76.8 | 26.7 | 4.8 | 2.1 | 29.7 |
| S: 1536 | 72.6 | 88.5 | 69.6 | 84.8 | 66.6 | 81.0 | 61.3 | 9.8 | 2.2 | 13.6 |
| S: 2048 | 75.8 | 90.4 | 71.1 | 86.0 | 66.8 | 81.4 | 104.7 | 16.1 | 2.3 | 8.1 |
Table 6. Input size. Performance comparison on HierText test set. “S:” means the length of the shorter side, and the original aspect ratio is maintained.
Visualization Analysis
To intuitively demonstrate the effectiveness, robustness, and generalization capability of Prism, we conduct a comprehensive qualitative analysis across multiple benchmarks.
As illustrated in Figure 6, we first visualize the multi-granularity detection results on the HierText test set. In complex document layouts or natural scenes with dense, small text instances, Prism accurately localizes visual text across words, lines, and paragraphs, and parses their topological inclusion relationships via the proposed Box-level IoS algorithm. This demonstrates that minimalist geometric post-processing can effectively replace heavy relation-reasoning modules.

Figure 6. Visualization results of Prism on HierText test set.
Furthermore, we evaluate Prism on standard single-granularity scene text detection benchmarks, including CTW1500, Total-Text, ICDAR19 ArT, and MSRA-TD500. As shown in Figure 8, our method accurately detects text instances that exhibit challenging attributes, such as extreme length, high curvature, vertical orientation, or tiny scales. In particular, on CTW1500, tiny text instances are precisely localized even at a short-side resolution of 704. This robust performance demonstrates that our single-scale feature representation captures sufficient discriminative details to handle diverse shapes and scales without requiring multi-scale feature pyramids.
Figure 8. Visualization results of Prism on scene text detection benchmarks: CTW1500, Total-Text, ICDAR19 ArT, and MSRA-TD500.
Benefiting from our mixed-granularity training strategy, Prism exhibits strong generalization capabilities. While many existing datasets only provide single-granularity annotations, Prism can seamlessly predict the missing hierarchical levels. As illustrated in Figure 7, it can generate precise word-level boundaries for highly stylized and dense text, accurately group scattered elements into coherent lines, and successfully cluster multiple lines into logical paragraphs despite complex background interference. This capability significantly enhances the practical value of our model, enabling the automatic refinement of incomplete annotations in real-world applications.

Figure 7. Visualization of multi-granularity pseudo-labels generated by Prism. Note that these datasets do not have annotations for these specific granularities.
Conclusion
In this paper, we propose Prism, a minimalist hierarchical text detection framework. By systematically re-evaluating the necessity of complex architectural components, we demonstrate that a single-scale feature map, empowered by a sufficiently powerful and extensively pre-trained backbone, can provide a competitive and efficient alternative to traditional multi-scale necks and heavy heads. Moreover, our empirical study of four lightweight head archetypes concludes that a simple pixel-level regression head provides the best accuracy-efficiency trade-off for this setting. To parse the multi-granularity relationships, Prism reconstructs the structural hierarchy through a simple yet highly efficient geometric inclusion algorithm. Given its extreme simplicity, we hope that Prism can naturally serve as a plug-and-play detection extension for emerging large vision-language models (VLMs) and encourages future research to shift focus from intricate architectural engineering toward a deeper exploration of backbone networks and pre-training.
References
References
- [1]Daniel Bolya, Chong Zhou, Fanyi Xiao, and Yong Jae Lee. Yolact: Real-time instance segmentation. In ICCV, pages 9157–9166, 2019.arxiv.org/abs/1904.02689
- [2]Qingwen Bu, Sungrae Park, Minsoo Khang, and Yichuan Cheng. Srformer: Text detection transformer with incorporated segmentation and regression. In AAAI, volume 38, no. 2, pages 855–863, 2024.
- [3]Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In ECCV, pages 213–229, 2020.arxiv.org/abs/2005.12872
- [4]Hao Chen, Kunyang Sun, Zhi Tian, Chunhua Shen, Yongming Huang, and Youliang Yan. Blendmask: Top-down meets bottom-up for instance segmentation. In CVPR, pages 8573–8581, 2020.arxiv.org/abs/2001.00309
- [5]Bowen Cheng, Alex Schwing, and Alexander Kirillov. Per-pixel classification is not all you need for semantic segmentation. Adv. Neural Inf. Process. Syst., 34:17864–17875, 2021.arxiv.org/abs/2107.06278
- [6]Chee Kheng Ch’ng and Chee Seng Chan. Total-text: A comprehensive dataset for scene text detection and recognition. In ICDAR, volume 1, pages 935–942, 2017.
- [7]Chee Kheng Chng, Yuliang Liu, Yipeng Sun, Chun Chet Ng, Canjie Luo, Zihan Ni, ChuanMing Fang, Shuaitao Zhang, Junyu Han, Errui Ding, et al. Icdar2019 robust reading challenge on arbitrary-shaped text-rrc-art. In ICDAR, pages 1571–1576, 2019.
- [8]Pengwen Dai, Sanyi Zhang, Hua Zhang, and Xiaochun Cao. Progressive contour regression for arbitrary-shape scene text detection. In CVPR, pages 7393–7402, 2021.DOI
- [9]Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.arxiv.org/abs/2010.11929
- [10]Yongkun Du, Zhineng Chen, Hongtao Xie, Caiyan Jia, and Yu-Gang Jiang. Svtrv2: Ctc beats encoder-decoder models in scene text recognition. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 20147–20156, 2025.
- [11]Yongkun Du, Zhineng Chen, Yazhen Xie, Weikang Bai, Hao Feng, Wei Shi, Yuchen Su, Can Huang, and Yu-Gang Jiang. Unirec-0.1 b: Unified text and formula recognition with 0.1 b parameters. arXiv preprint arXiv:2512.21095, 2025.
- [12]Xu Han, Chuang Yang, and Qi Wang. Pull pole points to text contour by magnetism: A real-time scene text detector. IEEE Trans. Image Process., 34:6374–6385, 2025.
- [13]Kaiming He, Xinlei Chen, Saining Xie, Yanghao Li, Piotr Dollár, and Ross Girshick. Masked autoencoders are scalable vision learners. In CVPR, pages 16000–16009, 2022.arxiv.org/abs/2111.06377
- [14]Dimosthenis Karatzas, Faisal Shafait, Seiichi Uchida, Masakazu Iwamura, Lluis Gomez i Bigorda, Sergi Robles Mestre, Joan Mas, David Fernandez Mota, Jon Almazan Almanzan, and Lluis Pere De Las Heras. Icdar 2013 robust reading competition. In ICDAR, pages 1484–1493, 2013.DOI
- [15]Dimosthenis Karatzas, Lluis Gomez-Bigorda, Anguelos Nicolaou, Suman Ghosh, Andrew Bagdanov, Masakazu Iwamura, Jiri Matas, Lukas Neumann, Vijay Ramaseshan Chandrasekhar, Shijian Lu, et al. Icdar 2015 competition on robust reading. In ICDAR, pages 1156–1160, 2015.DOI
- [16]Xiao-Hui Li, Fei Yin, and Cheng-Lin Liu. Docsam: Unified document image segmentation via query decomposition and heterogeneous mixed learning. In CVPR, pages 15021–15032, 2025.
- [17]Yanghao Li, Hanzi Mao, Ross Girshick, and Kaiming He. Exploring plain vision transformer backbones for object detection. In ECCV, pages 280–296. Springer, 2022.
- [18]Min Liang, Jia-Wei Ma, Xiaobin Zhu, Jingyan Qin, and Xu-Cheng Yin. Layoutformer: Hierarchical text detection towards scene text understanding. In CVPR, pages 15665–15674, 2024.
- [19]Minghui Liao, Zhaoyi Wan, Cong Yao, Kai Chen, and Xiang Bai. Real-time scene text detection with differentiable binarization. In AAAI, pages 11474–11481, 2020.arxiv.org/abs/1911.08947
- [20]Minghui Liao, Zhisheng Zou, Zhaoyi Wan, Cong Yao, and Xiang Bai. Real-time scene text detection with differentiable binarization and adaptive scale fusion. IEEE Trans. Pattern Anal. Mach. Intell., 45(1):919–931, 2022.arxiv.org/abs/2202.10304
- [21]Tsung-Yi Lin, Piotr Dollár, Ross Girshick, Kaiming He, Bharath Hariharan, and Serge Belongie. Feature pyramid networks for object detection. In CVPR, pages 2117–2125, 2017.arxiv.org/abs/1612.03144
- [22]Shu Liu, Lu Qi, Haifang Qin, Jianping Shi, and Jiaya Jia. Path aggregation network for instance segmentation. In CVPR, pages 8759–8768, 2018.arxiv.org/abs/1803.01534
- [23]Yuliang Liu, Lianwen Jin, Shuaitao Zhang, Canjie Luo, and Sheng Zhang. Curved scene text detection via transverse and longitudinal sequence connection. Pattern Recogn., 90:337–345, 2019.DOI
- [24]Yuliang Liu, Hao Chen, Chunhua Shen, Tong He, Lianwen Jin, and Liangwei Wang. Abcnet: Real-time scene text spotting with adaptive bezier-curve network. In CVPR, pages 9809–9818, 2020.arxiv.org/abs/2002.10200
- [25]Yuliang Liu, Chunhua Shen, Lianwen Jin, Tong He, Peng Chen, Chongyu Liu, and Hao Chen. Abcnet v2: Adaptive bezier-curve network for real-time end-to-end text spotting. IEEE Trans. Pattern Anal. Mach. Intell., 44(11):8048–8064, 2021.arxiv.org/abs/2105.03620
- [26]Shangbang Long, Siyang Qin, Dmitry Panteleev, Alessandro Bissacco, Yasuhisa Fujii, and Michalis Raptis. Towards end-to-end unified scene text detection and layout analysis. In CVPR, pages 1049–1059, 2022.arxiv.org/abs/2203.15143
- [27]Nibal Nayef, Fei Yin, Imen Bizid, Hyunsoo Choi, Yuan Feng, Dimosthenis Karatzas, Zhenbo Luo, Umapada Pal, Christophe Rigaud, Joseph Chazalon, et al. Icdar2017 robust reading challenge on multi-lingual scene text detection and script identification-rrc-mlt. In ICDAR, pages 1454–1459, 2017.DOI
- [28]Amanpreet Singh, Guan Pang, Mandy Toh, Jing Huang, Wojciech Galuba, and Tal Hassner. Textocr: Towards large-scale end-to-end reasoning for arbitrary-shaped scene text. In CVPR, pages 8802–8812, 2021.arxiv.org/abs/2105.05486
- [29]Yuchen Su, Zhineng Chen, Zhiwen Shao, Yuning Du, Zhilong Ji, Jinfeng Bai, Yong Zhou, and Yu-gang Jiang. Lranet: Towards accurate and efficient scene text detection with low-rank approximation network. In AAAI, volume 38, no. 5, pages 4979–4987, 2024.arxiv.org/abs/2306.15142
- [30]Yuchen Su, Zhineng Chen, Yongkun Du, Zhilong Ji, Kai Hu, Jinfeng Bai, and Xieping Gao. Explicit relational reasoning network for scene text detection. In AAAI, volume 39, no. 7, pages 7069–7077, 2025.arxiv.org/abs/2412.14692
- [31]Yuchen Su, Zhineng Chen, Yongkun Du, Zuxuan Wu, Hongtao Xie, and Yu-Gang Jiang. Lranet++: Low-rank approximation network for accurate and efficient text spotting. IEEE Trans. Pattern Anal. Mach. Intell., 48(5):5620–5638, 2026.DOI
- [32]Mingxing Tan, Ruoming Pang, and Quoc V Le. Efficientdet: Scalable and efficient object detection. In CVPR, pages 10781–10790, 2020.arxiv.org/abs/1911.09070
- [33]Jingqun Tang, Wenqing Zhang, Hongye Liu, MingKun Yang, Bo Jiang, Guanglong Hu, and Xiang Bai. Few could be better than all: Feature sampling and grouping for scene text detection. In CVPR, pages 4563–4572, 2022.arxiv.org/abs/2203.15221
- [34]Zhi Tian, Chunhua Shen, Hao Chen, and Tong He. Fcos: Fully convolutional one-stage object detection. In ICCV, pages 9627–9636, 2019.arxiv.org/abs/1904.01355
- [35]Jianqiang Wan, Sibo Song, Wenwen Yu, Yuliang Liu, Wenqing Cheng, Fei Huang, Xiang Bai, Cong Yao, and Zhibo Yang. Omniparser: A unified framework for text spotting key information extraction and table recognition. In CVPR, pages 15641–15653, 2024.arxiv.org/abs/2403.19128
- [36]Xingyu Wan, Chengquan Zhang, Pengyuan Lyu, Sen Fan, Zihan Ni, Kun Yao, Errui Ding, and Jingdong Wang. Towards unified multi-granularity text detection with interactive attention. arXiv preprint arXiv:2405.19765, 2024.arxiv.org/abs/2405.19765
- [37]Ao Wang, Hui Chen, Lihao Liu, Kai Chen, Zijia Lin, Jungong Han, et al. YoloV10: Real-time end-to-end object detection. Adv. Neural Inf. Process. Syst., 37:107984–108011, 2024.arxiv.org/abs/2405.14458
- [38]Wei Wang, Yu Zhou, Jiahao Lv, Dayan Wu, Guoqing Zhao, Ning Jiang, and Weiping Wang. Tpsnet: Reverse thinking of thin plate splines for arbitrary shape scene text representation. In ACM MM, pages 5014–5025, 2022.arxiv.org/abs/2110.12826
- [39]Wenhai Wang, Enze Xie, Xiang Li, Wenbo Hou, Tong Lu, Gang Yu, and Shuai Shao. Shape robust text detection with progressive scale expansion network. In CVPR, pages 9336–9345, 2019.arxiv.org/abs/1903.12473
- [40]Xinlong Wang, Rufeng Zhang, Tao Kong, Lei Li, and Chunhua Shen. Solov2: Dynamic and fast instance segmentation. Adv. Neural Inf. Process. Syst., 33:17721–17732, 2020.arxiv.org/abs/2003.10152
- [41]Cong Yao, Xiang Bai, Wenyu Liu, Yi Ma, and Zhuowen Tu. Detecting texts of arbitrary orientations in natural images. In CVPR, pages 1083–1090, 2012.DOI
- [42]Maoyuan Ye, Jing Zhang, Shanshan Zhao, Juhua Liu, Bo Du, and Dacheng Tao. Dptetx-detr: Towards better scene text detection with dynamic points in transformer. In AAAI, pages 3241–3249, 2023.
- [43]Maoyuan Ye, Jing Zhang, Juhua Liu, Chenyu Liu, Baocai Yin, Cong Liu, Bo Du, and Dacheng Tao. Hi-sam: Marrying segment anything model for hierarchical text segmentation. IEEE Trans. Pattern Anal. Mach. Intell., 2024.arxiv.org/abs/2401.17904
- [44]Wenwen Yu, Yuliang Liu, Xingkui Zhu, Haoyu Cao, Xing Sun, and Xiang Bai. Turning a clip model into a scene text spotter. IEEE Trans. Pattern Anal. Mach. Intell., 46(9):6040–6054, 2024.DOI
- [45]Wenwen Yu, Zhibo Yang, Jianqiang Wan, Sibo Song, Jun Tang, Wenqing Cheng, Yuliang Liu, and Xiang Bai. Omniparser v2: Structured-points-of-thought for unified visual text parsing and its generality to multimodal large language models. IEEE Trans. Pattern Anal. Mach. Intell., 2026.DOI
- [46]Shi-Xue Zhang, Xiaobin Zhu, Lei Chen, Jie-Bo Hou, and Xu-Cheng Yin. Arbitrary shape text detection via segmentation with probability maps. IEEE Trans. Pattern Anal. Mach. Intell., 45(3):2736–2750, 2022.arxiv.org/abs/2208.12419
- [47]Shi-Xue Zhang, Chun Yang, Xiaobin Zhu, and Xu-Cheng Yin. Arbitrary shape text detection via boundary transformer. IEEE Trans. Multimedia, 26:1747–1760, 2023.arxiv.org/abs/2205.05320
- [48]Xi Zhao, Wei Feng, Zheng Zhang, Jingjing Lv, Xin Zhu, Zhangang Lin, Jinghe Hu, and Jingping Shao. Cbnet: A plug-and-play network for segmentation-based scene text detection. Int. J. Comput. Vision, pages 1–20, 2024.DOI
- [49]Jinzhi Zheng, Heng Fan, and Libo Zhang. Kernel adaptive convolution for scene text detection via distance map prediction. In CVPR, pages 5957–5966, 2024.DOI
- [50]Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, and Jifeng Dai. Deformable detr: Deformable transformers for end-to-end object detection. In ICLR, 2021.arxiv.org/abs/2010.04159
- [51]Yiqin Zhu, Jianyong Chen, Lingyu Liang, Zhanghui Kuang, Lianwen Jin, and Wayne Zhang. Fourier contour embedding for arbitrary-shaped text detection. In CVPR, pages 3123–3131, 2021.arxiv.org/abs/2104.10442



