Initial public release of BashkirTrOCR v3 (ONNX FP16 CUDA & INT8 CPU)

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

META.json

@@ -0,0 +1,62 @@
+{
+  "id": "bashkir_trocr_base",
+  "version": "v3.0-onnx-runtime.1",
+  "type": "onnx_ocr_model_bundle",
+  "language": "ba",
+  "license": "apache-2.0",
+  "status": "published",
+  "repo_id": "failed09/bashkir-trocr-base",
+  "intended_visibility": "public",
+  "architecture": "ViT-Base + TrOCR decoder",
+  "precision": {
+    "cpu": "dynamic_int8",
+    "gpu": "mixed_fp16_fp32_io"
+  },
+  "training_data_included": false,
+  "private_user_data_included": false,
+  "quality_claim": "No independent real-book CER/WER established. Manual review required.",
+  "artifacts": [
+    {
+      "file": "models/dbnet.onnx",
+      "bytes": 2432880,
+      "sha256": "3439588c030faea393a54515f51e983d8e155b19a2e8aba7891934c1cf0de526"
+    },
+    {
+      "file": "models/fp16/decoder.onnx",
+      "bytes": 598137053,
+      "sha256": "e55c720fd10ae8f290c28d06a150dc118a118d020f7405fef85a1b273d9ed7a3"
+    },
+    {
+      "file": "models/fp16/encoder.onnx",
+      "bytes": 172327813,
+      "sha256": "90a4ee3d331ea59cc2b60a860064ded38a3953163a33d4d16ce34f9b640103a5"
+    },
+    {
+      "file": "models/int8/decoder.onnx",
+      "bytes": 300449064,
+      "sha256": "e04bcbaaee07851e7b0a47c7b271fcd85a4d8b68623a3241e2c968c22808aecb"
+    },
+    {
+      "file": "models/int8/encoder.onnx",
+      "bytes": 89817188,
+      "sha256": "c9773380fd2e85ec4ccc07f570de7c2e63c88784570d3378a6af1ae744c7ca04"
+    }
+  ],
+  "validation": {
+    "cpu_clean_environment": true,
+    "gpu_clean_environment": true,
+    "pytorch_required": false,
+    "transformers_required": false,
+    "cuda_providers_confirmed": true,
+    "private_inputs_redistributed": false,
+    "public_examples": 1,
+    "independent_real_book_accuracy_established": false
+  },
+  "known_limitations": [
+    "Superscript 1 may be recognized as !; I/l/1/7 can be confused.",
+    "Capitals, Bashkir letters and punctuation can be wrong.",
+    "Dash types and word-splitting at wide-line boundaries are unreliable.",
+    "Decorative marks, columns, skew and poor scans require manual review.",
+    "No PDF rasterization, handwriting guarantee, spelling repair or independent real-book CER/WER claim."
+  ]
+}

NOTICE

@@ -0,0 +1,12 @@
+Bashkir TrOCR v3
+Fine-tuned from microsoft/trocr-base-stage1.
+
+PP-OCRv3 detection model and DBNet preprocessing/postprocessing helpers:
+Copyright (c) 2020 PaddlePaddle Authors. Apache License 2.0.
+Selected from RapidOCR 1.2.3 (https://github.com/RapidAI/RapidOCR).
+Modified: only detector helpers retained; no recognition/classifier models bundled.
+
+No source books, training corpus, personal paths or training logs are redistributed.
+
+Upstream TrOCR implementation: Copyright (c) Microsoft Corporation, MIT; see licenses/TrOCR-MIT.txt.
+RapidOCR: Copyright (c) 2021 RapidOCR Authors, Apache-2.0; see licenses/RapidOCR-Apache-2.0.txt.

QUICKSTART_RU.md

@@ -0,0 +1,33 @@
+# Быстрый запуск Bashkir OCR v3
+
+1. Установите Python 3.11–3.13 с python.org. На Windows включите «Add Python to PATH».
+2. Скачайте репозиторий целиком в обычную папку с правом записи.
+3. Запустите start_ocr.bat. По умолчанию выбран режим 3 (Авто — сам определит наличие видеокарты NVIDIA через nvidia-smi и поставит GPU FP16, иначе CPU INT8), либо выберите 1 — CPU INT8 или 2 — NVIDIA GPU FP16. Первый запуск скачает зависимости в локальное окружение. Дождитесь завершения установки.
+4. Откроется браузер. Выберите изображение, нажмите «Распознать». Переключайтесь между вкладками «По строкам» (нарезка строк и построчная правка) и «Страница и текст» (страница целиком слева и весь текст единым блоком справа).
+5. «Скопировать текст» копирует весь распознанный текст в буфер обмена; «Сохранить TXT» выгружает его в UTF-8 файл. Документы сервером на диск не записываются.
+6. Для остановки закройте окно запуска. Для следующего запуска снова откройте батник.
+
+## Режимы
+
+- CPU INT8 — обычный процессор, отдельная видеокарта не нужна.
+- GPU FP16 — NVIDIA CUDA. AMD/Intel GPU в этом релизе не проверены. CUDA/cuDNN зависимости ставятся в отдельное окружение; нужен установленный драйвер NVIDIA.
+- Авто (по умолчанию) — проверяет наличие драйвера NVIDIA (nvidia-smi), автоматически устанавливает и запускает GPU-окружение (с откатом на CPU при сбое инициализации CUDA), либо использует CPU.
+
+Не смешивайте onnxruntime и onnxruntime-gpu в одном окружении. Батник создаёт отдельные .venv-cpu и .venv-gpu. Пакет не содержит PyTorch/Transformers. Если установка прервана, следующий запуск повторит её. Если Python отсутствует, установите его и перезапустите батник.
+
+## Ограничения
+
+Принимается одно изображение страницы (PNG/JPEG/WebP/TIFF/BMP), до 25 МБ и 25 миллионов пикселей. Для PDF сначала экспортируйте страницы в изображения. Для TIFF используется первая страница. Не подавайте целую книгу одним длинным изображением.
+
+Проверяйте мелкие сноски 1/!, регистр, похожие буквы, тире и переносы. Расположение колонок и сильно наклонённые страницы могут обрабатываться неверно. Декоративные элементы могут стать мусорным текстом. Красивый результат не означает отсутствие ошибок.
+
+Сервер слушает только 127.0.0.1; изображения не отправляются в облако. Не меняйте привязку на публичный адрес. В интерфейсе нет телеметрии и внешних шрифтов.
+
+## Если не запускается
+
+- CUDA недоступна: обновите драйвер NVIDIA или выберите CPU. FP16 не предназначен для CPU.
+- Ошибка DLL в Windows: проверьте Microsoft Visual C++ Redistributable и установку зависимостей выбранного окружения. PyTorch устанавливать не требуется.
+- Порт 8001 занят: закройте предыдущий OCR либо запустите studio.py с --port 8002.
+- Текст не найден: убедитесь, что изображение содержит текст, а не иллюстрацию; попробуйте более чёткую страницу.
+- Видно предупреждение о длине строки: вручную проверьте обрезанный конец или разделите изображение на более короткие строки.
+

README.md

@@ -0,0 +1,188 @@
+---
+language:
+- ba
+license: apache-2.0
+pretty_name: BashkirTrOCR
+library_name: onnxruntime
+pipeline_tag: image-to-text
+tags:
+- bashkir
+- trocr
+- ocr
+- optical-character-recognition
+- vision-encoder-decoder
+- text-recognition
+- onnx
+- onnxruntime
+- int8
+- fp16
+- low-resource
+- experimental
+---
+
+# BashkirTrOCR
+
+> Optical Character Recognition for printed Bashkir books and documents, shipped as standalone ONNX models (FP16 CUDA GPU & dynamic INT8 CPU) with a local browser review studio.
+
+## Overview
+
+This model transcribes printed Bashkir text lines and full document pages. It supports the complete 42-letter Bashkir Cyrillic alphabet, including all 9 specific letters (`ә, ө, ү, ғ, ҡ, ң, һ, ҫ, ҙ`), mixed Russian-Bashkir lines, punctuation, and dialogue formatting.
+
+The release bundles a complete zero-PyTorch ONNX Runtime pipeline: `PP-OCRv3` (DBNet) text-line detection, wide-line splitting, `ViT-Base + TrOCR` recognition in both **mixed FP16** (for NVIDIA CUDA GPUs) and **dynamic INT8** (for CPUs), a CLI runner, and **Bashkir OCR Studio** — a local web interface with two review modes (line-by-line crop comparison and side-by-side full page + full text).
+
+| At a glance | |
+| --- | --- |
+| Task | Page & line-level Optical Character Recognition (`image-to-text`) |
+| Default artifact | **`models/fp16/`** (CUDA GPU) / **`models/int8/`** (CPU) |
+| Architecture | Vision-Encoder-Decoder (`ViT-Base` + `TrOCR` Causal LM) + `PP-OCRv3` detector |
+| Version / license | v3.0-onnx-runtime.1 / Apache-2.0 |
+
+## Contents
+
+### Files and Configurations
+
+| File / Directory | Purpose | Size |
+| --- | --- | ---: |
+| **`models/fp16/encoder.onnx`** (recommended for GPU) | Mixed FP16 ViT encoder for NVIDIA CUDA | 172.3 MB |
+| **`models/fp16/decoder.onnx`** (recommended for GPU) | Mixed FP16 TrOCR decoder for NVIDIA CUDA | 598.1 MB |
+| **`models/int8/encoder.onnx`** (recommended for CPU) | Dynamic INT8 ViT encoder for CPU | 89.8 MB |
+| **`models/int8/decoder.onnx`** (recommended for CPU) | Dynamic INT8 TrOCR decoder for CPU | 300.4 MB |
+| `models/dbnet.onnx` | `PP-OCRv3` text-line detector graph | 2.4 MB |
+| `tokenizer.json`, `tokenizer_config.json` | Tokenizer vocabulary (50,283 tokens) and settings | 1.8 MB |
+| `config.json`, `preprocessor_config.json` | Runtime contract, generation limits and image normalization | — |
+| `start_ocr.bat`, `studio.py`, `run.py`, `runtime/` | One-click Windows launcher, local browser studio and CLI | — |
+| `requirements-cpu.txt`, `requirements-gpu.txt` | Isolated dependency manifests for CPU and CUDA runtimes | — |
+| `QUICKSTART_RU.md` | Quickstart guide and troubleshooting in Russian | — |
+| `META.json` | Release passport and artifact hashes | — |
+| `LICENSE`, `NOTICE`, `licenses/` | Full Apache-2.0 license text and upstream attributions | — |
+| `SHA256SUMS` | Checksums of the public files | — |
+
+Raw training corpora, rendered synthetic image archives and full PyTorch checkpoints are not included.
+
+### Model Architecture
+
+| Property | Value |
+|---|---|
+| Base architecture | Vision-Encoder-Decoder (`VisionEncoderDecoderModel`) |
+| Encoder | Vision Transformer (`ViT-Base`, 12 layers, 12 attention heads, hidden size 768) |
+| Decoder | TrOCR Autoregressive Transformer Decoder (12 layers, 16 heads, hidden size 1024) |
+| Line detector | `PP-OCRv3` (DBNet) polygon detector + horizontal line merger |
+| Parameters | ~334M |
+| Vocabulary | 50,283 tokens |
+| Image resolution | 384 × 384 RGB |
+
+### Examples
+
+Side-by-side line recognition in **Bashkir OCR Studio** (cropped book lines on the left, recognized text on the right):
+
+![Bashkir OCR Studio line recognition comparison](examples/line_comparison.png)
+
+## Method
+
+```text
+BashkirTrOCR v3 pipeline
+  ├── 1. page text-line detection (PP-OCRv3 / DBNet) & horizontal box merging
+  ├── 2. wide-line splitting at whitespace valleys (aspect ratio > 20:1)
+  ├── 3. ViT-Base visual encoding (384 × 384 RGB) & autoregressive TrOCR decoding
+  └── 4. interactive browser review (line-by-line crops or full-page side-by-side)
+```
+
+The recognizer was adapted from [`microsoft/trocr-base-stage1`](https://huggingface.co/microsoft/trocr-base-stage1) with full Bashkir Cyrillic vocabulary coverage and fine-tuned on a multi-domain collection of printed text lines (books, vintage scans, and digital typography). The trained v3 checkpoint was exported to ONNX and converted into two deployment variants:
+- **Mixed FP16 (`models/fp16/`)** for NVIDIA CUDA GPUs, keeping graph inputs/outputs and numerically sensitive reductions in FP32 for exact parity with the PyTorch v3 checkpoint.
+- **Dynamic INT8 (`models/int8/`)** for standalone CPU execution without a dedicated GPU.
+
+### Benchmark
+
+Runtime parity and speed comparison between the bundled ONNX variants on the 133-line multi-page diagnostic suite (NVIDIA RTX 4060 vs CPU):
+
+| Runtime variant | Precision | Lines tested | Exact match vs PyTorch v3 | Full poem page latency | 133-line suite total time |
+| --- | --- | ---: | ---: | ---: | ---: |
+| **NVIDIA CUDA GPU** | Mixed FP16 | 133 | **133 / 133 (100%)** | **8.8 s** | **66.9 s** |
+| **CPU** | Dynamic INT8 | 133 | 114 / 133 (85.7%) | 49.7 s | 392.4 s |
+
+Differences between INT8 CPU and FP16 GPU outputs consist primarily of dash variants (`—` vs `–`) and minor punctuation on degraded scans.
+
+## Quality and Use
+
+Use this release for assisted digitization of printed Bashkir books, articles, and dictionary pages. The bundled **Bashkir OCR Studio** (`studio.py` / `start_ocr.bat`) serves as a ready-to-run reference application for single-page interactive review with two view modes:
+- **Line-by-line review** — inspect each detected line crop alongside its editable transcription.
+- **Full page & text** — view the full page scan on the left and edit the complete page text as a single block on the right, with one-click clipboard copy and UTF-8 text export.
+
+For large-scale book digitization, the standalone `OCR` engine (`runtime/engine.py`) or the raw ONNX graphs can be directly integrated into custom batch, PDF, or multi-page processing pipelines.
+
+### Limitations
+
+- Tiny superscript footnote digits can be confused with punctuation (e.g. `1 → !`), and visually similar glyphs (`1`, `I`, `l`, `7`) require attention.
+- Multi-column layouts, heavy page skew, decorative dividers, and low-contrast scans can affect reading order or line boundaries.
+- Wide-line splitting may introduce spaces or split hyphenated words across chunk boundaries.
+- Designed for printed Cyrillic Bashkir text; not intended for handwriting or historical Arabic-script manuscripts.
+
+## Related Resources
+
+- [Bashkir Diacritics Restorer](https://huggingface.co/failed09/bashkir-diacritics-restorer) — character-level restorer for Bashkir-specific letters (`ә, ө, ү, ғ, ҡ, ң, һ, ҫ, ҙ`), useful for post-correcting characters confused on degraded scans.
+- [BashkirRoBERTa](https://huggingface.co/failed09/bashkir-roberta) — pretrained Bashkir masked language model suitable for scoring OCR hypotheses and reconstructing damaged words or broken line fragments.
+
+## Usage
+
+> **Note:** The bundled `Bashkir OCR Studio` web interface is provided as an interactive single-page usage example. For automated multi-page or full-book processing, import `runtime.engine.OCR` (or run the ONNX sessions directly) in your own batch pipeline.
+
+### 1. Local Browser Studio (Windows One-Click Example)
+
+Download the repository and double-click `start_ocr.bat`. By default (`[3] Auto`), the launcher automatically detects an NVIDIA GPU via `nvidia-smi`, creates an isolated `.venv-gpu` environment (or `.venv-cpu` on CPU-only machines), installs dependencies, and opens **Bashkir OCR Studio** at `http://127.0.0.1:8001`:
+
+```bash
+pip install huggingface_hub
+hf download failed09/bashkir-trocr-base --local-dir bashkir-ocr
+```
+
+### 2. Command-Line & Custom Pipeline API
+
+```bash
+cd bashkir-ocr
+python -m venv .venv-gpu
+.venv-gpu\Scripts\python -m pip install -r requirements-gpu.txt
+
+# Transcribe a page image from CLI (use --backend auto, gpu, or cpu)
+.venv-gpu\Scripts\python run.py page.png --backend auto --output result.txt
+
+# Launch the web studio manually
+.venv-gpu\Scripts\python studio.py --backend auto
+```
+
+```python
+from PIL import Image
+from runtime.engine import OCR
+
+ocr = OCR(".", backend="auto")  # selects CUDA FP16 if available, else CPU INT8
+result = ocr.recognize(Image.open("page.png"))
+print(result["full_text"])
+```
+
+## License
+
+The model weights, ONNX graphs and runtime code are distributed under [Apache-2.0](https://huggingface.co/failed09/bashkir-trocr-base/blob/main/LICENSE). Upstream attributions for TrOCR (`MIT`) and RapidOCR (`Apache-2.0`) are recorded in [NOTICE](https://huggingface.co/failed09/bashkir-trocr-base/blob/main/NOTICE). Rights in original source publications remain with their respective owners; raw book scans and training texts are not redistributed.
+
+## Citation
+
+```bibtex
+@software{failed09_bashkir_trocr_2026,
+  title = {BashkirTrOCR: Printed Bashkir OCR with ONNX Runtime (FP16 CUDA & INT8 CPU)},
+  author = {failed09},
+  year = {2026},
+  publisher = {Hugging Face},
+  url = {https://huggingface.co/failed09/bashkir-trocr-base},
+  note = {Optical Character Recognition model and local review studio for Bashkir}
+}
+```
+
+## Open Bashkir Data and Sources 🐝
+
+This release is part of an open-source effort to support the development,
+preservation and practical use of the Bashkir language. Other related models,
+datasets and tools are available on the author's Hugging Face profile.
+
+The author does not claim ownership or authorship of the source texts or other
+materials used to derive this release; rights and licensing remain with the
+original authors, publishers and dataset providers. Source texts are not
+redistributed in this repository, so users should follow the licenses and
+attribution requirements of the relevant upstream resources.

SHA256SUMS

@@ -0,0 +1,28 @@
+3ddf9be5c28fe27dad143a5dc76eea25222ad1dd68934a047064e56ed2fa40c5  LICENSE
+6eb2c965307dc568082b8e63bef68828e571f37d9aadd19a1b8d9f0fbff6e6b0  META.json
+a7269948dafa3fd519facba67890b90704d566609ba86c3555d02ce62f4c9c24  NOTICE
+b0d20c0131758208f59219b5aac7910c08147cac9a42789ab7952b9c10f4c520  QUICKSTART_RU.md
+8c0b2fba7bbfd16caa92bccbc50e85050a379e13a3cf8972fc4fdb30290aa290  README.md
+6af91e2db60bc88f047eebb53414e1de8bd1015d2566e801f34ef9f5ea71e6c2  config.json
+58fb88778d56947e0929d8fb5d85e60e8fb18485061c465b9d3b3f3ed26e4219  examples/line_comparison.png
+3e0af25fdd06aa9586ae97adb00ea927ebe5a3805ac77d2d3a81ce5f55693333  licenses/RapidOCR-Apache-2.0.txt
+904dc4d8749877f1dba1cda48200d2462dccbeb7c134d5e4ef6fa75e0198c8fe  licenses/TrOCR-MIT.txt
+3439588c030faea393a54515f51e983d8e155b19a2e8aba7891934c1cf0de526  models/dbnet.onnx
+e55c720fd10ae8f290c28d06a150dc118a118d020f7405fef85a1b273d9ed7a3  models/fp16/decoder.onnx
+90a4ee3d331ea59cc2b60a860064ded38a3953163a33d4d16ce34f9b640103a5  models/fp16/encoder.onnx
+e04bcbaaee07851e7b0a47c7b271fcd85a4d8b68623a3241e2c968c22808aecb  models/int8/decoder.onnx
+c9773380fd2e85ec4ccc07f570de7c2e63c88784570d3378a6af1ae744c7ca04  models/int8/encoder.onnx
+1918ad875a1cd08aa9ca0ecb3e4ae13adabe89f850a038f35f485d916bbd6e10  preprocessor_config.json
+77feb31f7f3f15a17fd569064c23abe9fa718f4a399dde268559ab644fae6512  requirements-common.txt
+d1fc9108e0de2d3186caf337a97971c14032ef66001c2ec0024642b51eaa40c6  requirements-cpu.txt
+a91cea3236c184653692f95944fa2c4967a7b431f7fa84029ef6efb2f26eac75  requirements-gpu.txt
+8492c5f8e6048e769bd2a4ed1e51b57d4cfad036e30c6e7f4ec7bd3799b23ec5  run.py
+089c2e7f646157f37640ac8dced5f20aa417728aa24d0ffc1c5cc4e37f9de21d  runtime/__init__.py
+7447d83ba6825d95db99fb4b561a223d94dcd4f32de7c4670d4ee82df2b6af81  runtime/dbnet_utils.py
+380642fbed945044c7ae3f18a7565b569c32146ec5f13d5ca090f7e68354b617  runtime/engine.py
+2eae00b66dff26e0a28c7d7c7b4ad8bbe7619926cc33a4f5c4111af2c8d28dfc  runtime/index.html
+af060a2df181d242311694ee5053fe52e4b1cf2a9758a666abb0488f37403cfa  runtime/line_merger.py
+293d3851b50aa16bf4f966d48a785d66187153ca86b8011a5b2ef1a2811e2b58  start_ocr.bat
+32ea287ac8d514ccc0dafec12c293e604d328ed69b32453754ff6340b5be1762  studio.py
+04ac1e6dec3f09a8cd17adbcc1d4a7809dbb3bdd2f800cbc8e9f33ec4155b28a  tokenizer.json
+416c94e5774d3bdf841aeea13f526ec76fe137b18db3acd56f65e7bc4d399ea3  tokenizer_config.json

config.json

@@ -0,0 +1,18 @@
+{
+  "architecture": "ViT-Base + TrOCR decoder",
+  "image_size": 384,
+  "decoder_start_token_id": 0,
+  "eos_token_id": 2,
+  "pad_token_id": 1,
+  "max_new_tokens": 256,
+  "variants": {
+    "int8": {
+      "encoder": "models/int8/encoder.onnx",
+      "decoder": "models/int8/decoder.onnx"
+    },
+    "fp16": {
+      "encoder": "models/fp16/encoder.onnx",
+      "decoder": "models/fp16/decoder.onnx"
+    }
+  }
+}

licenses/RapidOCR-Apache-2.0.txt

@@ -0,0 +1,203 @@
+Copyright (c) 2021 RapidOCR Authors. All rights reserved.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2021 RapidAI. All rights reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

licenses/TrOCR-MIT.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

models/dbnet.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3439588c030faea393a54515f51e983d8e155b19a2e8aba7891934c1cf0de526
+size 2432880

models/fp16/decoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e55c720fd10ae8f290c28d06a150dc118a118d020f7405fef85a1b273d9ed7a3
+size 598137053

models/fp16/encoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90a4ee3d331ea59cc2b60a860064ded38a3953163a33d4d16ce34f9b640103a5
+size 172327813

models/int8/decoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e04bcbaaee07851e7b0a47c7b271fcd85a4d8b68623a3241e2c968c22808aecb
+size 300449064

models/int8/encoder.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c9773380fd2e85ec4ccc07f570de7c2e63c88784570d3378a6af1ae744c7ca04
+size 89817188

preprocessor_config.json

@@ -0,0 +1,23 @@
+{
+  "do_normalize": true,
+  "do_rescale": true,
+  "do_resize": true,
+  "image_mean": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "image_processor_type": "ViTImageProcessor",
+  "image_std": [
+    0.5,
+    0.5,
+    0.5
+  ],
+  "processor_class": "TrOCRProcessor",
+  "resample": 2,
+  "rescale_factor": 0.00392156862745098,
+  "size": {
+    "height": 384,
+    "width": 384
+  }
+}

requirements-common.txt

@@ -0,0 +1,9 @@
+numpy>=1.26,<3
+Pillow>=11,<13
+tokenizers>=0.22,<0.23
+opencv-python-headless>=4.10,<5
+pyclipper>=1.3,<2
+shapely>=2,<3
+fastapi>=0.115,<1
+uvicorn>=0.30,<1
+python-multipart>=0.0.20,<0.1

requirements-cpu.txt

@@ -0,0 +1,2 @@
+-r requirements-common.txt
+onnxruntime==1.22.0

requirements-gpu.txt

@@ -0,0 +1,4 @@
+-r requirements-common.txt
+onnxruntime-gpu[cuda,cudnn]==1.22.0
+# ORT 1.22 convolution frontend was validated with cuDNN 9.1; 9.27 failed.
+nvidia-cudnn-cu12==9.1.0.70

run.py

@@ -0,0 +1,21 @@
+"""Recognize one image locally and write UTF-8 text and JSON."""
+import argparse
+import json
+from pathlib import Path
+from PIL import Image
+from runtime.engine import OCR
+
+
+def main():
+    p=argparse.ArgumentParser(description=__doc__)
+    p.add_argument('image',type=Path)
+    p.add_argument('--backend',choices=['cpu','gpu','auto'],default='cpu')
+    p.add_argument('--output',type=Path,default=Path('result.txt'))
+    args=p.parse_args()
+    with Image.open(args.image) as image:r=OCR(backend=args.backend).recognize(image,include_images=False)
+    args.output.write_text(r['full_text']+'\n',encoding='utf-8')
+    args.output.with_suffix('.json').write_text(json.dumps(r,ensure_ascii=False,indent=2)+'\n',encoding='utf-8')
+    print(f'Saved {args.output}; backend={r["backend"]}; lines={len(r["lines"])}')
+
+
+if __name__=='__main__':main()

runtime/__init__.py

@@ -0,0 +1 @@
+"""Standalone Bashkir OCR; no PyTorch or Transformers dependency."""

runtime/dbnet_utils.py

@@ -0,0 +1,290 @@
+"""
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+# -*- encoding: utf-8 -*-
+# @Author: SWHL
+# Modified: selected detector helpers only; no recognition/classifier runtime.
+import cv2
+import numpy as np
+import pyclipper
+from shapely.geometry import Polygon
+
+class DetResizeForTest():
+    def __init__(self, **kwargs):
+        super(DetResizeForTest, self).__init__()
+        self.resize_type = 0
+        if 'image_shape' in kwargs:
+            self.image_shape = kwargs['image_shape']
+            self.resize_type = 1
+        elif 'limit_side_len' in kwargs:
+            self.limit_side_len = kwargs.get('limit_side_len', 736)
+            self.limit_type = kwargs.get('limit_type', 'min')
+
+        if 'resize_long' in kwargs:
+            self.resize_type = 2
+            self.resize_long = kwargs.get('resize_long', 960)
+        else:
+            self.limit_side_len = kwargs.get('limit_side_len', 736)
+            self.limit_type = kwargs.get('limit_type', 'min')
+
+    def __call__(self, data):
+        img = data['image']
+        src_h, src_w = img.shape[:2]
+
+        if self.resize_type == 0:
+            # img, shape = self.resize_image_type0(img)
+            img, [ratio_h, ratio_w] = self.resize_image_type0(img)
+        elif self.resize_type == 2:
+            img, [ratio_h, ratio_w] = self.resize_image_type2(img)
+        else:
+            # img, shape = self.resize_image_type1(img)
+            img, [ratio_h, ratio_w] = self.resize_image_type1(img)
+        data['image'] = img
+        data['shape'] = np.array([src_h, src_w, ratio_h, ratio_w])
+        return data
+
+    def resize_image_type1(self, img):
+        resize_h, resize_w = self.image_shape
+        ori_h, ori_w = img.shape[:2]  # (h, w, c)
+        ratio_h = float(resize_h) / ori_h
+        ratio_w = float(resize_w) / ori_w
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        # return img, np.array([ori_h, ori_w])
+        return img, [ratio_h, ratio_w]
+
+    def resize_image_type0(self, img):
+        """
+        resize image to a size multiple of 32 which is required by the network
+        args:
+            img(array): array with shape [h, w, c]
+        return(tuple):
+            img, (ratio_h, ratio_w)
+        """
+        limit_side_len = self.limit_side_len
+        h, w = img.shape[:2]
+
+        # limit the max side
+        if self.limit_type == 'max':
+            if max(h, w) > limit_side_len:
+                if h > w:
+                    ratio = float(limit_side_len) / h
+                else:
+                    ratio = float(limit_side_len) / w
+            else:
+                ratio = 1.
+        else:
+            if min(h, w) < limit_side_len:
+                if h < w:
+                    ratio = float(limit_side_len) / h
+                else:
+                    ratio = float(limit_side_len) / w
+            else:
+                ratio = 1.
+        resize_h = int(h * ratio)
+        resize_w = int(w * ratio)
+
+        resize_h = int(round(resize_h / 32) * 32)
+        resize_w = int(round(resize_w / 32) * 32)
+
+        try:
+            if int(resize_w) <= 0 or int(resize_h) <= 0:
+                return None, (None, None)
+            img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        except:
+            print(img.shape, resize_w, resize_h)
+            sys.exit(0)
+        ratio_h = resize_h / float(h)
+        ratio_w = resize_w / float(w)
+        return img, [ratio_h, ratio_w]
+
+    def resize_image_type2(self, img):
+        h, w = img.shape[:2]
+
+        resize_w = w
+        resize_h = h
+
+        # Fix the longer side
+        if resize_h > resize_w:
+            ratio = float(self.resize_long) / resize_h
+        else:
+            ratio = float(self.resize_long) / resize_w
+
+        resize_h = int(resize_h * ratio)
+        resize_w = int(resize_w * ratio)
+
+        max_stride = 128
+        resize_h = (resize_h + max_stride - 1) // max_stride * max_stride
+        resize_w = (resize_w + max_stride - 1) // max_stride * max_stride
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        ratio_h = resize_h / float(h)
+        ratio_w = resize_w / float(w)
+
+        return img, [ratio_h, ratio_w]
+
+
+class DBPostProcess():
+    """The post process for Differentiable Binarization (DB)."""
+
+    def __init__(self,
+                 thresh=0.3,
+                 box_thresh=0.7,
+                 max_candidates=1000,
+                 unclip_ratio=2.0,
+                 score_mode="fast",
+                 use_dilation=False):
+        self.thresh = thresh
+        self.box_thresh = box_thresh
+        self.max_candidates = max_candidates
+        self.unclip_ratio = unclip_ratio
+        self.min_size = 3
+        self.score_mode = score_mode
+
+        if use_dilation:
+            self.dilation_kernel = np.array([[1, 1], [1, 1]])
+        else:
+            self.dilation_kernel = None
+
+    def boxes_from_bitmap(self, pred, _bitmap, dest_width, dest_height):
+        '''
+        _bitmap: single map with shape (1, H, W),
+                whose values are binarized as {0, 1}
+        '''
+
+        bitmap = _bitmap
+        height, width = bitmap.shape
+
+        outs = cv2.findContours((bitmap * 255).astype(np.uint8), cv2.RETR_LIST,
+                                cv2.CHAIN_APPROX_SIMPLE)
+        if len(outs) == 3:
+            img, contours, _ = outs[0], outs[1], outs[2]
+        elif len(outs) == 2:
+            contours, _ = outs[0], outs[1]
+
+        num_contours = min(len(contours), self.max_candidates)
+
+        boxes = []
+        scores = []
+        for index in range(num_contours):
+            contour = contours[index]
+            points, sside = self.get_mini_boxes(contour)
+            if sside < self.min_size:
+                continue
+            points = np.array(points)
+            if self.score_mode == "fast":
+                score = self.box_score_fast(pred, points.reshape(-1, 2))
+            else:
+                score = self.box_score_slow(pred, contour)
+            if self.box_thresh > score:
+                continue
+
+            box = self.unclip(points).reshape(-1, 1, 2)
+            box, sside = self.get_mini_boxes(box)
+            if sside < self.min_size + 2:
+                continue
+            box = np.array(box)
+
+            box[:, 0] = np.clip(
+                np.round(box[:, 0] / width * dest_width), 0, dest_width)
+            box[:, 1] = np.clip(
+                np.round(box[:, 1] / height * dest_height), 0, dest_height)
+            boxes.append(box.astype(np.int16))
+            scores.append(score)
+        return np.array(boxes, dtype=np.int16), scores
+
+    def unclip(self, box):
+        unclip_ratio = self.unclip_ratio
+        poly = Polygon(box)
+        distance = poly.area * unclip_ratio / poly.length
+        offset = pyclipper.PyclipperOffset()
+        offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+        expanded = np.array(offset.Execute(distance))
+        return expanded
+
+    def get_mini_boxes(self, contour):
+        bounding_box = cv2.minAreaRect(contour)
+        points = sorted(list(cv2.boxPoints(bounding_box)), key=lambda x: x[0])
+
+        index_1, index_2, index_3, index_4 = 0, 1, 2, 3
+        if points[1][1] > points[0][1]:
+            index_1 = 0
+            index_4 = 1
+        else:
+            index_1 = 1
+            index_4 = 0
+        if points[3][1] > points[2][1]:
+            index_2 = 2
+            index_3 = 3
+        else:
+            index_2 = 3
+            index_3 = 2
+
+        box = [
+            points[index_1], points[index_2], points[index_3], points[index_4]
+        ]
+        return box, min(bounding_box[1])
+
+    def box_score_fast(self, bitmap, _box):
+        h, w = bitmap.shape[:2]
+        box = _box.copy()
+        xmin = np.clip(np.floor(box[:, 0].min()).astype(np.int32), 0, w - 1)
+        xmax = np.clip(np.ceil(box[:, 0].max()).astype(np.int32), 0, w - 1)
+        ymin = np.clip(np.floor(box[:, 1].min()).astype(np.int32), 0, h - 1)
+        ymax = np.clip(np.ceil(box[:, 1].max()).astype(np.int32), 0, h - 1)
+
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        box[:, 0] = box[:, 0] - xmin
+        box[:, 1] = box[:, 1] - ymin
+        cv2.fillPoly(mask, box.reshape(1, -1, 2).astype(np.int32), 1)
+        return cv2.mean(bitmap[ymin:ymax + 1, xmin:xmax + 1], mask)[0]
+
+    def box_score_slow(self, bitmap, contour):
+        '''
+        box_score_slow: use polyon mean score as the mean score
+        '''
+        h, w = bitmap.shape[:2]
+        contour = contour.copy()
+        contour = np.reshape(contour, (-1, 2))
+
+        xmin = np.clip(np.min(contour[:, 0]), 0, w - 1)
+        xmax = np.clip(np.max(contour[:, 0]), 0, w - 1)
+        ymin = np.clip(np.min(contour[:, 1]), 0, h - 1)
+        ymax = np.clip(np.max(contour[:, 1]), 0, h - 1)
+
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+
+        contour[:, 0] = contour[:, 0] - xmin
+        contour[:, 1] = contour[:, 1] - ymin
+
+        cv2.fillPoly(mask, contour.reshape(1, -1, 2).astype(np.int32), 1)
+        return cv2.mean(bitmap[ymin:ymax + 1, xmin:xmax + 1], mask)[0]
+
+    def __call__(self, pred, shape_list):
+        pred = pred[:, 0, :, :]
+        segmentation = pred > self.thresh
+
+        boxes_batch = []
+        for batch_index in range(pred.shape[0]):
+            src_h, src_w, ratio_h, ratio_w = shape_list[batch_index]
+            if self.dilation_kernel is not None:
+                mask = cv2.dilate(
+                    np.array(segmentation[batch_index]).astype(np.uint8),
+                    self.dilation_kernel)
+            else:
+                mask = segmentation[batch_index]
+            boxes, scores = self.boxes_from_bitmap(pred[batch_index], mask,
+                                                   src_w, src_h)
+
+            boxes_batch.append({'points': boxes})
+        return boxes_batch

runtime/engine.py

@@ -0,0 +1,141 @@
+"""Local ONNX OCR with shared detection and line assembly for CPU/GPU."""
+import base64
+import io
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+import cv2
+from PIL import Image, ImageOps
+from tokenizers import Tokenizer
+
+from .dbnet_utils import DBPostProcess, DetResizeForTest
+from .line_merger import merge_line_boxes
+
+
+def pixels(image, config):
+    size=config['size']
+    image=image.convert('RGB').resize((size['width'],size['height']),Image.Resampling(config['resample']))
+    x=np.asarray(image,dtype=np.float32)*np.float32(config['rescale_factor'])
+    x=(x-np.asarray(config['image_mean'],dtype=np.float32))/np.asarray(config['image_std'],dtype=np.float32)
+    return np.ascontiguousarray(x.transpose(2,0,1)[None])
+
+
+def split_line(image, ratio=20):
+    w,h=image.size
+    if w/max(h,1)<=ratio:return [image]
+    ink=(np.asarray(image.convert('L'))<210).sum(axis=0)
+    runs=[];start=None
+    for x,value in enumerate(ink):
+        if value==0 and start is None:start=x
+        elif value!=0 and start is not None:runs.append((start,x));start=None
+    if start is not None:runs.append((start,w))
+    gaps=[(a,b) for a,b in runs if a>40 and b<w-40 and b-a>=8]
+    if gaps:
+        a,b=min(gaps,key=lambda r:abs((r[0]+r[1])/2-w/2));cut=(a+b)//2
+    else:
+        left,right=int(w*.35),int(w*.65)
+        cut=left+int(np.argmin(ink[left:right])) if right>left else w//2
+    cut=max(1,min(w-1,cut))
+    return split_line(image.crop((0,0,cut,h)),ratio)+split_line(image.crop((cut,0,w,h)),ratio)
+
+
+def preview(image):
+    image=image.copy();image.thumbnail((1100,180))
+    out=io.BytesIO();image.save(out,format='PNG')
+    return 'data:image/png;base64,'+base64.b64encode(out.getvalue()).decode('ascii')
+
+
+class OCR:
+    def __init__(self, root=None, backend='cpu', threads=4):
+        import onnxruntime as ort
+        ort.disable_telemetry_events()
+        self.root=Path(root or Path(__file__).resolve().parents[1])
+        self.config=json.loads((self.root/'config.json').read_text(encoding='utf-8'))
+        self.preprocess=json.loads((self.root/'preprocessor_config.json').read_text(encoding='utf-8'))
+        self.tokenizer=Tokenizer.from_file(str(self.root/'tokenizer.json'))
+        self.tokenizer.no_padding();self.tokenizer.no_truncation()
+        requested_backend=backend
+        if backend not in ('cpu','gpu','auto'):raise ValueError('backend must be cpu, gpu or auto')
+        if backend in ('gpu','auto') and hasattr(ort,'preload_dlls'):
+            ort.preload_dlls()
+        if backend=='auto':backend='gpu' if 'CUDAExecutionProvider' in ort.get_available_providers() else 'cpu'
+        if backend=='gpu' and 'CUDAExecutionProvider' not in ort.get_available_providers():
+            raise RuntimeError('CUDA недоступна. Установите GPU-зависимости или выберите CPU.')
+        options=ort.SessionOptions();options.intra_op_num_threads=threads;options.inter_op_num_threads=1
+        if backend=='gpu':
+            variant=self.config['variants']['fp16']
+            providers=['CUDAExecutionProvider','CPUExecutionProvider']
+            try:
+                self.encoder=ort.InferenceSession(str(self.root/variant['encoder']),sess_options=options,providers=providers)
+                self.decoder=ort.InferenceSession(str(self.root/variant['decoder']),sess_options=options,providers=providers)
+                if any('CUDAExecutionProvider' not in s.get_providers() for s in (self.encoder,self.decoder)):
+                    raise RuntimeError('Модель не загрузилась на CUDA. Выберите CPU; скрытая смена GPU на CPU запрещена.')
+                self.encoder.disable_fallback()
+                self.decoder.disable_fallback()
+            except Exception:
+                if requested_backend!='auto':raise
+                backend='cpu'
+        if backend=='cpu':
+            variant=self.config['variants']['int8']
+            providers=['CPUExecutionProvider']
+            self.encoder=ort.InferenceSession(str(self.root/variant['encoder']),sess_options=options,providers=providers)
+            self.decoder=ort.InferenceSession(str(self.root/variant['decoder']),sess_options=options,providers=providers)
+        self.backend=backend
+        self.detector=ort.InferenceSession(str(self.root/'models/dbnet.onnx'),sess_options=options,providers=['CPUExecutionProvider'])
+        self.resize=DetResizeForTest(limit_side_len=736,limit_type='min')
+        self.post=DBPostProcess(thresh=.2,box_thresh=.2,max_candidates=1000,unclip_ratio=1.3,use_dilation=True,score_mode='fast')
+
+    def recognize_line(self,image):
+        hidden=self.encoder.run(None,{'pixel_values':pixels(image,self.preprocess)})[0]
+        ids=np.array([[self.config['decoder_start_token_id']]],dtype=np.int64)
+        truncated=True
+        for _ in range(self.config['max_new_tokens']):
+            logits=self.decoder.run(None,{'input_ids':ids,'encoder_hidden_states':hidden})[0]
+            if not np.isfinite(logits).all():raise RuntimeError('Non-finite decoder output')
+            token=int(np.argmax(logits[0,-1]))
+            ids=np.concatenate((ids,np.array([[token]],dtype=np.int64)),axis=1)
+            if token==self.config['eos_token_id']:truncated=False;break
+        return self.tokenizer.decode(ids[0].tolist(),skip_special_tokens=True).strip(),truncated
+
+    def detect(self,image):
+        # The original detector upsizes the short side. Bound unusually narrow
+        # images so a one-line crop cannot allocate a gigantic detector tensor.
+        scale=max(1.,736/min(image.size))
+        if max(image.size)*scale>4096:
+            scale=4096/max(image.size)
+            width=max(32,round(image.width*scale/32)*32)
+            height=max(32,round(image.height*scale/32)*32)
+            data=dict(image=cv2.resize(np.asarray(image),(width,height)),
+                      shape=np.array([image.height,image.width,height/image.height,width/image.width]))
+        else:data=self.resize({'image':np.asarray(image)})
+        x=np.asarray(data['image'],dtype=np.float32)*np.float32(1/255)
+        x=(x-np.array([.485,.456,.406],dtype=np.float32))/np.array([.229,.224,.225],dtype=np.float32)
+        x=np.ascontiguousarray(x.transpose(2,0,1)[None])
+        output=self.detector.run(None,{self.detector.get_inputs()[0].name:x})[0]
+        boxes=self.post(output,np.asarray([data['shape']]))[0]['points']
+        valid=[]
+        for box in boxes:
+            box=np.asarray(box,dtype=np.float32)
+            box[:,0]=np.clip(box[:,0],0,image.width-1);box[:,1]=np.clip(box[:,1],0,image.height-1)
+            if np.linalg.norm(box[0]-box[1])>3 and np.linalg.norm(box[0]-box[3])>3:valid.append(box)
+        return merge_line_boxes(valid,x_margin_ratio=3.5,y_overlap_thresh=.45)
+
+    def recognize(self,image,boxes=None,include_images=True):
+        t=time.perf_counter()
+        image=ImageOps.exif_transpose(image).convert('RGB')
+        if np.asarray(image.convert('L')).mean()<125:image=ImageOps.invert(image)
+        boxes=self.detect(image) if boxes is None else boxes
+        lines=[]
+        for box in boxes:
+            a,b,c,d=[int(v) for v in box]
+            if c-a<4 or d-b<4:continue
+            crop=image.crop((max(0,a-4),max(0,b-2),min(image.width,c+4),min(image.height,d+2)))
+            parts=[self.recognize_line(ch) for ch in split_line(crop)]
+            text=' '.join(s for s,_ in parts if s).strip()
+            line=dict(bbox=[a,b,c,d],text=text,truncated=any(end for _,end in parts),chunks=len(parts))
+            if include_images:line['image']=preview(crop)
+            lines.append(line)
+        return dict(backend=self.backend,lines=lines,full_text='\n'.join(row['text'] for row in lines),
+                    seconds=time.perf_counter()-t,no_text_detected=not lines)

runtime/index.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="ru"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Bashkir OCR Studio</title>
+<style>
+:root{color-scheme:light;--ink:#183333;--muted:#637778;--border:#d8e3df;--accent:#196c56}*{box-sizing:border-box}body{margin:0;background:#f3f6f2;color:var(--ink);font:16px/1.55 system-ui,sans-serif}main{max-width:1300px;margin:auto;padding:32px 24px}header{display:flex;justify-content:space-between;align-items:start;gap:20px}h1{font-size:30px;letter-spacing:-1px;margin:0}p{max-width:850px}.muted{color:var(--muted)}.card{background:white;border:1px solid var(--border);border-radius:16px;padding:24px;margin:22px 0}.controls{display:flex;gap:12px;align-items:center;flex-wrap:wrap}button,.file{border:1px solid var(--border);background:white;border-radius:9px;padding:11px 17px;font:inherit;color:var(--ink);cursor:pointer}button.primary{background:var(--accent);color:white;border-color:var(--accent)}button:disabled{opacity:.45;cursor:wait}input[type=file]{max-width:400px}#original{max-height:420px;max-width:100%;object-fit:contain;margin:18px 0}.tabs{display:inline-flex;background:#e8efec;padding:4px;border-radius:11px;border:1px solid var(--border);gap:4px}.tab{border:none;background:transparent;border-radius:8px;padding:8px 15px;font-weight:600;color:var(--muted);cursor:pointer}.tab.active{background:var(--accent);color:white;box-shadow:0 1px 3px rgba(0,0,0,.12)}.row{display:grid;grid-template-columns:42px minmax(0,1fr) minmax(0,1fr);gap:16px;padding:18px 0;border-bottom:1px solid var(--border);align-items:start}.row img{max-width:100%;background:#fff}.num{color:var(--muted);font-size:13px}textarea{width:100%;min-height:62px;resize:vertical;border:1px solid var(--border);border-radius:8px;padding:10px;font:17px/1.5 system-ui;color:var(--ink);background:#fcfdfb}.page-split{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);gap:20px;align-items:start;margin-top:12px}.page-pane{position:sticky;top:16px}.page-pane img{max-width:100%;max-height:78vh;object-fit:contain;border:1px solid var(--border);border-radius:10px;background:#fff;display:block}#fullText{min-height:520px;height:72vh;font:17px/1.6 system-ui;padding:14px}.warning{color:#9b5b12;font-size:13px}.rowhead{font-weight:600;color:var(--muted);font-size:13px}pre{white-space:pre-wrap;font:inherit}.badge{white-space:nowrap;border:1px solid var(--border);padding:7px 12px;border-radius:30px}#message[role=alert]{color:#9b3612}@media(max-width:700px){main{padding:22px 14px}.card{padding:16px}.row{grid-template-columns:25px minmax(0,1fr)}.row textarea,.row .result{grid-column:2}.rowhead{display:none}.page-split{grid-template-columns:1fr}.page-pane{position:static}header{display:block}.badge{display:inline-block;margin-top:12px}}
+</style>
+<main><header><div><h1>Bashkir OCR Studio</h1><div class="muted">Распознайте. Сверьте со сканом. Сохраните текст.</div></div><span class="badge" id="backend">Загрузка…</span></header>
+<section class="card"><div class="controls"><input id="file" type="file" accept="image/png,image/jpeg,image/webp,image/tiff,image/bmp"><button class="primary" id="recognize" disabled>Распознать</button><div style="flex:1"></div><div class="tabs" role="tablist" aria-label="Режим просмотра"><button type="button" class="tab active" id="tabLines" role="tab" aria-selected="true">По строкам</button><button type="button" class="tab" id="tabPage" role="tab" aria-selected="false">Страница и текст</button></div></div><p class="muted">Изображение обрабатывается на этом компьютере. Оно не отправляется в облако и не сохраняется сервером. Поддерживается одно изображение за раз.</p><details><summary>На что обратить внимание</summary><p class="muted">Проверьте мелкие сноски: <b>1</b> может превратиться в <b>!</b>. Возможны ошибки регистра, похожих букв и тире. Длинные строки разделяются на части; сложные колонки, наклон и декоративные элементы могут нарушать порядок и полноту текста. Результат требует вычитки.</p></details><img id="original" alt="Выбранное изображение" hidden><p id="message" aria-live="polite">Выберите изображение со страницы книги или документа.</p></section>
+<section class="card" id="results" hidden><div class="controls"><div class="tabs" role="tablist" aria-label="Режим просмотра результатов"><button type="button" class="tab active" id="tabLines2" role="tab" aria-selected="true">По строкам</button><button type="button" class="tab" id="tabPage2" role="tab" aria-selected="false">Страница и текст</button></div><div style="flex:1"></div><button id="copyText">Скопировать текст</button><button id="saveText">Сохранить TXT</button></div><p class="muted" id="summary"></p><div id="viewLines"><div class="row rowhead"><span>№</span><span>Оригинальная строка</span><span>Распознанный текст — можно исправить</span></div><div id="rows"></div></div><div id="viewPage" class="page-split" hidden><div class="page-pane"><div class="rowhead" style="margin-bottom:8px">Страница</div><img id="pageImage" alt="Исходная страница"></div><div class="text-pane"><div class="rowhead" style="margin-bottom:8px">Весь распознанный текст — можно исправить</div><textarea id="fullText" aria-label="Весь распознанный текст"></textarea></div></div></section><footer class="muted">TrOCR v3 · Без словарной автозамены · Закройте окно запуска, чтобы остановить OCR.</footer></main>
+<script>
+const $=id=>document.getElementById(id);let chosen=null,objectUrl=null,answer=null,mode='lines';
+function setMode(next){mode=next;const isPage=mode==='page';['tabLines','tabLines2'].forEach(id=>{$(id).classList.toggle('active',!isPage);$(id).setAttribute('aria-selected',String(!isPage))});['tabPage','tabPage2'].forEach(id=>{$(id).classList.toggle('active',isPage);$(id).setAttribute('aria-selected',String(isPage))});$('viewLines').hidden=isPage;$('viewPage').hidden=!isPage}
+$('tabLines').onclick=$('tabLines2').onclick=()=>setMode('lines');
+$('tabPage').onclick=$('tabPage2').onclick=()=>setMode('page');
+function syncFullFromRows(){$('fullText').value=[...$('rows').querySelectorAll('textarea')].map(x=>x.value).join('\n')}
+$('fullText').addEventListener('input',()=>{const boxes=[...$('rows').querySelectorAll('textarea')];const parts=$('fullText').value.split('\n');if(parts.length===boxes.length)boxes.forEach((b,i)=>{b.value=parts[i]})});
+fetch('/status').then(r=>r.json()).then(x=>{$('backend').textContent=x.backend==='gpu'?'NVIDIA GPU · FP16':'CPU · INT8'}).catch(()=>{$('backend').textContent='Сервер недоступен'});
+$('file').addEventListener('change',()=>{chosen=$('file').files[0];$('recognize').disabled=!chosen;if(objectUrl)URL.revokeObjectURL(objectUrl);if(chosen){objectUrl=URL.createObjectURL(chosen);$('original').src=objectUrl;$('pageImage').src=objectUrl;$('original').hidden=false;$('results').hidden=true;$('message').textContent='Нажмите «Распознать».'}});
+$('recognize').onclick=async()=>{if(!chosen)return;$('recognize').disabled=true;$('message').removeAttribute('role');$('message').textContent='Идёт распознавание. На CPU это может занять несколько минут.';$('results').hidden=true;try{const data=new FormData();data.append('file',chosen);const response=await fetch('/recognize',{method:'POST',body:data});if(!response.ok){const e=await response.json();throw new Error(e.detail||'Не удалось распознать изображение')}answer=await response.json();$('rows').replaceChildren();answer.lines.forEach((line,index)=>{const row=document.createElement('div');row.className='row';const n=document.createElement('span');n.className='num';n.textContent=index+1;const img=document.createElement('img');img.src=line.image;img.alt='Строка '+(index+1);const result=document.createElement('div');result.className='result';const edit=document.createElement('textarea');edit.value=line.text;edit.setAttribute('aria-label','Текст строки '+(index+1));edit.addEventListener('input',syncFullFromRows);result.append(edit);if(line.truncated){const note=document.createElement('div');note.className='warning';note.textContent='Достигнут предел длины: проверьте, не обрезана ли строка.';result.append(note)}row.append(n,img,result);$('rows').append(row)});syncFullFromRows();$('summary').textContent=`Строк: ${answer.lines.length}. Время: ${answer.seconds.toFixed(1)} с. ${answer.backend==='gpu'?'GPU FP16':'CPU INT8'}.`;$('message').textContent=answer.no_text_detected?'Текст не обнаружен. Проверьте, есть ли он на изображении; модель не распознаёт иллюстрацию как целую строку.':'Готово. Переключайте вкладки «По строкам» и «Страница и текст» для удобной сверки.';$('results').hidden=answer.no_text_detected;if(!answer.no_text_detected)$('original').hidden=true}catch(e){$('message').setAttribute('role','alert');$('message').textContent=e.message}finally{$('recognize').disabled=!chosen}};
+function currentText(){return($('fullText').value||[...$('rows').querySelectorAll('textarea')].map(x=>x.value).join('\n'))}
+function save(content,type,name){const url=URL.createObjectURL(new Blob([content],{type}));const a=document.createElement('a');a.href=url;a.download=name;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000)}
+$('copyText').onclick=async()=>{await navigator.clipboard.writeText(currentText());const old=$('copyText').textContent;$('copyText').textContent='Скопировано!';setTimeout(()=>{$('copyText').textContent=old},1500)};
+$('saveText').onclick=()=>save(currentText()+'\n','text/plain;charset=utf-8','ocr-result.txt');
+</script></html>
+
+

runtime/line_merger.py

@@ -0,0 +1,98 @@
+import numpy as np
+
+def merge_line_boxes(det_res, x_margin_ratio=2.5, y_overlap_thresh=0.45):
+    """
+    Умное объединение разрезанных боксов одной строки (Horizontal Line Merging).
+
+    :param det_res: список кортежей (box, text, score) от PaddleOCR/RapidOCR
+    :param x_margin_ratio: максимальное расстояние между словами одной строки (в долях высоты)
+    :param y_overlap_thresh: минимальный коэффициент вертикального перекрытия для принадлежности к одной строке
+    """
+    if det_res is None or len(det_res) == 0:
+        return []
+
+    # Преобразуем в структурированные прямоугольники [xmin, ymin, xmax, ymax]
+    rects = []
+    for item in det_res:
+        if isinstance(item, (list, tuple)) and len(item) > 0 and isinstance(item[0], (list, tuple, np.ndarray)):
+            box = np.array(item[0]).astype(int)
+        else:
+            box = np.array(item).astype(int)
+
+        if box.ndim == 2 and box.shape[0] >= 4:
+            xmin = int(np.min(box[:, 0]))
+            xmax = int(np.max(box[:, 0]))
+            ymin = int(np.min(box[:, 1]))
+            ymax = int(np.max(box[:, 1]))
+        elif len(box) == 4:
+            xmin, ymin, xmax, ymax = int(box[0]), int(box[1]), int(box[2]), int(box[3])
+        else:
+            continue
+
+        h = max(1, ymax - ymin)
+        w = max(1, xmax - xmin)
+        rects.append({
+            "box": [xmin, ymin, xmax, ymax],
+            "xmin": xmin, "xmax": xmax,
+            "ymin": ymin, "ymax": ymax,
+            "h": h, "w": w,
+            "cy": (ymin + ymax) / 2.0
+        })
+
+    if not rects:
+        return []
+
+    # Сортируем сначала по вертикали Y
+    rects.sort(key=lambda r: (r["ymin"], r["xmin"]))
+
+    # Группируем боксы по строкам с проверкой близости вертикальных центров
+    lines = []
+    for r in rects:
+        placed = False
+        for line in lines:
+            line_ymin = min(x["ymin"] for x in line)
+            line_ymax = max(x["ymax"] for x in line)
+            line_cy = (line_ymin + line_ymax) / 2.0
+            line_h = max(1, line_ymax - line_ymin)
+
+            # Проверяем расстояние между центрами строк
+            center_diff = abs(r["cy"] - line_cy)
+            if center_diff <= min(r["h"], line_h) * 0.45:
+                line.append(r)
+                placed = True
+                break
+        if not placed:
+            lines.append([r])
+
+    # Внутри каждой строки сортируем слева направо и объединяем
+    merged_boxes = []
+    for line in lines:
+        line.sort(key=lambda r: r["xmin"])
+
+        cur_xmin = line[0]["xmin"]
+        cur_xmax = line[0]["xmax"]
+        cur_ymin = line[0]["ymin"]
+        cur_ymax = line[0]["ymax"]
+
+        for next_r in line[1:]:
+            avg_h = ((cur_ymax - cur_ymin) + next_r["h"]) / 2.0
+            dist_x = next_r["xmin"] - cur_xmax
+
+            # Если боксы достаточно близко по горизонтали — объединяем в один
+            if dist_x <= avg_h * x_margin_ratio:
+                cur_xmax = max(cur_xmax, next_r["xmax"])
+                cur_ymin = min(cur_ymin, next_r["ymin"])
+                cur_ymax = max(cur_ymax, next_r["ymax"])
+            else:
+                # Слишком далеко (например, две колонки текста) — сохраняем отдельно
+                merged_boxes.append([cur_xmin, cur_ymin, cur_xmax, cur_ymax])
+                cur_xmin = next_r["xmin"]
+                cur_xmax = next_r["xmax"]
+                cur_ymin = next_r["ymin"]
+                cur_ymax = next_r["ymax"]
+
+        merged_boxes.append([cur_xmin, cur_ymin, cur_xmax, cur_ymax])
+
+    # Сортируем итоговые строки строго сверху вниз
+    merged_boxes.sort(key=lambda b: (b[1], b[0]))
+    return merged_boxes

start_ocr.bat

@@ -0,0 +1,47 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+title Bashkir OCR Studio v3
+echo [1] CPU - ONNX INT8
+echo [2] NVIDIA GPU - ONNX FP16
+echo [3] Auto - detect NVIDIA GPU (FP16) or fall back to CPU (INT8)
+set "OCR_MODE="
+set /p "OCR_MODE=Choose mode [1/2/3, default 3]: "
+if "%OCR_MODE%"=="" set "OCR_MODE=3"
+set "OCR_BACKEND=cpu"
+set "OCR_RUN_BACKEND=cpu"
+if "%OCR_MODE%"=="2" (
+ set "OCR_BACKEND=gpu"
+ set "OCR_RUN_BACKEND=gpu"
+)
+if "%OCR_MODE%"=="3" (
+ set "OCR_RUN_BACKEND=auto"
+ if exist ".venv-gpu\.ready" (
+  set "OCR_BACKEND=gpu"
+ ) else (
+  nvidia-smi >nul 2>&1
+  if not errorlevel 1 set "OCR_BACKEND=gpu"
+ )
+)
+set "OCR_ENV=.venv-%OCR_BACKEND%"
+if exist "%OCR_ENV%\.ready" goto LAUNCH
+echo First start (%OCR_BACKEND%): Python 3.11-3.13 and internet access are needed to install dependencies.
+python --version >nul 2>&1
+if errorlevel 1 (
+ echo Install Python from python.org and enable Add Python to PATH.
+ goto FINISH
+)
+if not exist "%OCR_ENV%\Scripts\python.exe" python -m venv "%OCR_ENV%"
+if errorlevel 1 goto FINISH
+"%OCR_ENV%\Scripts\python.exe" -m pip install -r "requirements-%OCR_BACKEND%.txt"
+if errorlevel 1 (
+ echo Installation failed. Check your connection, then run install again:
+ echo %OCR_ENV%\Scripts\python.exe -m pip install -r requirements-%OCR_BACKEND%.txt
+ goto FINISH
+)
+type nul > "%OCR_ENV%\.ready"
+:LAUNCH
+"%OCR_ENV%\Scripts\python.exe" studio.py --backend %OCR_RUN_BACKEND%
+:FINISH
+pause
+

studio.py

@@ -0,0 +1,59 @@
+"""Local browser UI. Uploaded images live only in request memory."""
+import argparse
+import io
+import threading
+import time
+import webbrowser
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+from PIL import Image, UnidentifiedImageError
+from starlette.concurrency import run_in_threadpool
+from runtime.engine import OCR
+
+
+def create_app(ocr):
+    app=FastAPI(title='Bashkir OCR Studio',docs_url=None,redoc_url=None)
+    lock=threading.Lock()
+    @app.get('/')
+    def index():return FileResponse(Path(__file__).parent/'runtime/index.html',headers={'Cache-Control':'no-store, no-cache, must-revalidate','Pragma':'no-cache','Expires':'0'})
+    @app.get('/status')
+    def status():return dict(ready=True,backend=ocr.backend)
+    @app.post('/recognize')
+    async def recognize(file:UploadFile):
+        data=await file.read(25*1024*1024+1)
+        if len(data)>25*1024*1024:raise HTTPException(413,'Изображение слишком большое: предел 25 МБ.')
+        try:
+            image=Image.open(io.BytesIO(data))
+            if image.width*image.height>25_000_000:raise HTTPException(413,'Предел — 25 миллионов пикселей.')
+            image.load()
+        except (UnidentifiedImageError,OSError,Image.DecompressionBombError):raise HTTPException(400,'Не удалось открыть изображение.')
+        if not lock.acquire(blocking=False):raise HTTPException(409,'Дождитесь завершения текущего изображения.')
+        try:return await run_in_threadpool(ocr.recognize,image)
+        finally:lock.release()
+    return app
+
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--backend',choices=['cpu','gpu','auto'],default='cpu')
+    parser.add_argument('--port',type=int,default=8001)
+    parser.add_argument('--no-browser',action='store_true')
+    parser.add_argument('--model-dir',type=Path,help='Optional directory containing config.json and model files')
+    args=parser.parse_args()
+    ocr=OCR(root=args.model_dir,backend=args.backend)
+    if not args.no_browser:
+        def open_ready():
+            import urllib.request
+            for _ in range(60):
+                try:
+                    with urllib.request.urlopen(f'http://127.0.0.1:{args.port}/status',timeout=1) as r:
+                        if r.status==200:webbrowser.open(f'http://127.0.0.1:{args.port}/?v={int(time.time())}');return
+                except OSError:time.sleep(.5)
+        threading.Thread(target=open_ready,daemon=True).start()
+    import uvicorn
+    uvicorn.run(create_app(ocr),host='127.0.0.1',port=args.port,access_log=False)
+
+
+if __name__=='__main__':main()

tokenizer_config.json

@@ -0,0 +1 @@
+{"add_prefix_space": false, "added_tokens_decoder": {"0": {"content": "<s>", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": true}, "1": {"content": "<pad>", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": true}, "2": {"content": "</s>", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": true}, "3": {"content": "<unk>", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": true}, "50264": {"content": "<mask>", "lstrip": true, "normalized": true, "rstrip": false, "single_word": false, "special": true}, "50265": {"content": "Ғ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50266": {"content": "ғ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50267": {"content": "Ҙ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50268": {"content": "ҙ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50269": {"content": "Ҡ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50270": {"content": "ҡ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50271": {"content": "Ң", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50272": {"content": "ң", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50273": {"content": "Ө", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50274": {"content": "ө", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50275": {"content": "Ҫ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50276": {"content": "ҫ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50277": {"content": "Ү", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50278": {"content": "ү", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50279": {"content": "Һ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50280": {"content": "һ", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50281": {"content": "Ә", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}, "50282": {"content": "ә", "lstrip": false, "normalized": true, "rstrip": false, "single_word": false, "special": false}}, "backend": "tokenizers", "bos_token": "<s>", "clean_up_tokenization_spaces": false, "cls_token": "<s>", "eos_token": "</s>", "errors": "replace", "is_local": false, "local_files_only": false, "mask_token": "<mask>", "model_max_length": 512, "pad_token": "<pad>", "processor_class": "TrOCRProcessor", "sep_token": "</s>", "tokenizer_class": "RobertaTokenizer", "trim_offsets": true, "unk_token": "<unk>"}