octantocr 0.1.0__tar.gz

octantocr-0.1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: octantocr
+Version: 0.1.0
+Summary: Offline-first, edge-native OCR framework with structured output, layout analysis, and table retention.
+Author-email: OctantOCR Team <devadarshanoop@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://devadarshmay-eng.github.io/octantocr/
+Project-URL: Documentation, https://devadarshmay-eng.github.io/octantocr/
+Project-URL: Repository, https://github.com/devadarshmay-eng/octantocr
+Project-URL: Issues, https://github.com/devadarshmay-eng/octantocr/issues
+Project-URL: Changelog, https://github.com/devadarshmay-eng/octantocr/releases
+Keywords: ocr,offline-ocr,edge-native,onnxruntime,document-analysis,table-extraction,dbnet,hocr,layout-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.22.0
+Requires-Dist: onnxruntime>=1.14.0
+Requires-Dist: opencv-python-headless>=4.5.0
+Requires-Dist: pyclipper>=1.3.0
+Requires-Dist: shapely>=2.0.0
+Requires-Dist: pypdfium2>=4.0.0
+Requires-Dist: Pillow>=9.0.0
+
+# OctantOCR (Python)
+
+Offline-first, edge-native OCR framework with structured output, layout analysis, and table retention.
+
+## Installation
+
+```bash
+pip install octantocr
+```
+
+## Quickstart
+
+```python
+from octantocr import OctantEngine
+
+engine = OctantEngine()
+result = engine.scan("document.png")
+
+print(f"Recognized text:\n{result.text}")
+print(f"Confidence: {result.confidence:.2f}")
+
+# Layout blocks & lines
+for block in result.blocks:
+    for line in block.lines:
+        print(f"[{line.confidence:.2f}] {line.text} (box: {line.box})")
+
+# Extracted tables (if present)
+for table in result.tables:
+    print(table.to_markdown())
+
+# Export formats
+hocr_str = result.to_hocr()
+json_str = result.to_json()
+```
+
+## CLI Usage
+
+```bash
+octantocr scan document.png
+octantocr scan invoice.pdf --table --output invoice.json
+```

octantocr-0.1.0/README.md

@@ -0,0 +1,41 @@
+# OctantOCR (Python)
+
+Offline-first, edge-native OCR framework with structured output, layout analysis, and table retention.
+
+## Installation
+
+```bash
+pip install octantocr
+```
+
+## Quickstart
+
+```python
+from octantocr import OctantEngine
+
+engine = OctantEngine()
+result = engine.scan("document.png")
+
+print(f"Recognized text:\n{result.text}")
+print(f"Confidence: {result.confidence:.2f}")
+
+# Layout blocks & lines
+for block in result.blocks:
+    for line in block.lines:
+        print(f"[{line.confidence:.2f}] {line.text} (box: {line.box})")
+
+# Extracted tables (if present)
+for table in result.tables:
+    print(table.to_markdown())
+
+# Export formats
+hocr_str = result.to_hocr()
+json_str = result.to_json()
+```
+
+## CLI Usage
+
+```bash
+octantocr scan document.png
+octantocr scan invoice.pdf --table --output invoice.json
+```

octantocr-0.1.0/octantocr/__init__.py

@@ -0,0 +1,32 @@
+"""
+OctantOCR
+Offline-first, edge-native OCR framework with structured output, layout analysis, and table retention.
+"""
+from .models import OcrResult, OCRResult, OCRConfig, TextBlock, TextLine, Word, Table, TableCell
+from .engine import OctantEngine, discover_models_dir
+
+__version__ = "0.1.0"
+
+_default_engine = None
+
+def scan(target, lang="eng", **kwargs) -> OcrResult:
+    """Convenience scan function using a global singleton engine."""
+    global _default_engine
+    if _default_engine is None:
+        _default_engine = OctantEngine()
+    return _default_engine.scan(target, lang=lang, **kwargs)
+
+__all__ = [
+    "OctantEngine",
+    "OcrResult",
+    "OCRResult",
+    "OCRConfig",
+    "TextBlock",
+    "TextLine",
+    "Word",
+    "Table",
+    "TableCell",
+    "scan",
+    "discover_models_dir",
+    "__version__",
+]

octantocr-0.1.0/octantocr/cli.py

@@ -0,0 +1,63 @@
+"""
+OctantOCR Command Line Interface (CLI)
+"""
+from __future__ import annotations
+import argparse
+import sys
+import os
+from pathlib import Path
+from .engine import OctantEngine
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="octantocr",
+        description="Offline-first, edge-native OCR framework with table extraction and structured output."
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # scan command
+    scan_parser = subparsers.add_parser("scan", help="Scan an image or PDF document.")
+    scan_parser.add_argument("input", type=str, help="Path to input image or PDF.")
+    scan_parser.add_argument("--lang", type=str, default="eng", help="OCR language code (default: 'eng').")
+    scan_parser.add_argument("--json", action="store_true", help="Output full structured JSON.")
+    scan_parser.add_argument("--hocr", action="store_true", help="Output W3C hOCR XHTML.")
+    scan_parser.add_argument("--table", action="store_true", help="Extract and print tabular structures as Markdown.")
+    scan_parser.add_argument("--no-deskew", action="store_true", help="Disable automatic skew correction.")
+    scan_parser.add_argument("--superres", action="store_true", help="Enable FSRCNN x2 neural super-resolution for blurry crops.")
+    scan_parser.add_argument("-o", "--output", type=str, default=None, help="Save result to file.")
+
+    args = parser.parse_args()
+
+    if args.command == "scan":
+        if not os.path.exists(args.input):
+            sys.stderr.write(f"Error: Input file not found: {args.input}\n")
+            sys.exit(1)
+
+        engine = OctantEngine()
+        result = engine.scan(
+            args.input,
+            lang=args.lang,
+            deskew=not args.no_deskew,
+            extract_tables=args.table or args.json,
+            superres=args.superres
+        )
+
+        output_content = ""
+        if args.json:
+            output_content = result.to_json()
+        elif args.hocr:
+            output_content = result.to_hocr()
+        elif args.table:
+            output_content = result.to_markdown()
+        else:
+            output_content = result.text
+
+        if args.output:
+            with open(args.output, "w", encoding="utf-8") as f:
+                f.write(output_content)
+            print(f"[OctantOCR] Results written to {args.output} (Latency: {result.latency_ms:.1f}ms, Conf: {result.confidence:.2f})")
+        else:
+            print(output_content)
+
+if __name__ == "__main__":
+    main()

octantocr-0.1.0/octantocr/detector.py

@@ -0,0 +1,125 @@
+"""
+OctantOCR Text Detection Engine (DBNet ONNX)
+"""
+import os
+import cv2
+import numpy as np
+import onnxruntime as ort
+import pyclipper
+from shapely.geometry import Polygon
+
+def box_score_fast(bitmap: np.ndarray, _box: np.ndarray) -> float:
+    """Calculate mean confidence score strictly inside the polygon contour."""
+    h, w = bitmap.shape[:2]
+    box = _box.copy()
+    xmin = np.clip(np.floor(box[:, 0].min()).astype(int), 0, w - 1)
+    xmax = np.clip(np.ceil(box[:, 0].max()).astype(int), 0, w - 1)
+    ymin = np.clip(np.floor(box[:, 1].min()).astype(int), 0, h - 1)
+    ymax = np.clip(np.ceil(box[:, 1].max()).astype(int), 0, h - 1)
+
+    if xmax <= xmin or ymax <= ymin:
+        return 0.0
+
+    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 float(cv2.mean(bitmap[ymin:ymax + 1, xmin:xmax + 1], mask)[0])
+
+class OctantDetector:
+    def __init__(self, model_path: str, num_threads: int = 4):
+        sess_options = ort.SessionOptions()
+        sess_options.intra_op_num_threads = num_threads
+        sess_options.inter_op_num_threads = num_threads
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        
+        self.session = ort.InferenceSession(
+            model_path,
+            sess_options=sess_options,
+            providers=['CPUExecutionProvider']
+        )
+        self.input_name = self.session.get_inputs()[0].name
+
+    def preprocess(self, img: np.ndarray, max_side_len: int = 1600):
+        h, w, _ = img.shape
+        scale = max_side_len / float(max(h, w)) if max(h, w) > max_side_len else 1.0
+        
+        target_h = int(round(h * scale / 32) * 32)
+        target_w = int(round(w * scale / 32) * 32)
+        target_h = max(32, target_h)
+        target_w = max(32, target_w)
+
+        resized = cv2.resize(img, (target_w, target_h))
+        ratio_h = target_h / float(h)
+        ratio_w = target_w / float(w)
+
+        norm = resized.astype(np.float32) / 255.0
+        norm -= np.array([0.485, 0.456, 0.406], dtype=np.float32)
+        norm /= np.array([0.229, 0.224, 0.225], dtype=np.float32)
+        norm = norm.transpose((2, 0, 1))
+        norm = np.expand_dims(norm, axis=0)
+
+        return norm, (ratio_h, ratio_w, target_h, target_w)
+
+    def detect(self, img: np.ndarray, thresh: float = 0.3, box_thresh: float = 0.5, unclip_ratio: float = 1.6, max_side_len: int = 1600):
+        h, w, _ = img.shape
+        tensor, (ratio_h, ratio_w, target_h, target_w) = self.preprocess(img, max_side_len=max_side_len)
+        preds = self.session.run(None, {self.input_name: tensor})[0]
+        pred_map = preds[0, 0, :, :]
+
+        segmentation = pred_map > thresh
+        mask = (segmentation * 255).astype(np.uint8)
+
+        contours, _ = cv2.findContours(mask, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+        boxes = []
+
+        for c in contours:
+            if cv2.contourArea(c) < 12:
+                continue
+            rect = cv2.minAreaRect(c)
+            (cx, cy), (bw, bh), angle = rect
+            if min(bw, bh) < 3:
+                continue
+
+            pts_kernel = cv2.boxPoints(rect)
+            score = box_score_fast(pred_map, pts_kernel)
+            if score < box_thresh:
+                continue
+
+            poly = c.reshape(-1, 2)
+            area = cv2.contourArea(c)
+            perimeter = cv2.arcLength(c, True)
+            if perimeter == 0:
+                continue
+            distance = area * unclip_ratio / perimeter
+
+            offset = pyclipper.PyclipperOffset()
+            offset.AddPath(poly, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+            expanded = offset.Execute(distance)
+            if not expanded:
+                continue
+
+            expanded_poly = np.array(expanded[0])
+            box_rect = cv2.minAreaRect(expanded_poly)
+            pts_small = cv2.boxPoints(box_rect)
+
+            # Scale to original coordinates
+            pts = pts_small.copy()
+            pts[:, 0] /= ratio_w
+            pts[:, 1] /= ratio_h
+
+            ordered_pts = self.order_points(pts)
+            boxes.append((ordered_pts, score))
+
+        return boxes
+
+    @staticmethod
+    def order_points(pts: np.ndarray) -> np.ndarray:
+        rect = np.zeros((4, 2), dtype=np.float32)
+        s = pts.sum(axis=1)
+        rect[0] = pts[np.argmin(s)] # Top-left
+        rect[2] = pts[np.argmax(s)] # Bottom-right
+        diff = np.diff(pts, axis=1)
+        rect[1] = pts[np.argmin(diff)] # Top-right
+        rect[3] = pts[np.argmax(diff)] # Bottom-left
+        return rect

octantocr-0.1.0/octantocr/engine.py

@@ -0,0 +1,356 @@
+"""
+OctantOCR Primary Engine & Pipeline Controller
+"""
+from __future__ import annotations
+import os
+import time
+from pathlib import Path
+from typing import List, Optional, Union, Dict, Any
+import numpy as np
+import cv2
+from PIL import Image
+
+from .models import OcrResult, TextBlock, TextLine, Word, Table
+from .detector import OctantDetector
+from .recognizer import OctantRecognizer
+from .layout import get_perspective_crop, sort_reading_order, decompose_line_into_words
+from .preprocess import estimate_skew_angle, deskew_image, enhance_low_quality
+from .superres import SuperResolutionEngine
+from .table import detect_tables
+
+def discover_models_dir(custom_path: Optional[str] = None) -> Path:
+    """Locate the directory containing OctantOCR ONNX models."""
+    if custom_path and os.path.isdir(custom_path):
+        return Path(custom_path)
+
+    env_dir = os.environ.get("OCTANT_MODELS_DIR")
+    if env_dir and os.path.isdir(env_dir):
+        return Path(env_dir)
+
+    search_paths = [
+        Path(__file__).resolve().parent / "models_data",
+        Path(__file__).resolve().parent / "models",
+        Path.home() / ".cache" / "octantocr" / "models",
+        Path.cwd() / "models",
+        Path(__file__).resolve().parent.parent.parent.parent / "models",
+        Path(__file__).resolve().parent.parent.parent.parent / "octant-ocr-edge" / "packages" / "recognizer" / "models",
+    ]
+
+    for p in search_paths:
+        if p.exists() and (p / "ch_PP-OCRv4_det_infer.onnx").exists():
+            return p
+
+    raise FileNotFoundError(
+        "OctantOCR ONNX models not found. Please install the package with bundled weights, specify models_dir, or set OCTANT_MODELS_DIR."
+    )
+
+class OctantEngine:
+    """
+    Offline-first, edge-native OCR engine for Python applications.
+    
+    Provides high-speed document text detection, recognition, layout sorting,
+    and table retention without cloud dependencies.
+    """
+
+    _detector_instance: Optional[OctantDetector] = None
+    _rec_en_instance: Optional[OctantRecognizer] = None
+    _rec_multi_instance: Optional[OctantRecognizer] = None
+    _sr_instance: Optional[SuperResolutionEngine] = None
+
+    def __init__(self, models_dir: Optional[Union[str, Path]] = None, num_threads: int = 4):
+        self.models_dir = discover_models_dir(str(models_dir) if models_dir else None)
+        self.num_threads = num_threads
+
+        det_path = str(self.models_dir / "ch_PP-OCRv4_det_infer.onnx")
+        rec_en_path = str(self.models_dir / "en_PP-OCRv3_rec_infer.onnx")
+        keys_en_path = str(self.models_dir / "en_dict.txt")
+        rec_multi_path = str(self.models_dir / "ch_PP-OCRv4_rec_infer.onnx")
+        keys_multi_path = str(self.models_dir / "ppocr_keys_v1.txt")
+
+        # Initialize detector singleton
+        if OctantEngine._detector_instance is None:
+            OctantEngine._detector_instance = OctantDetector(det_path, num_threads=num_threads)
+        self.detector = OctantEngine._detector_instance
+
+        # English recognizer
+        if OctantEngine._rec_en_instance is None and os.path.exists(rec_en_path) and os.path.exists(keys_en_path):
+            OctantEngine._rec_en_instance = OctantRecognizer(rec_en_path, keys_en_path, num_threads=num_threads)
+        self.recognizer_en = OctantEngine._rec_en_instance
+
+        # Multilingual recognizer
+        if OctantEngine._rec_multi_instance is None and os.path.exists(rec_multi_path) and os.path.exists(keys_multi_path):
+            OctantEngine._rec_multi_instance = OctantRecognizer(rec_multi_path, keys_multi_path, num_threads=num_threads)
+        self.recognizer_multi = OctantEngine._rec_multi_instance
+
+        # Super-resolution engine
+        if OctantEngine._sr_instance is None:
+            sr_model = self.models_dir / "FSRCNN_x2.onnx"
+            OctantEngine._sr_instance = SuperResolutionEngine(str(sr_model) if sr_model.exists() else None)
+        self.sr_engine = OctantEngine._sr_instance
+
+    def _get_recognizer(self, lang: str) -> OctantRecognizer:
+        lang_lower = lang.lower()
+        if lang_lower in ("en", "eng", "english") and self.recognizer_en is not None:
+            return self.recognizer_en
+        if self.recognizer_multi is not None:
+            return self.recognizer_multi
+        if self.recognizer_en is not None:
+            return self.recognizer_en
+        raise RuntimeError("No recognition models loaded.")
+
+    def scan(
+        self,
+        target: Union[str, Path, np.ndarray, Image.Image],
+        lang: str = "eng",
+        deskew: bool = True,
+        enhance: bool = False,
+        extract_tables: bool = True,
+        superres: bool = False,
+        max_side_len: int = 1600,
+    ) -> OcrResult:
+        """
+        Scan a document (image file, numpy array, PIL Image, or multi-page PDF).
+        
+        Args:
+            target: Filepath or image object
+            lang: Language code ('eng', 'fra', 'deu', 'multi', etc.)
+            deskew: Automatically correct document skew angle
+            enhance: Apply adaptive contrast enhancement
+            extract_tables: Identify and preserve tabular structures
+            superres: Upscale blurry or low-resolution text crops using FSRCNN
+            max_side_len: Maximum image dimension for DBNet detection scaling
+        """
+        t0 = time.perf_counter()
+
+        # Handle PDF input
+        if isinstance(target, (str, Path)):
+            path_str = str(target)
+            if path_str.lower().endswith(".pdf"):
+                return self._scan_pdf(
+                    path_str,
+                    lang=lang,
+                    deskew=deskew,
+                    enhance=enhance,
+                    extract_tables=extract_tables,
+                    superres=superres,
+                    max_side_len=max_side_len,
+                    start_time=t0
+                )
+
+        # Handle image input
+        img = self._load_image(target)
+        result = self._scan_single_image(
+            img,
+            lang=lang,
+            deskew=deskew,
+            enhance=enhance,
+            extract_tables=extract_tables,
+            superres=superres,
+            max_side_len=max_side_len,
+        )
+        result.latency_ms = round((time.perf_counter() - t0) * 1000, 2)
+        return result
+
+    def _load_image(self, target: Union[str, Path, np.ndarray, Image.Image]) -> np.ndarray:
+        if isinstance(target, (str, Path)):
+            p = str(target)
+            if not os.path.exists(p):
+                raise FileNotFoundError(f"Image not found: {p}")
+            img = cv2.imread(p)
+            if img is None:
+                raise ValueError(f"Failed to load image from {p}")
+            return img
+        elif isinstance(target, Image.Image):
+            rgb = np.array(target.convert("RGB"))
+            return cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+        elif isinstance(target, np.ndarray):
+            if len(target.shape) == 2:
+                return cv2.cvtColor(target, cv2.COLOR_GRAY2BGR)
+            return target
+        else:
+            raise TypeError(f"Unsupported target type: {type(target)}")
+
+    def _scan_single_image(
+        self,
+        img: np.ndarray,
+        lang: str,
+        deskew: bool,
+        enhance: bool,
+        extract_tables: bool,
+        superres: bool,
+        max_side_len: int,
+    ) -> OcrResult:
+        processed_img = img.copy()
+
+        # 1. Geometric deskew
+        if deskew:
+            angle = estimate_skew_angle(processed_img)
+            if abs(angle) >= 0.5:
+                processed_img = deskew_image(processed_img, angle)
+
+        # 2. Contrast enhancement
+        if enhance:
+            processed_img = enhance_low_quality(processed_img)
+
+        h, w = processed_img.shape[:2]
+
+        # 3. DBNet text detection
+        raw_boxes = self.detector.detect(processed_img, max_side_len=max_side_len)
+
+        if not raw_boxes:
+            return OcrResult(
+                text="",
+                confidence=1.0,
+                latency_ms=0.0,
+                hardware_tier="standard",
+                execution_provider="CPUExecutionProvider",
+                model_tier="standard",
+                blocks=[],
+                tables=[],
+                page_count=1
+            )
+
+        # 4. Perspective rectification crops
+        valid_crops = []
+        valid_box_indices = []
+        for idx, (box, score) in enumerate(raw_boxes):
+            crop = get_perspective_crop(processed_img, box)
+            if crop is not None:
+                if superres and self.sr_engine.is_blurry_or_low_res(crop):
+                    crop = self.sr_engine.upscale(crop)
+                valid_crops.append(crop)
+                valid_box_indices.append(idx)
+
+        # 5. Batched recognition
+        recognizer = self._get_recognizer(lang)
+        rec_results = recognizer.recognize_batch(valid_crops)
+
+        # Associate recognized text with boxes
+        detected_items = []
+        for box_idx, (text, conf) in zip(valid_box_indices, rec_results):
+            if not text:
+                continue
+            box, det_score = raw_boxes[box_idx]
+            detected_items.append((box, {"text": text, "confidence": conf, "det_score": det_score}))
+
+        # 6. Natural reading order sorting & column separation
+        sorted_items = sort_reading_order(detected_items, page_width=w)
+
+        # 7. Word bounding box decomposition & block building
+        lines: List[TextLine] = []
+        full_text_lines = []
+        confidences = []
+
+        for box, data in sorted_items:
+            line_text = data["text"]
+            line_conf = data["confidence"]
+            full_text_lines.append(line_text)
+            confidences.append(line_conf)
+
+            # Decompose words
+            raw_words = decompose_line_into_words(box, line_text, line_conf)
+            words = [
+                Word(
+                    text=rw["text"],
+                    box=[[rw["bbox"][0], rw["bbox"][1]], [rw["bbox"][2], rw["bbox"][1]],
+                         [rw["bbox"][2], rw["bbox"][3]], [rw["bbox"][0], rw["bbox"][3]]],
+                    confidence=rw["confidence"]
+                )
+                for rw in raw_words
+            ]
+
+            lines.append(
+                TextLine(
+                    text=line_text,
+                    box=box.tolist() if isinstance(box, np.ndarray) else box,
+                    confidence=line_conf,
+                    words=words
+                )
+            )
+
+        block = TextBlock(
+            id=1,
+            box=[[0, 0], [w, 0], [w, h], [0, h]],
+            lines=lines
+        )
+
+        # 8. Table extraction (if requested)
+        tables: List[Table] = []
+        if extract_tables:
+            table_input = [
+                {"box": np.array(l.box), "text": l.text} for l in lines
+            ]
+            tables = detect_tables(processed_img, table_input)
+
+        overall_conf = float(np.mean(confidences)) if confidences else 1.0
+        full_text = "\n".join(full_text_lines)
+
+        return OcrResult(
+            text=full_text,
+            confidence=round(overall_conf, 4),
+            latency_ms=0.0,
+            hardware_tier="standard",
+            execution_provider="CPUExecutionProvider",
+            model_tier="standard",
+            blocks=[block],
+            tables=tables,
+            page_count=1
+        )
+
+    def _scan_pdf(
+        self,
+        pdf_path: str,
+        lang: str,
+        deskew: bool,
+        enhance: bool,
+        extract_tables: bool,
+        superres: bool,
+        max_side_len: int,
+        start_time: float
+    ) -> OcrResult:
+        import pypdfium2 as pdfium
+
+        pdf = pdfium.PdfDocument(pdf_path)
+        num_pages = len(pdf)
+
+        all_text_parts = []
+        all_blocks = []
+        all_tables = []
+        all_confs = []
+
+        for p_idx in range(num_pages):
+            page = pdf[p_idx]
+            # Render page to PIL image at 300 DPI
+            pil_img = page.render(scale=300 / 72.0).to_pil()
+            cv_img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+
+            page_res = self._scan_single_image(
+                cv_img,
+                lang=lang,
+                deskew=deskew,
+                enhance=enhance,
+                extract_tables=extract_tables,
+                superres=superres,
+                max_side_len=max_side_len
+            )
+
+            if page_res.text:
+                all_text_parts.append(f"--- Page {p_idx + 1} ---\n" + page_res.text)
+                all_confs.append(page_res.confidence)
+            all_blocks.extend(page_res.blocks)
+            all_tables.extend(page_res.tables)
+
+        total_latency = round((time.perf_counter() - start_time) * 1000, 2)
+        mean_conf = float(np.mean(all_confs)) if all_confs else 1.0
+
+        return OcrResult(
+            text="\n\n".join(all_text_parts),
+            confidence=round(mean_conf, 4),
+            latency_ms=total_latency,
+            hardware_tier="standard",
+            execution_provider="CPUExecutionProvider",
+            model_tier="standard",
+            blocks=all_blocks,
+            tables=all_tables,
+            page_count=num_pages
+        )