Cham-OCR: A Deep-Learning OCR Pipeline for Unicode Eastern Cham, toward Historical Manuscript and Epigraphic Recognition

1. Introduction & Paleographic Foundations

1.1 Historical Script Typology & Document Endangered Status

The Cham language belongs to the Austronesian language family (Malayo-Polynesian branch) and was the primary medium of literature, state administration, and liturgy across the Champa polities along coastal central and southern Vietnam from the 2nd to early 19th centuries. The script family descends from Southern Brahmic Grantha/Pallava lineages, evolving into two distinct extant traditions:

• Eastern Cham (Akhar Thrah): Inscribed and preserved predominantly in Ninh Thuận and Bình Thuận provinces (Vietnam). Historical manuscripts are executed on traditional bark-paper (kertas) or palm leaf with calligraphic bamboo pens.
• Western Cham (Cam Srak): Preserved by Cham communities in the Mekong Delta (An Giang, Tây Ninh) and Cambodia. It features distinctive stylistic glyph contours, regional ligature forms, and localized phonetic loan signs.

Due to tropical climate conditions, ink bleed, microbiological decay, and physical fragmentation, remaining manuscript archives (such as the Akayet Inra Patra, Ariya Po Pareng, and sacred divinatory compendia) face significant preservation risks. Standard off-the-shelf OCR engines designed primarily for Latin or CJK scripts struggle significantly on historical Cham manuscripts due to fundamental typographical divergences.

1.2 Abugida Orthography & Multi-Directional Glyphs

Unlike alphabetic writing systems where letters follow a single horizontal axis, Cham is an abugida governed by complex spatial attachment rules:

1. Independent Vowels (U+AA00–U+AA05): Six standalone vowel glyphs represent syllable-initial vowel phonemes without a preceding consonant base: ꨀ (U+AA00: CHAM LETTER A), ꨁ (U+AA01: CHAM LETTER I), ꨂ (U+AA02: CHAM LETTER U), ꨃ (U+AA03: CHAM LETTER E), ꨄ (U+AA04: CHAM LETTER AI), ꨅ (U+AA05: CHAM LETTER O).
2. Consonantal Inventory (U+AA06–U+AA28): Thirty-five consonant glyphs carry an inherent vowel (/a/ or /ɔ/), beginning with ꨆ (U+AA06: CHAM LETTER KA) through ꨨ (U+AA28: CHAM LETTER HA), encompassing unaspirated, aspirated, nasal, and liquid articulation series.
3. Subjoined Medials (U+AA33–U+AA36): Four medial consonants attach underneath or encircle the consonant base: Medial Ya (ꨳ U+AA33: CHAM CONSONANT SIGN YA), Medial Ra (ꨴ U+AA34: CHAM CONSONANT SIGN RA), Medial La (ꨵ U+AA35: CHAM CONSONANT SIGN LA), and Medial Wa (ꨶ U+AA36: CHAM CONSONANT SIGN WA).
4. Multi-Directional Dependent Vowels (U+AA29–U+AA32): Dependent vowel signs attach across all four spatial quadrants around the base:
   • Above base: Vowel Sign I (ꨪ U+AA2A), II (ꨫ U+AA2B), EI (ꨬ U+AA2C).
   • Below base: Vowel Sign U (ꨭ U+AA2D), UE (ꨲ U+AA32).
   • Post-base / Dependent: Vowel Sign AA (ꨩ U+AA29), OE (ꨮ U+AA2E), AU (ꨱ U+AA31).
   • Pre-base (Left / Visual Ahead): Vowel Sign O (ꨯ U+AA2F), AI (ꨰ U+AA30).
5. Final Consonants & Signs ([U+AA40–U+AA4D, U+AA25]): Explicit syllable codas including separate base glyphs with extended terminal strokes (U+AA40–U+AA4B), combining coda marks (Final Ng ꩃ U+AA43, Final M / Anusvara ꩌ U+AA4C, Final H / Visarga ꩍ U+AA4D), and the base consonant ꨥ (U+AA25 CHAM LETTER VA) which, per Unicode Standard Chapter 16 Table 16-16, functions without alteration in both initial and syllable-final positions (e.g., in syllables such as ꨀꨍꨯꨱꨥ and ꨝꨗꨴꨭꨥ).
6. Script Spacing Conventions: Many historical Cham manuscripts exhibit limited or inconsistent inter-word spacing, while modern printed Cham commonly uses spaces. Classical literary texts and verse compendia frequently exhibit continuous running script (scriptio continua), though section divisions, poetic hemistichs, or phrasing pauses are demarcated by punctuation marks (e.g., Danda ꩝, Double Danda ꩞, Triple Danda ꩟) and occasional whitespace gaps.
7. Punctuation & Verse Markers: Traditional discourse is demarcated via Danda (꩝ U+AA5D), Double Danda (꩞ U+AA5E, also serving as section/stanza mark), and Triple Danda (꩟ U+AA5F). Poetic stanzas frequently open with Cham numerals followed by a section mark (e.g., ꩑꩞ for Verse 1, ꩒꩞ for Verse 2).

1.3 The Conflict: Logical Storage Order vs Visual Rendering Order

The Unicode Standard mandates Logical Order encoding for all Brahmic scripts, meaning the character sequence reflects phonetic utterance:

However, pre-vowels like ꨯ (Vowel Sign O, U+AA2F) and ꨰ (Vowel Sign AI, U+AA30) are rendered visually to the left of the base consonant. When an optical sequence decoder scans an image crop left-to-right, its visual perception encounters the pre-vowel ahead of the consonant glyph (e.g. perceiving ꨯ before base ꨕ). Standard CTC models therefore frequently output the illegal sequence ꨯꨕ instead of the canonical Unicode cluster ꨕꨯ.

2. Related Work on Cham Document Analysis & Epigraphy

2.1 Early Epigraphic & Glyph Recognition

Automated processing of Cham script originated in the analysis of stone inscriptions from ancient Champa sanctuaries (Mỹ Sơn, Po Nagar, Đồng Dương). Nguyen, Schweyer, Le, Tran, & Vu (2019a) presented preliminary results on recognizing ancient Cham glyphs extracted from stone rubbings and photographs using Histogram of Oriented Gradients (HOG), Non-Parametric Weighted (NPW) features, and CNN-derived feature representations coupled with $k$-NN and linear SVM classifiers at the IEEE MAPR 2019 conference. Due to severe stone weathering, erosion, and irregular surface texture, isolated glyph classification across noisy background substrates was evaluated.

To mitigate extreme sample scarcity in epigraphic corpora, Nguyen, Schweyer, Le, Tran, & Vu (2019b) evaluated data augmentation strategies and transfer learning from scripts of similar or the same language family to ancient stone inscription glyphs at the ICIAP 2019 Workshops (PatReCH), demonstrating quantitative gains on script-to-inscription transfer across weathered stone carvings.

2.2 Deep Learning for Cham Epigraphy & Transliteration

In his doctoral dissertation, Nguyen (2023) developed comprehensive document image processing and understanding methodologies dedicated to ancient Cham documents. His work investigated stone inscription image restoration, automatic glyph segmentation under rough stone substrate conditions, and deep convolutional representations for historical Brahmic scripts.

Complementing glyph recognition, Nguyen, Burie, Le, & Schweyer (2022) proposed an effective multi-stage method for text line segmentation in historical document images presented at the 26th International Conference on Pattern Recognition (ICPR 2022), addressing line curvature and touching diacritics in historical archives. Expanding to linguistic representation, Nguyen, Burie, Le, & Schweyer (2023) introduced a two-step sequence transformer model for Cham-to-Latin script transliteration presented at the HIP@ICDAR 2023 workshop. Their system demonstrated the efficacy of sequence-to-sequence transformers in mapping recognized Cham text sequences to standardized Latin phonological romanizations (Cam-Latin). Most recently, Nguyen, Burie, Le, & Schweyer (2025) published a comprehensive study entitled Text line segmentation approach combining deep learning model and traditional image processing techniques - application to transliteration of Cham manuscripts in Multimedia Tools and Applications, evaluating text-line segmentation and automatic transliteration across 627 manuscript images and approximately 8,300 textlines (focusing on line segmentation and transliteration rather than end-to-end character OCR benchmarking).

2.3 Manuscript Preservation & Digitization Initiatives

Beyond epigraphy on stone, historical Cham manuscripts on paper (kertas) and palm-leaf have been documented through preservation missions. The Historic Cham Manuscripts of Vietnam collection in the Southeast Asia Digital Library (SEADL) contains 977 digitized manuscripts comprising more than 57,800 page scans. In addition, field surveys estimate approximately 3,000 physical manuscripts preserved within Cham community families and religious dignitaries across Vietnam and Cambodia. The French National Research Agency funded the CHAMDOC project (Cham Documentation, ANR-19-CE27-0018, 2019–2024) to support preservation, cataloging, and linguistic documentation.

However, despite the preservation of tens of thousands of scanned folios, almost none of these archives possess open, machine-readable character-level or line-level bounding box ground-truth annotations suitable for training supervised deep learning models. The bottleneck for Cham OCR is therefore not an absolute absence of physical manuscripts, but rather the severe scarcity of annotated, verified training ground truth.

2.4 Positioning of the Present System

Prior research has focused predominantly on either isolated glyph recognition on stone inscriptions, downstream transliteration of cleaned text, or academic research prototypes evaluated on private manuscript subsets. In contrast, the system presented in this report addresses the complete end-to-end continuous document pipeline for historical manuscripts:

• Full-page line detection and segmentation robust to undulating baselines and tight interlinear diacritics.
• End-to-end continuous textline recognition without manual character pre-segmentation.
• Deterministic canonical reordering adhering strictly to the official Unicode standard.
• Production-grade serving designed for cultural heritage researchers and native community access.

3. Text Detection & Indic Line Segmentation (Cham-DBNet)

3.1 The Interlinear Diacritic Collision Problem

In digital modeling and synthetic text rendering at nominal glyph heights (32–36px), interlinear clearance often narrows to 3–12 pixels between adjacent lines (with ascender excursions extending up to \(+18\text{px}\) and descender excursions down to \(-22\text{px}\) in normalized coordinate space). Because upper dependent vowels reach high above the core text band and subjoined medials plunge below, the ascenders of line \(n+1\) routinely touch or intertwine with the descenders of line \(n\) under dense formatting. Standard off-the-shelf text detection models (such as baseline DBNet trained on natural scene Latin or CJK text) frequently encounter two severe failure modes when applied to dense historical manuscripts:

• Merging adjacent lines into single monolithic boxes.
• Slicing off upper/lower diacritics, leading to fatal recognition errors.

3.2 Specialized Cham-DBNet: Architecture & Training

We trained a specialized text detector based on PP-OCRv4 Mobile DBNet with a lightweight PPLCNetV3 backbone on an NVIDIA L4 GPU (24GB VRAM) in Lightning AI:

Empirical Line Detection Performance: Evaluated within the complete document processing pipeline on our 200-page synthetic stress-test suite (evaluation_report.json), Cham-DBNet achieves high line extraction fidelity across difficulty levels:

3.3 Hybrid Indic Valley-Cut Heuristic & Boundary Masking Safeguards

For CPU execution in low-resource environments (or when DBNet probability maps exhibit ambiguity), we designed an Indic Valley-Cut Heuristic Engine operating as a secondary defense layer:

1. Connected Component Analysis (CCA): Extracts all connected ink components on the binarized page.
2. Core Text Band Determination: Identifies the median baseline and core bounding box of each text line using horizontal projection histograms.
3. Boundary Stroke Masking via difference_update: When creating an erasing mask to obscure adjacent interfering lines, components belonging to the current line are strictly excluded using mathematical set difference (\(S_{\text{mask}} = S_{\text{adjacent}} \setminus S_{\text{current}}\)). This prevents amputating touching diacritics.
4. Vertical Padding Safeguards: The bounding box is padded by exactly \(0.40 \times \text{median line height}\) upwards and downwards, bounded at a minimum distance of \(2\text{px}\) from neighboring core bands.
5. Legacy-First / No-Change Gate: For clean documents where interline gap \(\ge 0.35 \times \text{height}\) and initial confidence \(\ge 0.75\), multi-crop splitting is bypassed entirely to guarantee zero regression on pristine folios.

4. Neural Text Recognition Architecture (Cham-SVTR)

4.1 PP-OCRv4 SVTR-LCNet Backbone

Text recognition is formulated as sequence labeling on textline image crops. We adopted the SVTR-LCNet architecture from PP-OCRv4, customized with specialized input and output heads:

• Input Tensor Dimensions: Scaled to \([3, 48, 480]\) (channels \(\times\) height \(\times\) width). Widening the receptive field to 480 width prevents spatial squashing of Cham verses containing stacked diacritics.
• SVTR Blocks (Single Visual Model for Text Recognition): Integrates local visual feature extractors with patch-wise self-attention mechanisms to capture long-range contextual relationships across unspaced text.
• Squeeze-and-Excitation (SE) Channel Attention: Adaptively recalibrates channel-wise feature responses, emphasizing subtle diacritic strokes over background paper grain.

4.2 Joint CTC & Sequence Attention Loss

Training employs joint supervision combining Connectionist Temporal Classification (CTC) with an Attention-based sequence decoder:

Where \(\mathcal{L}_{\text{CTC}}\) maximizes the log-likelihood of valid alignments over the transcription sequence \(\mathbf{y}\):

During runtime inference, greedy CTC decoding is executed to provide lightweight, low-latency single-thread CPU execution without costly beam search.

4.3 Post-OCR Deterministic Canonical Normalization

To resolve the visual-versus-logical ordering paradox described in Section 1.3, we developed normalize_unicode, an algorithmic state machine built upon parse_unicode_clusters. It decomposes the raw CTC output string into individual phonological syllables and re-sorts tokens into canonical Brahmic sequence:

def normalize_unicode(text: str) -> str:
    # Enforces Canonical Brahmic Logical Order on CTC decoded Cham text:
    # Base Consonant -> Medial RA/LA -> Medial YA/WA -> Pre-Vowels (O/AI) ->
    # Other Dependent Vowels -> Vowel Lengthener AA -> Final Consonants / Signs (incl. Final VA)
    # Example: Corrects visual sequence 'ꨙꨯꨳꨮ' into canonical 'ꨙꨳꨯꨮ'.
    clusters = parse_unicode_clusters(text)
    uni_clusters = [visual_to_unicode_cluster(c) for c in clusters]
    return "".join("".join(c) for c in uni_clusters)

5. Synthetic Dataset Generation & Hard-Example Mining

5.1 The Data Scarcity Bottleneck

Deep neural OCR networks require hundreds of thousands of diverse labeled textlines. However, surviving physical Cham manuscripts lack open character-level bounding box ground truth. To overcome this limitation, we engineered an algorithmic synthesizer (scripts/generate_data.py) capable of rendering 150,000 diverse textline crops from authentic literary corpora.

5.2 Calibrated Synthetic Dataset Partitioning & Dual-Generator Architecture

To support both baseline reproducibility and ongoing experimental modeling, the repository provides two distinct synthetic dataset generation pipelines:

Pipeline A: Baseline General Generator (scripts/generate_data.py)

The baseline generator produces a 150,000 textline corpus partitioned into 15% evaluation/locked splits (22,500 lines: val_clean_short 3%, val_clean_long 3%, val_noisy_short 3%, val_noisy_long 3%, locked_test 3%) and an 85% training split (127,500 lines) structured across 6 calibrated sub-categories:

Pipeline B: Experimental V25 Generator (scripts/generate_data_v25.py)

For the V25 experimental iteration, a dedicated multi-threaded generator (generate_data_v25.py) synthesizes 150,000 textline images (140,000 train + 10,000 validation) directly synchronized with configs/v25_dataset_manifest.json across 5 core pillars:

1. Canonical Cham Literature (43.3% / 65,000 lines): Classical literary vocabulary (Po Klong Garai, 57-stanza verse).
2. Anti-Motion Blur Base (20.0% / 30,000 lines): Clean base images paired with dynamic in-RAM directional motion blur (\(7\times 7\) to \(13\times 13\)) and defocus.
3. Inline Bilingual Code-Switching (16.7% / 25,000 lines): Intra-line mixed phrases with Vietnamese diacritics and Latin annotations.
4. Stanza Numerals & Boundary Punctuation (12.0% / 18,000 lines): Verse numbers \(1\)–\(99\) (꩑꩞..꩙꩙꩞) and boundary marks (꩞, :, –).
5. Adversarial Minimal Pairs (8.0% / 12,000 lines): Micro-stroke pairs (ꨲ U+AA32 Vowel Sign UE vs ꨶ U+AA36 Medial WA, variable Double Danda ꩝꩝ spacing 2–8px, 3-tier diacritic stacks).

5.3 Digital Typefaces & TrueType cmap Tofu Glyph Safeguards

When rendering synthetic text, digital Cham typefaces must be verified for glyph coverage. The primary bundled and reproducible typeface distributed directly within this repository is Noto Sans Cham (Regular, Bold, Black; SIL Open Font License 1.1, located in ocr-training/data/fonts/). External reference typefaces evaluated during research—including Cham Roman, EFEO Cham, and community fonts—are not redistributed in this repository and must be acquired independently if researchers wish to reproduce specific historical font variations.

To prevent missing Unicode codepoints from producing blank rectangles ("tofu" glyphs), our generator incorporates pre-render verification via fontTools.ttLib to extract each font's cmap table. Candidate strings are inspected character-by-character; any string containing unmapped glyphs for the active font is rejected prior to rasterization.

5.4 On-the-Fly Dynamic Motion Blur & Noise Synthesis in RAM

To prevent disk I/O bottlenecks during generation, augmentations are synthesized dynamically in memory:

• Point Spread Function (PSF) Motion Blur: Simulates hand tremors during mobile photography in archival field trips (kernel size 3–9px, angle \([0, 180^\circ]\)).
• Gaussian & Salt-and-Pepper Noise: Simulates coarse paper fibers and dust particles.
• Non-Linear Illumination Gradients: Models uneven natural sunlight across warped manuscript pages.

6. Empirical Benchmarks & Quantitative Evaluations

6.1 Controlled 50-Test Stratified Benchmark (Model V23 vs V24)

We evaluated model evolution across 50 rigorous stratified test cases covering 10 distinct failure modes, logged in benchmark_50_tests_results.json and benchmark_50_tests_results_v24.json:

6.2 Controlled 200-Page Synthetic Document Stress-Test (903 Textlines)

To establish the operational limits of the complete end-to-end pipeline (Cham-DBNet + Cham-SVTR v24), we evaluated a controlled synthetic stress-test suite of 200 generated page images comprising 903 ground-truth textlines. Generated by ocr-benchmark/scripts/generate_benchmark_200.py, this suite renders authentic literary passages under calibrated geometric and photometric stress across 5 difficulty tiers:

6.3 Model Progression & Empirical Validation: V23 vs V24 vs V25 SOTA

Across iterative development cycles, we evaluated the trajectory of the Cham-SVTR architecture across three foundational milestones: Version 23 (visual ordering legacy), Version 24 (first logical ordering baseline), and Version 25 (current production State-Of-The-Art). Quantitative validation on the standardized 10,000 frozen validation split (cham_v25_val_freeze.zip) documents the compounding gains achieved through lexicon expansion, resolution widening, and targeted hard-example synthesis:

Detailed Error Mode Resolution & Paleographic Breakthroughs in V25

1. Stanza Numerals vs Consonant Disambiguation: Prior iterations suffered from CTC blank collapse where Western and Eastern Cham digit ligatures were decoded as visually similar consonants: ꩔ (digit 4) was misclassified as ꨤ (la), ꩕ (digit 5) as ꨅ (e) or ꨂ (u), and verse markers like ꩑꩞ collapsed into ꨩꩌ. Incorporating 18,000 dedicated adversarial samples covering numerals \(1\)–\(99\) with boundary markers (꩑꩞ through ꩙꩙꩞) achieved \(>98.5\%\) exact match on stanza headers.
2. Boundary Punctuation & Double Danda (꩝꩝) Spacing: CTC decoders with standard temporal stride tend to merge closely adjacent vertical strokes into a single timestep. V25 synthesized variable Double Danda spacings (\(2\)px to \(8\)px) under varying blur kernels, training the network to distinguish single ꩝ (U+AA5D) from double ꩝꩝ (U+AA5D U+AA5D).
3. Diacritic Minimal Pair Disambiguation (ꨲ vs ꨶ): Under degraded ink conditions, Vowel Sign UE (ꨲ, U+AA32) and Medial Consonant Sign WA (ꨶ, U+AA36) exhibit extreme visual proximity under base glyphs ꨀ, ꨓ, ꨚ, ꨆ. Through 12,000 targeted adversarial minimal pairs, V25 forces the convolutional feature extractor to attend to subtle sub-stroke curvature differences, dropping the pair substitution rate from \(18.4\%\) in V24 to \(<1.2\%\) in V25.
4. Integration with Deterministic Unicode Cluster Normalization: Operating strictly in Logical Storage Order, V25 pairs directly with normalize_unicode (via scripts/generate_data.py). Any localized CTC sequence permutations are deterministically regularized to the canonical Brahmic order: \(\text{Base} + \text{Medials} + \text{Pre-Ra} + \text{Pre-Vowels} + \text{Post-Vowels} + \text{Finals}\), eliminating ordering inversion errors while maintaining 100% compliance with modern Unicode display engines.

6.4 Multi-GPU Distributed Hardware Scaling & Cost Efficiency

Training deep OCR backbones over 10,000,000 synthetic sample passes requires empirical hardware optimization. We executed controlled distributed benchmarks across four accelerator configurations:

7. Production Serving & Deployment Infrastructure

7.1 Containerized Microservice Architecture

The production Cham OCR Studio is packaged as a lightweight, multi-stage Docker container deployed on Hugging Face Spaces (Space ID: phucsd/cham-ocr-studio) and routed through the custom apex domain:

7.2 Concurrency Safeguards & NumPy 2.x Forward Compatibility

To guarantee deterministic latency under free-tier CPU constraints (2 vCPUs, 16GB RAM):

• Single-Thread Concurrency Locks: OpenMP and MKL thread pools are constrained via OMP_NUM_THREADS=1 and CPU_THREADS=1. This eliminates OS context-switching overhead and CPU thrashing during concurrent web requests.
• NumPy 2.x Compatibility Layer: Python 3.12+ environments encounter breaking attribute removals in NumPy 2.x (such as deprecated np.sctypes, np.bool, and np.typeDict required by legacy PaddleOCR and imgaug modules). We injected an automatic runtime patch at module initialization to guarantee zero-crash execution:
  Python Runtime Monkeypatch

  import numpy as np
  if not hasattr(np, 'sctypes'):
      np.sctypes = {'int': [np.int8, np.int16, np.int32, np.int64],
                    'uint': [np.uint8, np.uint16, np.uint32, np.uint64],
                    'float': [np.float16, np.float32, np.float64],
                    'complex': [np.complex64, np.complex128],
                    'others': [bool, object, bytes, str]}
  if not hasattr(np, 'bool'): np.bool = bool
  if not hasattr(np, 'int'): np.int = int
  if not hasattr(np, 'float'): np.float = float
  if not hasattr(np, 'typeDict'): np.typeDict = {}

8. Limitations & Open Research Challenges

While our pipeline demonstrates substantial gains on synthetic and semi-controlled documents, rigorous academic honesty requires acknowledging the following boundaries:

• Synthetic-to-Real Domain Gap: The neural recognizer is trained predominantly on synthetic textlines rendered with bundled Noto Sans Cham (SIL OFL 1.1). Historical manuscripts feature idiosyncratic scribal hands, variable ink viscosity, and non-standard ligature variations that may exhibit lower recognition confidence in the field.
• Absence of Large-Scale Real Manuscript Ground Truth: Due to the acute scarcity of digitized historical Cham archives with line-level annotations, current benchmarks rely on controlled synthetic stress-tests and curated test slices. Establishing an open, expert-verified historical palm-leaf manuscript benchmark represents an urgent necessity requiring future collaborative scholarship with native Cham elders and linguists.
• Severe Biological Degradation & Epigraphy: Inscription stone rubbings and severely mold-damaged palm leaves (where character ink has substantially eroded) remain beyond the capabilities of pure vision-based CTC sequence models. Integrating masked language models (MLMs) trained on historical Cham corpora is an active subject of future study.
• Extreme Interlinear Overlap (Level 5): When severe paper wrinkling causes interlinear wave amplitude to exceed line spacing (\(\text{Amplitude} > \text{Gap}\)), 1D projection and horizontal bounding boxes collapse, indicating the need for 2D polygonal baseline tracking models in future iterations.

8.5 Post-V25 Future Iterations (Planned V25.1 / V26 Improvements)

Following the successful training and deployment of Model Version 25 (90.96% Sequence Accuracy), all subsequent pipeline enhancements are tracked systematically in FUTURE_WORK.md:

1. Dual-Script Font Fallback & Combined Glyph Validation: Coordinated rendering pipeline for mixed Cham and Vietnamese/Latin text with fontTools cmap validation across both scripts to eliminate tofu artifacts in bilingual annotations.
2. Dedicated Directional Motion-Blur Augmentation: Physics-grounded Point Spread Function (PSF) kernels modeling hand tremor motion angles and camera exposure duration.
3. Manifest-Driven Exact Package Allocation: Deterministic line count allocation per category instead of probabilistic multinomial sampling.
4. Deterministic Frozen Validation Generation: Pre-generated, permanent frozen validation splits for zero-variance benchmark comparisons across training stages.

9. BibTeX Citation & Academic References

If you use this work, the synthetic generation methodology, or the OCR Studio in your research, please cite:

@software{cham_ocr_pipeline,
  author = {Nguyen, Phuc H.},
  title = {Cham-OCR: A Deep-Learning OCR Pipeline for Unicode Eastern Cham, toward Historical Manuscript and Epigraphic Recognition},
  year = {2026},
  publisher = {GitHub},
  url = {https://github.com/phucsd/Cham-OCR},
  note = {Production web service: https://ocr.cham.asia}
}

Academic References