updated PaddleOCR with PPv6, introduced helping param --main-lang, remove local llm qwen2.5:7b due to hallucinations

README.md

     │ --llm, --vlm, --force-ocr
     │ --pause 5 (по умолчанию)
     │ --result-one-document    (по умолчанию ON, объединить в один .md)
-    │
     ├─ PP-StructureV3 / Surya 2    (OCR)
     ├─ fixups                      (VaR, V^2)
-    ├─ LLM corrector               (Qwen2.5-7B, local)
     ├─ VLM corrector               (Qwen3.8 Max, API)
     │
     ▼
 | `--input` / `-i` | Файл изображения **или** каталог | required |
 | `--output-dir` / `-o` | Каталог вывода | рядом с `--input` |
 | `--ocr-engine` | **Обязательный:** `paddle`, `surya` или `external-qwen3` | — |
-| `--fix-by-llm` | Исправить ошибки локальным LLM (Qwen2.5-7B) | OFF |
 | `--fix-by-external-qwen3` | Исправить ошибки VLM API (Qwen3.8 Max) | OFF |
+| `--main-lang` | Основной язык: `ru` (eslav) или `en` (PP-OCRv6 rec) | `ru` |
 | `--pause` | Пауза между изображениями (сек) | 5 |
 | `--no-result-one-document` | Не объединять `.md` в один документ | — |
 | `--no-post-crop` | Не обрезать по контенту (Stage 1) | — |
 # Без объединения в один документ
 python -m src.image_ocr -i ./pages/ --ocr-engine surya --no-result-one-document
 
-# С LLM-корректором
-python -m src.image_ocr -i page.jpg --ocr-engine paddle --fix-by-llm
+# С VLM-корректором
+python -m src.image_ocr -i page.jpg --ocr-engine paddle --fix-by-external-qwen3
+
+# Английский документ (PP-OCRv6 rec)
+python -m src.image_ocr -i page.jpg --ocr-engine paddle --main-lang en
 ```
 
 <details>
 │                                                        результатов (по       │
 │                                                        умолчанию — рядом с   │
 │                                                        входным файлом)       │
-│    --fix-by-llm                                        Исправить OCR-ошибки  │
-│                                                        локальным LLM         │
-│                                                        (Qwen2.5-7B). Не      │
-│                                                        работает с            │
-│                                                        --ocr-engine          │
-│                                                        external-qwen3        │
 │    --fix-by-external-q…                                Исправить OCR-ошибки  │
 │                                                        внешней VLM (Qwen3.8  │
 │                                                        Max, API). Не         │
 | Движок | Русский текст | Формулы | Скорость (CPU) |
 |--------|:---:|:---:|:---:|
 | PaddleOCR (PP-StructV3) | ~85% | ✅ отлично | ~140s |
-| + LLM (Qwen2.5-7B) | ~95% | ✅ | +5 min |
 | + VLM (Qwen3.8 Max) | ~98% | ✅✅ | +10s/блок |
 | Surya 2 | ~95% | ✅ отлично | ~300s |
 
   postprocess/
     fixups.py            — OCR-ошибки (VaR)
     corrector.py         — Corrector protocol
-    llm_corrector.py     — Qwen2.5-7B (local)
     vlm_corrector.py     — Qwen3.8 Max (API)
   markdown/generator.py  — Markdown + валидация
   latex/

installation.md

 
 - **OS:** Linux x86_64
 - **CPU:** 8+ ядер (i7-1165G7 или лучше)
-- **RAM:** 16+ GB (32 GB с LLM-корректором)
+- **RAM:** 16+ GB
 - **Диск:** 15+ GB свободного места
 
 ---
 |--------|--------|:---:|------|
 | PaddleOCR | PP-StructureV3 (ансамбль) | ~2.5 GB | `~/.paddlex/official_models/` |
 | Surya 2 | surya-2.gguf + mmproj | ~1.5 GB | HF Hub (кеш) |
-| LLM | Qwen2.5-7B-Q4_K_M.gguf | ~4.4 GB | `~/.cache/llama_models/` |
 
 ---
 
 
 # Stage 2 — Surya
 python -m src.image_ocr -i test.jpg --ocr-engine surya
-
-# Stage 2 — с LLM-корректором
-python -m src.image_ocr -i test.jpg --ocr-engine paddle --fix-by-llm
 ```
 
 ---

requirements.txt

 # Core
 typer>=0.15
-opencv-python-headless>=4.11
+opencv-python-headless>=4.11,<5.0
 numpy>=1.24,<2.4
 PyYAML>=6.0
 Pillow>=11.0
 beautifulsoup4>=4.12
 
 # OCR engines
-paddlex>=3.2,<3.4
+paddlex[ocr]>=3.7,<3.8
 paddlepaddle==3.2.2
+paddleocr>=3.7
 surya-ocr>=0.12
 
-# LLM corrector (--fix-by-llm)
-llama-cpp-python>=0.3
-
 # Dev
 pytest>=8.0
 ruff>=0.9

src/image_ocr.py

 IMG_EXTENSIONS: set[str] = {".jpg", ".jpeg", ".png", ".tiff", ".tif"}
 
 
-def _get_ocr_engine(name: str):
+def _get_ocr_engine(name: str, main_lang: str):
     if name == "surya":
         from src.ocr.surya_engine import surya_ocr_image
         return surya_ocr_image, "Surya 2 VLM"
     if name == "external-qwen3":
         from src.ocr.external_vlm_engine import external_vlm_ocr_image
         return external_vlm_ocr_image, "Qwen3.8 Max (external VLM)"
-    return ocr_image, "PP-StructureV3"
+    return functools.partial(ocr_image, main_lang=main_lang), "PP-StructureV3"
 
 
 def _merge_markdown_files(output_dir: Path, md_files: list[Path]) -> None:
 
 def _process_single(
     ocr_fn, input_path: Path,
-    output_dir_resolved: Path, use_llm: bool, use_vlm: bool,
+    output_dir_resolved: Path, use_vlm: bool,
 ) -> None:
     """Обрабатывает одно изображение: OCR → fixups → корректоры → JSON + Markdown."""
     # Этап OCR — самое долгое и хрупкое место
     fix_ocr_errors(page.blocks)
     logger.debug("Fixups: завершено")
 
-    # Опциональная коррекция через VLM / локальный LLM
-    if use_vlm or use_llm:
+    # Опциональная коррекция через VLM
+    if use_vlm:
         from src.postprocess.corrector import apply_corrector
         logger.debug("Корректоры: инициализация")
-
-    if use_vlm:
         from src.postprocess.vlm_corrector import vlm_correct_block
         corrector = functools.partial(vlm_correct_block, image_path=str(input_path.resolve()))
         apply_corrector(page.blocks, corrector, "VLM")
         logger.debug("VLM: завершено")
 
-    if use_llm:
-        from src.postprocess.llm_corrector import llm_correct_block
-        apply_corrector(page.blocks, llm_correct_block, "LLM")
-        logger.debug("LLM: завершено")
-
     # Сохранение JSON (всегда) + Markdown (всегда)
     json_path = output_dir_resolved / (input_path.stem + ".json")
     if not json_path.exists():
             help="Каталог для сохранения результатов (по умолчанию — рядом с входным файлом)",
         ),
     ] = None,
-    use_llm: Annotated[
-        bool,
-        typer.Option(
-            "--fix-by-llm",
-            help="Исправить OCR-ошибки локальным LLM (Qwen2.5-7B). Не работает с --ocr-engine external-qwen3",
-        ),
-    ] = False,
     use_vlm: Annotated[
         bool,
         typer.Option(
             help="Исправить OCR-ошибки внешней VLM (Qwen3.8 Max, API). Не работает с --ocr-engine external-qwen3",
         ),
     ] = False,
+    main_lang: Annotated[
+        str,
+        typer.Option(
+            "--main-lang",
+            help="Основной язык: ru (eslav_PP-OCRv5_mobile_rec) или en (PP-OCRv6_medium_rec)",
+        ),
+    ] = "ru",
     result_one_document: Annotated[
         bool,
         typer.Option(
     ] = 5,
 ) -> None:
     """OCR → PostProcess → Markdown. Принимает файл или каталог изображений."""
-    ocr_fn, engine_name = _get_ocr_engine(ocr_engine)
+    ocr_fn, engine_name = _get_ocr_engine(ocr_engine, main_lang)
 
     if input.is_dir():
         image_paths = sorted(
 
         for i, img_path in enumerate(image_paths):
             logger.info("[%d/%d] %s...", i + 1 + skipped, len(image_paths) + skipped, img_path.name)
-            _process_single(ocr_fn, img_path, out, use_llm, use_vlm)
+            _process_single(ocr_fn, img_path, out, use_vlm)
             if i < len(image_paths) - 1 and pause > 0:
                 time.sleep(pause)
 
     else:
         out = output_dir.resolve() if output_dir else input.resolve().parent
         out.mkdir(parents=True, exist_ok=True)
-        _process_single(ocr_fn, input, out, use_llm, use_vlm)
+        _process_single(ocr_fn, input, out, use_vlm)
 
 
 def main() -> None:

src/latex/json_to_latex.py

 
         if label == "formula":
             lines.append(f"\\[\n{content}\n\\]\n")
+        elif label == "table" and "<table" in content:
+            soup = BeautifulSoup(content, "html.parser")
+            lines.append(_table_to_latex(soup))
+            lines.append("")
         elif label in ("paragraph_title", "title", "section_header"):
             lines.append(f"\\section*{{{_escape_latex(content)}}}")
-        elif label == "text":
-            lines.append(f"\n{_escape_latex(content)}\n")
         else:
             lines.append(f"\n{_escape_latex(content)}\n")
     return "\n".join(lines)
         label = block.get("block_label", "text")
         if label == "formula":
             return f'\n<div class="equation">$$\n{content}\n$$</div>'
+        if label == "table" and "<table" in content:
+            soup = BeautifulSoup(content, "html.parser")
+            return str(soup.find("table"))
         if label in ("paragraph_title", "title", "section_header"):
             return f"<h2>{content}</h2>"
         return f"<p>{content}</p>"

src/ocr/paddle_engine.py

 
 from src.models import OcrPageResult, ParsedBlock
 
+_REC_MODELS: dict[str, str] = {
+    "ru": "eslav_PP-OCRv5_mobile_rec",
+    "en": "PP-OCRv6_medium_rec",
+}
 
-def _load_config() -> dict[str, Any]:
+
+def _load_config(main_lang: str) -> dict[str, Any]:
     ref = importlib.resources.files("paddlex") / "configs" / "pipelines" / "PP-StructureV3.yaml"
     with importlib.resources.as_file(ref) as path, open(path) as f:
         config: dict[str, Any] = yaml.safe_load(f)
 
-    config["SubPipelines"]["GeneralOCR"]["SubModules"]["TextRecognition"]["model_name"] = (
-        "eslav_PP-OCRv5_mobile_rec"
+    rec_model = _REC_MODELS.get(main_lang, _REC_MODELS["ru"])
+    config["SubPipelines"]["GeneralOCR"]["SubModules"]["TextDetection"]["model_name"] = (
+        "PP-OCRv6_medium_det"
     )
+    config["SubPipelines"]["GeneralOCR"]["SubModules"]["TextRecognition"]["model_name"] = rec_model
     table_ocr = config["SubPipelines"]["TableRecognition"]["SubPipelines"]["GeneralOCR"]
-    table_ocr["SubModules"]["TextRecognition"]["model_name"] = "eslav_PP-OCRv5_mobile_rec"
+    table_ocr["SubModules"]["TextRecognition"]["model_name"] = rec_model
     return config
 
 
 class OcrEngine:
-    def __init__(self) -> None:
-        self._config: dict[str, Any] = _load_config()
+    def __init__(self, main_lang: str) -> None:
+        self._config: dict[str, Any] = _load_config(main_lang)
         self._pipeline: Any = None
 
     def process(self, image_path: str) -> OcrPageResult:
         return blocks, raw_json
 
 
-@functools.lru_cache(maxsize=1)
-def _get_engine() -> OcrEngine:
-    return OcrEngine()
+@functools.lru_cache(maxsize=2)
+def _get_engine(main_lang: str) -> OcrEngine:
+    return OcrEngine(main_lang)
 
 
-def ocr_image(image_path: str) -> OcrPageResult:
-    return _get_engine().process(image_path)
+def ocr_image(image_path: str, main_lang: str = "ru") -> OcrPageResult:
+    return _get_engine(main_lang).process(image_path)

src/postprocess/llm_corrector.py

-from __future__ import annotations
-
-import functools
-import os
-
-from llama_cpp import Llama
-
-from src.models import ParsedBlock
-
-DEFAULT_LLM_PATH = os.path.expanduser("~/.cache/llama_models/Qwen2.5-7B-Instruct-Q4_K_M.gguf")
-
-
-class LlmCorrector:
-    def __init__(self, model_path: str = DEFAULT_LLM_PATH) -> None:
-        self._llm = Llama(
-            model_path=model_path,
-            n_ctx=1024,
-            n_threads=8,
-            verbose=False,
-        )
-
-    def __call__(self, block: ParsedBlock) -> None:
-        if len(block.content) < 30:
-            return
-
-        text = block.content[:400]
-        messages = [
-            {"role": "system", "content": "Ты корректор OCR-ошибок. Возвращай ТОЛЬКО исправленный текст."},
-            {"role": "user", "content": f"Исправь:\n\n{text}"},
-        ]
-        response = self._llm.create_chat_completion(messages=messages, max_tokens=150, temperature=0.0)
-        corrected = response["choices"][0]["message"]["content"].strip()
-
-        if corrected and len(corrected) > 10 and corrected != text:
-            block.content = corrected
-
-
-@functools.lru_cache(maxsize=1)
-def _get_llm_corrector() -> LlmCorrector:
-    return LlmCorrector()
-
-
-def llm_correct_block(block: ParsedBlock) -> None:
-    _get_llm_corrector()(block)

src/split/slicer.py

 def generate_output_paths(input_path: Path, page_count: int, output_dir: Path) -> list[Path]:
     stem = input_path.stem
     suffix = input_path.suffix.lower()
+    if page_count == 1:
+        return [output_dir / f"{stem}{suffix}"]
     max_digits = max(PAGE_NUMBER_WIDTH, len(str(page_count)))
     return [
         output_dir / f"{stem}_{i:0{max_digits}d}{suffix}"

stage2_results.md

 ### 4. PP-OCRv5_server_rec / PP-OCRv6
 **Результат:** ❌ не поддерживают русский.
 - Server model: только CN/JP/EN
-- PP-OCRv6: 52 латинских языка
+- PP-OCRv6: 46 латинских языков + CN/JP/EN (без кириллицы)
 - **Вывод:** русский — только mobile-версии
 
-### 5. Локальный LLM-корректор (Qwen2.5-7B GGUF)
-**Результат:** +25% читаемости текста.
+### 5. PP-OCRv6 детектор (RepLKFPN, 62MB) ✅ оставлен
+**Результат:** +4.6% detection accuracy vs v5, на 7% быстрее (97.8s vs 104.7s).
+- Модель скачана через paddlex[ocr] 3.7.2 без апгрейда paddlepaddle
+- Смешан с eslav_rec — детектор язык-независим
+- Совместим с PP-StructureV3 через YAML-конфиг
+- **Вывод:** бесплатный прирост детекции без риска
+
+### 6. `--main-lang` выбор распознавалки ✅ оставлен
+**Результат:** переключение rec-модели по основному языку страницы.
+- `--main-lang=ru` → `eslav_PP-OCRv5_mobile_rec` (русский, 85-90%)
+- `--main-lang=en` → `PP-OCRv6_medium_rec` (английский + греческие в формулах, 75-80%)
+- Таблицы и формулы — общие (SLANet + PP-FormulaNet)
+- Модели кешируются раздельно (lru_cache по языку)
+- **Вывод:** +15-20% на английских страницах заменой одной модели
+
+### 7. Локальный LLM-корректор (Qwen2.5-7B Q4_K_M) ❌ удалён
+**Результат:** 50/50 — исправляет и тут же галлюцинирует.
 ```
-До:   t - номер месяцаB дефолте, на который прогнозируются возвраты
-После: т — номер месяца в диапазоне между текущим сроком в дефолте и горизонтом взыскания
+До:   сypporat WoE для гpynnы i
+После: коррелят weight of evidence (галлюцинация вместо «суррогат»)
 ```
-- ~4 tok/sec на CPU, ~20s/блок
-- **Вывод:** эффективен для пост-обработки
+- Причины отказа: (1) слепой — не видит изображение, догадывается; (2) маленький — 7B квантизованный не понимает контекст; (3) избыточный — `fixups.py` уже правит VaR/V^2 без модели
+- Занятые ресурсы: 4.4 GB диск + 5 GB RAM + 60s/блок
+- **Вывод:** удалён, освобождено 4.4 GB
 
-### 6. VLM-корректор (Qwen3.8 Max через OpenCode API)
+### 8. VLM-корректор (Qwen3.8 Max через OpenCode API)
 **Результат:** полное восстановление текста + авто inline-формулы.
 ```
 До:   ΣДсе, - дисконтированная сумма возвратов
 После: $\sum_t DCF_{i,t}$ — дисконтированная сумма возвратов
 ```
 - ~10s/блок, Anthropic API `zen/go/v1/messages`
+- Таблицы: HTML → tab-separated flat text ✅
+- На порядок качественнее LLM — видит изображение, читает напрямую
 - **Вывод:** лучшее качество, требует API-доступа
 
-### 7. Docling (IBM Research)
+### 9. Docling (IBM Research)
 **Результат:** ❌ не поддерживает PaddleOCR как OCR-backend.
 - Поддерживает: EasyOCR, Tesseract, RapidOCR, Nemotron
 - **Вывод:** несовместим с нашим пайплайном
 
-### 8. PaddleOCR-VL (ERNIE-4.5-0.3B)
+### 10. PaddleOCR-VL (ERNIE-4.5-0.3B)
 **Результат:** модель загружена (1.79 GB), ~15 мин/стр на CPU.
 - Одна VLM вместо ансамбля
 - Теоретически решает проблему русского (LM понимает контекст)
 - **Вывод:** правильный подход при GPU, нереализуем на CPU
 
-### 9. Surya 2 (Datalab, 650M VLM) ⭐
+### 11. Surya 2 (Datalab, 650M VLM) ⭐
 **Результат:** лучший русский OCR из коробки — но медленно на CPU.
 - 95%+ точность русского текста без коррекции
 - Авто inline-формулы: `<math>MRec_{it}</math>` → `$MRec_{it}$`
 - **Слабость:** таблицы требуют много токенов → таймауты на CPU
 - **Вывод:** лучший выбор по качеству, медленнее на CPU
 
-### 10. VLM full-page (Qwen3.8 Max) для таблиц
+### 12. VLM full-page (Qwen3.8 Max) для таблиц
 **Результат:** 118s на страницу с таблицей, качество отличное.
 - Таблица → pipe-Markdown: `| col1 | col2 |`
 - Формулы → `$...$`
 
 ---
 
+## Эксперименты по препроцессингу изображений
+
+### 13. Denoising (Non-Local Means) ✅ оставлен
+**Результат:** 17 блоков vs 12 без (+42%), исправил «6»→«G», «Пр»→«р».
+- Без denoise: «рогнозное», «L6D ID», 12 блоков, 104.7s
+- С denoise: «Прогнозное», «LGD ID», 17 блоков, 139.5s (+33% времени)
+- **Вывод:** +42% блоков за +35s — оставлен как опция `--denoise`
+
+### 14. Адаптивная бинаризация (Otsu/Adaptive) ❌ удалена
+**Результат:** жёсткие границы порвали буквы, ложные контуры.
+- «рассчитывается» → «рассчита**встся**»
+- Формулы: `$b_i$` → `$b_{-}i-\\sec a$` (мусор)
+- Мусорные блоки: `$\alpha\times\alpha\times\alpha...$` — артефакты бинаризации
+- **Причина:** нейросетевой OCR обучен на естественных изображениях, не на бинарных
+- **Вывод:** удалена из CLI и пайплайна
+
+### 15. Upscale ×2 для мелкого текста ❌ удалён
+**Результат:** бесполезен — PaddleOCR режет `max_side_limit=4000`.
+- Изображение 6090×3880 (×2) → Paddle сжимает обратно до ≤4000
+- Время впустую: 174s вместо 104s
+- **Причина:** параметр `max_side_limit` жёстко ограничивает входное разрешение
+- **Вывод:** удалён из CLI, требует правки `max_side_limit` в YAML для пользы
+
+### 16. Document Unwarping (Canny → 4-угольник → perspective) ✅ оставлен
+**Результат:** работает для фото под углом, NOP для плоского сканера.
+- Планшетный сканер: контур страницы не найден → возврат исходника
+- Фото: детектит 4-угольник → warp в прямоугольник
+- Баг первой версии: детектил внутренние таблицы (bbox ~150px высотой)
+- **Исправление:** порог `min_area ≥ 30%` от изображения
+- **Вывод:** опция `--unwarp` для фото, для сканера — YAGNI
+
+---
+
+## Оптимизации кода (SOLID / DRY / KISS / YAGNI)
+
+| Действие | Результат |
+|---|---|
+| `ParsedBlock`/`OcrPageResult` → `src/models.py` | 7 модулей отвязаны от paddle_engine |
+| `Corrector(Protocol)` → `Callable` | Удалён неиспользуемый Protocol |
+| `validate_output_dir()` удалён | Мёртвый код из `slicer.py` |
+| `_ensure_env()` → `load_env()` напрямую | Убраны дублирующие guard'ы |
+| `calc_scale_dims()` в `image_utils.py` | Общий pre-scale для Surya + external VLM |
+| `functools.lru_cache` для engine-синглтонов | Убран boilerplate `_engine: X \| None` |
+| `surya2html.py`, `tex2html.py` удалены | Дубликаты логики из `json_to_latex.py` |
+| `binarize_image()`, `upscale_image()` удалены | Мёртвые функции из `slicer.py` |
+| `requirements.txt`: 118 → 14 пакетов | Только прямые зависимости |
+| `llm_corrector.py` + Qwen2.5-7B (4.4GB) удалены | Галлюцинации, YAGNI |
+
+---
+
 ## Итоговая архитектура
 
 ```
 Входное изображение (JPEG/PNG/TIFF)
     │
     ▼
-src/image_prepare.py          ← Stage 1: разрезание
+src/image_prepare.py          ← Stage 1: подготовка
     │ --slice / --slice-auto
-    │ --border, --post-crop
+    │ --pre-rotate, --border
+    │ --unwarp, --denoise
+    │ --post-crop
     │
     ▼
 src/image_ocr.py            ← Stage 2: OCR + Markdown
-    │ --ocr-engine paddle|surya
-    │ --llm, --vlm
-    │ --force-ocr, --pause
-    │ --result-one-document (ON по умолчанию)
+    │ --ocr-engine paddle|surya|external-qwen3
+    │ --main-lang ru|en
+    │ --fix-by-external-qwen3
+    │ --pause, --no-result-one-document
     │
     ├─ PaddleEngine / SuryaEngine   (OCR)
     ├─ fix_ocr_errors               (VaR, V^2)
-    ├─ LlmCorrector                 (Qwen2.5-7B, local)
     ├─ VlmCorrector                 (Qwen3.8 Max, API)
     │
     ▼
 .md + .json (per page) + merged.md
+     │
+     ▼
+src/latex/json_to_latex.py  ← Stage 3: JSON → LaTeX + HTML
+    │ Paddle / Surya / Qwen
+    │ Автоопределение формата
+    │
+    ▼
+.tex + .html (с MathJax для таблиц и формул)
 ```
 
 ### По умолчанию включено
 
 | Функция | Статус |
 |---------|:------:|
-| `--resume` (пропуск JSON) | ON |
+| `--main-lang ru` | ON |
+| Resume (пропуск JSON) | ON |
 | `--result-one-document` | ON |
 | `--pause 5` | ON |
 | `--post-crop` (Stage 1) | ON |
 
 ```
 src/
-  image_prepare.py         — CLI Stage 1
-  image_ocr.py           — CLI Stage 2
-  cli_utils.py           — run_main()
-  env.py                 — загрузка .env
-  split/slicer.py        — разрезание, post-crop, border
+  models.py               — ParsedBlock, OcrPageResult
+  image_utils.py          — calc_scale_dims
+  image_prepare.py        — CLI Stage 1
+  image_ocr.py            — CLI Stage 2
+  cli_utils.py            — run_main()
+  env.py                  — загрузка .env
+  split/slicer.py         — разрезание, post-crop, border, unwarp, denoise
   ocr/
-    paddle_engine.py     — PP-StructureV3 + кастом YAML (eslav)
-    surya_engine.py      — Surya 2 + CPU-оптимизации + health_check
+    paddle_engine.py      — PP-StructureV3 + v6-det + ru/en rec
+    surya_engine.py       — Surya 2 + CPU-оптимизации + health_check
+    external_vlm_engine.py — Qwen3.8 Max full-page OCR
   postprocess/
-    fixups.py            — VaR, V^2
-    corrector.py         — Corrector Protocol
-    llm_corrector.py     — Qwen2.5-7B локально
-    vlm_corrector.py     — Qwen3.8 Max API (Anthropic)
-  markdown/generator.py  — Markdown + валидация LaTeX
+    fixups.py             — VaR, V^2
+    corrector.py          — apply_corrector
+    vlm_corrector.py      — Qwen3.8 Max per-block API
+    qwen_client.py        — общий Qwen API-клиент
+  markdown/generator.py   — Markdown + валидация LaTeX
   latex/
-    json_to_latex.py     — Единый JSON→LaTeX (Paddle + Surya)
-    json_to_latex.py     — Единый JSON→LaTeX+HTML (Paddle + Surya + Qwen)
+    json_to_latex.py      — JSON→LaTeX+HTML (Paddle + Surya + Qwen)
 ```
 
 ---
 | Threads | default | `-t 8` | стабильно |
 | **Итого** | **430s** | **300s** | **-30%** |
 
-### Health-check + retry
-```
-llama-server не отвечает → logger.warning → перезапуск SuryaEngine
-→ повторный health_check → OK / RuntimeError с инструкцией
-```
-
 ---
 
 ## Сравнение движков
 | Параметр | PaddleOCR | Surya 2 | VLM Qwen3.8 |
 |----------|:---:|:---:|:---:|
 | Архитектура | Ансамбль 5 моделей | Один VLM (650M) | Cloud VLM |
-| Русский текст | ~85% | 95%+ | 98%+ |
+| Русский текст | ~85% (eslav rec) | 95%+ | 98%+ |
+| Английский текст | ~80% (v6 rec) | 95%+ | 98%+ |
 | Формулы | PP-FormulaNet | VLM (отлично) | VLM (отлично) |
 | Таблицы | PP-TableMagic + bbox | ❌ CPU timeout | ✅ Pipe-Markdown |
 | Inline-формулы | Нет | `<math>` тэги | `$...$` |
-| Скорость CPU | ~140s | ~300s | ~120s (API) |
+| Скорость CPU | ~100-160s | ~300s | ~120s (API) |
 | Офлайн | ✅ | ✅ | ❌ |
 | Размер моделей | ~2.5 GB | ~1.5 GB | 0 (cloud) |
 
 
 | Этап | PaddleOCR | Surya 2 | VLM |
 |------|:---:|:---:|:---:|
-| OCR (одна страница) | 140s | 300s | 120s |
-| LLM-корректор | +5 min | не нужен | не нужен |
+| OCR (одна страница) | 100-160s | 300s | 120s |
+| Denoise (Stage 1) | +35s | — | — |
 | VLM-корректор | +10s/блок | не нужен | — |
 | JSON + MD сохранение | <1s | <1s | <1s |
 | Merge в один документ | <1s | <1s | <1s |
-| **Итого на страницу** | ~5 min | ~5 min | ~2 min |
-| **12 страниц (batch)** | ~28 min* | ~60 min | ~24 min |
+| **Итого на страницу** | ~3-4 min | ~5 min | ~2 min |
+| **12 страниц (batch)** | ~15-20 min* | ~60 min | ~24 min |
 
-\* PaddleOCR с `--pause 5`
+\* PaddleOCR с `--pause 5` и `--denoise`
 
 ---
 
 
 ## Выводы
 
-1. **PP-StructureV3** — надёжен для структуры и формул, русский текст требует LLM/VLM коррекции
-2. **Surya 2** — лучший русский OCR из коробки, CPU-оптимизации дали -30% времени
-3. **VLM Qwen3.8 Max** — решает таблицы там, где Surya падает, при приемлемой скорости
-4. **Гибридный подход**: Surya для текста + VLM для таблиц = лучший баланс
-5. **LLM/VLM коррекция** эффективна для PaddleOCR, не нужна для Surya 2
-6. **CPU-ограничения** — основной фактор, GPU сделал бы Surya/PaddleOCR-VL идеальным выбором
+1. **PP-StructureV3 + v6-det + eslav_rec** — лучший офлайн OCR для русского на CPU: 85-90% текст, 90% формулы, 80% таблицы
+2. **PP-OCRv6 rec** через `--main-lang=en` — +20% на английских страницах
+3. **Denoise** — +42% блоков на сканах с шумом, оставлен как опция
+4. **Бинаризация, upscale** — вредны для нейросетевого OCR, удалены
+5. **Локальный LLM (Qwen2.5-7B)** — галлюцинирует, удалён
+6. **VLM-корректор (Qwen3.8 Max)** — отличный, но API
+7. **Surya 2** — лучший русский OCR из коробки, CPU-оптимизации дали -30% времени
+8. **Гибридный подход**: Surya для текста + VLM для таблиц = лучший баланс
+9. **CPU-ограничения** — основной фактор, GPU сделал бы Surya/PaddleOCR-VL идеальным выбором

tests/test_post_crop.py

         with tempfile.TemporaryDirectory() as tmp:
             result = process_image(Path(path), 1, 2, Path(tmp), border_px=5)
             assert len(result) == 1
-            assert result[0].name == Path(path).stem + "_01.png"
+            assert result[0].name == Path(path).stem + ".png"
 
     def test_all_empty_returns_empty_list(self) -> None:
         image = create_test_image(200, 200)

tests/test_slicer.py

 
     def test_png_extension(self) -> None:
         paths = generate_output_paths(Path("img.PNG"), 1, Path("out"))
-        assert paths == [Path("out/img_01.png")]
+        assert paths == [Path("out/img.png")]
 
     def test_zero_padding(self) -> None:
         paths = generate_output_paths(Path("scan.jpg"), 12, Path("out"))