added external OCR VLM Qwen3.8 for whole image OCR

README.md

@@ -76,30 +76,32 @@ python -m src.image_split -i scan.jpg --slice-auto
 |----------|----------|:---:|
 | `--input` / `-i` | Файл изображения **или** каталог | required |
 | `--output-dir` / `-o` | Каталог вывода | рядом с `--input` |
-| `--lang` / `-l` | Язык OCR | `en` |
-| `--ocr-engine` | `paddle` или `surya` | `paddle` |
-| `--llm` | Локальный LLM-корректор (Qwen2.5-7B) | OFF |
-| `--vlm` | Vision LM корректор (Qwen3.8 Max, API) | OFF |
+| `--ocr-engine` | **Обязательный:** `paddle`, `surya` или `external-qwen3` | — |
+| `--fix-by-llm` | Исправить ошибки локальным LLM (Qwen2.5-7B) | OFF |
+| `--fix-by-external-qwen3` | Исправить ошибки VLM API (Qwen3.8 Max) | OFF |
 | `--pause` | Пауза между изображениями (сек) | 5 |
 | `--no-result-one-document` | Не объединять `.md` в один документ | — |
 | `--no-post-crop` | Не обрезать по контенту (Stage 1) | — |
 
 Пример:
 ```bash
-# Одна страница
-python -m src.image_ocr -i page.jpg
+# Одна страница — PaddleOCR
+python -m src.image_ocr -i page.jpg --ocr-engine paddle
 
-# Пакетный режим — все изображения в каталоге
+# Одна страница — Surya 2
+python -m src.image_ocr -i page.jpg --ocr-engine surya
+
+# Пакетный режим
 python -m src.image_ocr -i ./pages/ --ocr-engine surya
 
+# Внешняя VLM как OCR-движок (Qwen3.8 Max)
+python -m src.image_ocr -i page.jpg --ocr-engine external-qwen3
+
 # Без объединения в один документ
-python -m src.image_ocr -i ./pages/ --no-result-one-document
+python -m src.image_ocr -i ./pages/ --ocr-engine surya --no-result-one-document
 
 # С LLM-корректором
-python -m src.image_ocr -i page.jpg -l ru --llm
-
-# С VLM-корректором (нужен OPENCODE_API_KEY в .env)
-python -m src.image_ocr -i page.jpg --vlm
+python -m src.image_ocr -i page.jpg --ocr-engine paddle --fix-by-llm
 ```
 
 ### Debug-лог

src/image_ocr.py

@@ -48,15 +48,16 @@ logger = logging.getLogger(__name__)
 app = typer.Typer(add_completion=False, no_args_is_help=True)
 
 MD_EXTENSION: str = ".md"
-DEFAULT_LANG: str = "en"
 IMG_EXTENSIONS: set[str] = {".jpg", ".jpeg", ".png", ".tiff", ".tif"}
 
 
 def _get_ocr_engine(name: 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"
 
 
@@ -73,7 +74,7 @@ def _merge_markdown_files(output_dir: Path, md_files: list[Path]) -> None:
 
 
 def _process_single(
-    ocr_fn, input_path: Path, lang: str,
+    ocr_fn, input_path: Path,
     output_dir_resolved: Path, use_llm: bool, use_vlm: bool,
 ) -> None:
     """Обрабатывает одно изображение: OCR → fixups → корректоры → JSON + Markdown."""
@@ -136,6 +137,13 @@ def image_to_latex(
             help="Путь к входному изображению или каталогу (JPEG, PNG, TIFF)",
         ),
     ],
+    ocr_engine: Annotated[
+        str,
+        typer.Option(
+            "--ocr-engine",
+            help="OCR-движок: paddle (PP-StructureV3), surya (Surya 2 VLM) или external-qwen3 (Qwen3.8 Max API)",
+        ),
+    ],
     output_dir: Annotated[
         Path | None,
         typer.Option(
@@ -147,33 +155,18 @@ def image_to_latex(
             help="Каталог для сохранения результатов (по умолчанию — рядом с входным файлом)",
         ),
     ] = None,
-    lang: Annotated[
-        str,
-        typer.Option(
-            "--lang",
-            "-l",
-            help="Язык OCR (en, ru, ch, ...)",
-        ),
-    ] = DEFAULT_LANG,
-    ocr_engine: Annotated[
-        str,
-        typer.Option(
-            "--ocr-engine",
-            help="OCR-движок: paddle (PP-StructureV3) или surya (Surya 2 VLM)",
-        ),
-    ] = "paddle",
     use_llm: Annotated[
         bool,
         typer.Option(
-            "--llm",
-            help="Использовать локальный LLM-корректор (Qwen2.5-7B GGUF) для исправления OCR-ошибок",
+            "--fix-by-llm",
+            help="Исправить OCR-ошибки локальным LLM (Qwen2.5-7B). Не работает с --ocr-engine external-qwen3",
         ),
     ] = False,
     use_vlm: Annotated[
         bool,
         typer.Option(
-            "--vlm",
-            help="Использовать vision LM (Qwen3.8 Max) для распознавания сомнительных регионов. Токен: OPENCODE_API_KEY",
+            "--fix-by-external-qwen3",
+            help="Исправить OCR-ошибки внешней VLM (Qwen3.8 Max, API). Не работает с --ocr-engine external-qwen3",
         ),
     ] = False,
     result_one_document: Annotated[
@@ -230,7 +223,7 @@ def image_to_latex(
 
         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, lang, out, use_llm, use_vlm)
+            _process_single(ocr_fn, img_path, out, use_llm, use_vlm)
             if i < len(image_paths) - 1 and pause > 0:
                 time.sleep(pause)
 
@@ -248,7 +241,7 @@ def image_to_latex(
     else:
         out = output_dir.resolve() if output_dir else input.resolve().parent
         out.mkdir(parents=True, exist_ok=True)
-        _process_single(ocr_fn, input, lang, out, use_llm, use_vlm)
+        _process_single(ocr_fn, input, out, use_llm, use_vlm)
 
 
 def main() -> None:

src/ocr/external_vlm_engine.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import logging
+import time
+
+import cv2
+
+from src.ocr.paddle_engine import OcrPageResult, ParsedBlock
+from src.postprocess.qwen_client import call_qwen_vlm, image_to_base64
+
+logger = logging.getLogger(__name__)
+
+_IMAGE_MAX_WIDTH: int = 1024
+
+
+def _pre_scale(image):
+    h, w = image.shape[:2]
+    if w > _IMAGE_MAX_WIDTH:
+        ratio = _IMAGE_MAX_WIDTH / w
+        return cv2.resize(image, (_IMAGE_MAX_WIDTH, int(h * ratio)))
+    return image
+
+
+def _parse_response_to_blocks(text: str, image) -> OcrPageResult:
+    paragraphs = [p.strip() for p in text.split("\n\n") if p.strip()]
+    blocks: list[ParsedBlock] = []
+    for para in paragraphs:
+        label = "text"
+        if para.startswith("#"):
+            label = "SectionHeader"
+        elif para.startswith(("$$", "\\[")):
+            label = "formula"
+        blocks.append(ParsedBlock(label=label, content=para, bbox=(0, 0, image.shape[1], image.shape[0])))
+    return OcrPageResult(
+        blocks=blocks,
+        raw_json={"blocks": [{"label": b.label, "content": b.content} for b in blocks]},
+        width=image.shape[1],
+        height=image.shape[0],
+    )
+
+
+def external_vlm_ocr_image(image_path: str) -> OcrPageResult:
+    image = cv2.imread(image_path)
+    if image is None:
+        raise FileNotFoundError(f"Не удалось загрузить: {image_path}")
+
+    scaled = _pre_scale(image)
+    logger.debug("VLM: отправка %dx%d px → %dx%d px", image.shape[1], image.shape[0],
+                 scaled.shape[1], scaled.shape[0])
+
+    t0 = time.time()
+    b64 = image_to_base64(scaled)
+    text = call_qwen_vlm(
+        b64,
+        (
+            "Extract ALL text from this document page. "
+            "For tables use | column | format |. "
+            "For formulas use $$...$$ or $...$. "
+            "Preserve structure: headers as ##, paragraphs as text. "
+            "Return ONLY the extracted content, no commentary."
+        ),
+        max_tokens=4000,
+    )
+    dt = time.time() - t0
+    logger.debug("VLM: ответ за %.1fs", dt)
+
+    if not text:
+        raise RuntimeError("VLM вернул пустой ответ")
+
+    return _parse_response_to_blocks(text, image)

src/postprocess/qwen_client.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import base64
+import logging
+import os
+import time as _time
+
+import cv2
+import requests
+
+from src.env import load_env
+
+logger = logging.getLogger(__name__)
+
+API_URL: str = "https://opencode.ai/zen/go/v1/messages"
+DEFAULT_MODEL: str = "qwen3.8-max"
+IMAGE_QUALITY: int = 90
+
+_ENV_LOADED: bool = False
+
+
+def _ensure_env() -> None:
+    global _ENV_LOADED
+    if _ENV_LOADED:
+        return
+    load_env()
+    _ENV_LOADED = True
+
+
+def _api_key() -> str:
+    _ensure_env()
+    return os.environ.get("OPENCODE_API_KEY", "")
+
+
+def image_to_base64(image) -> str:
+    _, buf = cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, IMAGE_QUALITY])
+    return base64.b64encode(buf).decode("utf-8")
+
+
+def call_qwen_vlm(
+    image_b64: str,
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    max_tokens: int = 300,
+) -> str | None:
+    """Отправляет изображение + prompt в Qwen3.8 Max API и возвращает текст ответа."""
+    if not _api_key():
+        logger.warning("OPENCODE_API_KEY не задан")
+        return None
+
+    messages = [{
+        "role": "user",
+        "content": [
+            {"type": "image", "source": {"type": "base64", "media_type": "image/jpeg", "data": image_b64}},
+            {"type": "text", "text": prompt},
+        ],
+    }]
+
+    for attempt in (1, 2):
+        try:
+            r = requests.post(
+                API_URL,
+                headers={"x-api-key": _api_key(), "anthropic-version": "2023-06-01", "Content-Type": "application/json"},
+                json={"model": model, "max_tokens": max_tokens, "messages": messages},
+                timeout=120,
+            )
+            r.raise_for_status()
+            data = r.json()
+            for item in data.get("content", []):
+                if item.get("type") == "text":
+                    return item.get("text", "").strip()
+            return None
+        except requests.HTTPError as e:
+            if e.response is not None and e.response.status_code == 500 and attempt == 1:
+                logger.info("Qwen API: HTTP 500, ожидание 5с и повтор...")
+                _time.sleep(5)
+                continue
+            logger.warning("Qwen API: ошибка — %s", e)
+            return None
+        except (requests.RequestException, KeyError, IndexError) as e:
+            logger.warning("Qwen API: ошибка — %s", e)
+            return None
+    return None

src/postprocess/vlm_corrector.py

@@ -1,50 +1,18 @@
 from __future__ import annotations
 
-import base64
 import logging
-import os
-import time as _time
-from typing import Any
 
 import cv2
-import requests
 
-from src.env import load_env
 from src.ocr.paddle_engine import ParsedBlock
+from src.postprocess.qwen_client import call_qwen_vlm, image_to_base64
 
 logger = logging.getLogger(__name__)
 
-API_KEY_ENV: str = "OPENCODE_API_KEY"
-API_URL_ENV: str = "OPENCODE_API_URL"
-DEFAULT_MODEL: str = "qwen3.8-max"
 
-
-def _get_api_key() -> str:
-    load_env()
-    return os.environ.get(API_KEY_ENV, "")
-
-
-def _get_api_url() -> str:
-    return os.environ.get(API_URL_ENV, "https://opencode.ai/zen/go/v1/messages")
-
-SYSTEM_PROMPT: str = (
-    "Extract ALL visible text from this document image region. "
-    "Preserve LaTeX math ($...$ and $$...$$). "
-    "Return ONLY the corrected text, no commentary."
-)
-
-
-def _image_to_base64(image: Any) -> str:
-    _, buffer = cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, 90])
-    return base64.b64encode(buffer).decode("utf-8")
-
-
-def vlm_correct_block(block: ParsedBlock, image_path: str, model: str = DEFAULT_MODEL) -> None:
+def vlm_correct_block(block: ParsedBlock, image_path: str) -> None:
     if block.label == "formula":
         return
-    if not _get_api_key():
-        logger.warning("VLM: %s не задан, пропускаем", API_KEY_ENV)
-        return
 
     image = cv2.imread(image_path)
     if image is None:
@@ -52,76 +20,22 @@ def vlm_correct_block(block: ParsedBlock, image_path: str, model: str = DEFAULT_
 
     h, w = image.shape[:2]
     x1, y1, x2, y2 = block.bbox
-    x1 = max(0, x1 - 5)
-    y1 = max(0, y1 - 5)
-    x2 = min(w, x2 + 5)
-    y2 = min(h, y2 + 5)
+    x1, y1 = max(0, x1 - 5), max(0, y1 - 5)
+    x2, y2 = min(w, x2 + 5), min(h, y2 + 5)
     if x1 >= x2 or y1 >= y2:
         return
 
     crop = image[y1:y2, x1:x2]
-    crop_h, crop_w = crop.shape[:2]
-    logger.info("VLM: отправка региона %dx%d px (bbox %d,%d,%d,%d)", crop_w, crop_h, x1, y1, x2, y2)
-    b64 = _image_to_base64(crop)
-
-    messages = [
-        {
-            "role": "user",
-            "content": [
-                {
-                    "type": "image",
-                    "source": {
-                        "type": "base64",
-                        "media_type": "image/jpeg",
-                        "data": b64,
-                    },
-                },
-                {
-                    "type": "text",
-                    "text": f"{SYSTEM_PROMPT}\n\nExtract all text from this image region. Return ONLY the extracted text.",
-                },
-            ],
-        },
-    ]
-
-    for attempt in (1, 2):
-        try:
-            response = requests.post(
-                _get_api_url(),
-                headers={
-                    "x-api-key": _get_api_key(),
-                    "anthropic-version": "2023-06-01",
-                    "Content-Type": "application/json",
-                },
-                json={
-                    "model": model,
-                    "max_tokens": 300,
-                    "messages": messages,
-                },
-                timeout=120,
-            )
-            response.raise_for_status()
-            data = response.json()
-            text = ""
-            for item in data.get("content", []):
-                if item.get("type") == "text":
-                    text = item.get("text", "").strip()
-                    break
-            if text and len(text) > 5:
-                block.content = text
-                logger.info("VLM: результат (%d символов): %s", len(text), text[:120])
-            else:
-                logger.info("VLM: пустой или короткий ответ (%d символов)", len(text) if text else 0)
-            return
-        except requests.HTTPError as e:
-            if e.response is not None and e.response.status_code == 500 and attempt == 1:
-                logger.info("VLM: HTTP 500, ожидание 5с и повтор...")
-                _time.sleep(5)
-                continue
-            logger.warning("VLM: ошибка — %s", e)
-            return
-        except (requests.RequestException, KeyError, IndexError) as e:
-            logger.warning("VLM: ошибка — %s", e)
-            return
-
-    return
+    logger.info("VLM: отправка региона %dx%d px (bbox %d,%d,%d,%d)", x2 - x1, y2 - y1, x1, y1, x2, y2)
+
+    b64 = image_to_base64(crop)
+    text = call_qwen_vlm(
+        b64,
+        "Extract ALL visible text from this image region. Preserve LaTeX math. Return ONLY the extracted text.",
+        max_tokens=300,
+    )
+    if text and len(text) > 5:
+        block.content = text
+        logger.info("VLM: результат (%d символов): %s", len(text), text[:120])
+    elif text is not None:
+        logger.info("VLM: пустой или короткий ответ (%d символов)", len(text) if text else 0)