medhaocr 0.1.0__tar.gz

medhaocr-0.1.0/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.

medhaocr-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: medhaocr
+Version: 0.1.0
+Summary: CPU-only OCR for scanned and digital documents (PDF, JPG, JPEG, PNG) that keeps headings, tables and layout
+Author: Maruti L Sankannanavar
+License-Expression: Apache-2.0
+Keywords: ocr,pdf,scanned documents,layout,tables,cpu
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rapidocr>=3.9
+Requires-Dist: rapid-layout>=1.2
+Requires-Dist: rapid-table>=3.0
+Requires-Dist: onnxruntime>=1.20
+Requires-Dist: openvino>=2025.0
+Requires-Dist: opencv-python-headless>=4.10
+Requires-Dist: numpy>=1.26
+Requires-Dist: pypdfium2>=4.30
+Dynamic: license-file
+
+# medhaocr
+
+OCR for scanned and digital documents that runs on a normal CPU - no GPU, no cloud. Give it a
+**PDF, JPG, JPEG or PNG** (the type is detected automatically) and it prints the text of every page, keeping
+headings, side-by-side fields and tables in place.
+
+## Install
+
+Python 3.10 or newer, then:
+
+```
+pip install medhaocr
+```
+
+The first run downloads the OCR models once (~250 MB, needs internet); after that it works offline.
+
+## Use from the command line
+
+```
+medhaocr scan.pdf
+medhaocr photo.jpg
+medhaocr scan.pdf > scan.txt        # save the text to a file
+```
+
+Output - the file name and page number, then that page's text:
+
+```
+scan.pdf - Page 1
+# INVOICE
+Invoice No   : 1234                    Date : 01/01/2025
+| Item     | Qty | Amount |
+|----------|-----|--------|
+| Paper A4 | 2   | 500.00 |
+
+scan.pdf - Page 2
+...
+```
+
+## Use from Python
+
+```python
+from medhaocr import extract, extract_text
+
+for page in extract("scan.pdf"):          # one result per page
+    print(page["file"], page["page"], page["seconds"])
+    print(page["text"])
+
+text = extract_text("photo.jpg")          # all pages as one string
+```
+
+## What it does
+
+Per page: crop scanner borders, straighten tilted scans, remove punch holes -> detect and read every text line
+(PP-OCRv6; a fast model reads every line, a stronger one re-reads uncertain lines) -> find headings, text blocks,
+tables and logos (PP-DocLayout v2) -> rebuild table rows and columns (SLANet+) -> print in reading order.
+Typically 4-9 seconds per page on a laptop CPU.
+
+Best on digital and scanned printed documents. Handwriting is not supported. Always check important values
+(numbers, dates, IDs) against the original.
+
+## License
+
+Apache-2.0

medhaocr-0.1.0/README.md

@@ -0,0 +1,63 @@
+# medhaocr
+
+OCR for scanned and digital documents that runs on a normal CPU - no GPU, no cloud. Give it a
+**PDF, JPG, JPEG or PNG** (the type is detected automatically) and it prints the text of every page, keeping
+headings, side-by-side fields and tables in place.
+
+## Install
+
+Python 3.10 or newer, then:
+
+```
+pip install medhaocr
+```
+
+The first run downloads the OCR models once (~250 MB, needs internet); after that it works offline.
+
+## Use from the command line
+
+```
+medhaocr scan.pdf
+medhaocr photo.jpg
+medhaocr scan.pdf > scan.txt        # save the text to a file
+```
+
+Output - the file name and page number, then that page's text:
+
+```
+scan.pdf - Page 1
+# INVOICE
+Invoice No   : 1234                    Date : 01/01/2025
+| Item     | Qty | Amount |
+|----------|-----|--------|
+| Paper A4 | 2   | 500.00 |
+
+scan.pdf - Page 2
+...
+```
+
+## Use from Python
+
+```python
+from medhaocr import extract, extract_text
+
+for page in extract("scan.pdf"):          # one result per page
+    print(page["file"], page["page"], page["seconds"])
+    print(page["text"])
+
+text = extract_text("photo.jpg")          # all pages as one string
+```
+
+## What it does
+
+Per page: crop scanner borders, straighten tilted scans, remove punch holes -> detect and read every text line
+(PP-OCRv6; a fast model reads every line, a stronger one re-reads uncertain lines) -> find headings, text blocks,
+tables and logos (PP-DocLayout v2) -> rebuild table rows and columns (SLANet+) -> print in reading order.
+Typically 4-9 seconds per page on a laptop CPU.
+
+Best on digital and scanned printed documents. Handwriting is not supported. Always check important values
+(numbers, dates, IDs) against the original.
+
+## License
+
+Apache-2.0

medhaocr-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "medhaocr"
+version = "0.1.0"
+description = "CPU-only OCR for scanned and digital documents (PDF, JPG, JPEG, PNG) that keeps headings, tables and layout"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "Maruti L Sankannanavar" }]
+keywords = ["ocr", "pdf", "scanned documents", "layout", "tables", "cpu"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+    "Topic :: Text Processing",
+]
+dependencies = [
+    "rapidocr>=3.9",
+    "rapid-layout>=1.2",
+    "rapid-table>=3.0",
+    "onnxruntime>=1.20",
+    "openvino>=2025.0",
+    "opencv-python-headless>=4.10",
+    "numpy>=1.26",
+    "pypdfium2>=4.30",
+]
+
+[project.scripts]
+medhaocr = "medhaocr.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

medhaocr-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

medhaocr-0.1.0/src/medhaocr/__init__.py

@@ -0,0 +1,66 @@
+"""
+Medha OCR - CPU-only OCR for scanned documents that keeps the page structure.
+
+    from medhaocr import extract
+    for page in extract("report.pdf"):          # pdf, jpg, jpeg or png - detected automatically
+        print(page["file"], page["page"])
+        print(page["text"])
+"""
+import logging
+import os
+
+os.environ.setdefault("TQDM_DISABLE", "1")      # no progress bars from the table model
+
+from .core import MedhaOCR, load_pages, render_text  # noqa: E402
+
+
+def _quiet_model_logs():
+    """The OCR / layout / table packages log INFO lines while loading models; keep only warnings."""
+    for name in list(logging.root.manager.loggerDict):
+        if name.lower().startswith(("rapidocr", "rapid_layout", "rapid_table", "rapidtable")):
+            logging.getLogger(name).setLevel(logging.WARNING)
+    for name in ("RapidOCR", "RapidTable", "rapid_layout", "rapid_table"):
+        logging.getLogger(name).setLevel(logging.WARNING)
+
+__version__ = "0.1.0"
+__all__ = ["extract", "extract_text", "MedhaOCR", "SUPPORTED"]
+
+SUPPORTED = (".pdf", ".jpg", ".jpeg", ".png")
+_engine = None
+
+
+def _get_engine():
+    global _engine
+    if _engine is None:                 # models load once per process (first call takes a few seconds)
+        previous = logging.root.manager.disable
+        logging.disable(logging.INFO)   # silence INFO lines printed while the models load
+        try:
+            _engine = MedhaOCR()
+        finally:
+            logging.disable(previous)   # restore the caller's logging settings
+        _quiet_model_logs()             # loggers created while loading models
+    return _engine
+
+
+def extract(path):
+    """OCR a PDF / JPG / JPEG / PNG file.
+
+    Yields one dict per page, in order:
+        {"file": "<file name>", "page": <page number, 1-based>, "text": "<extracted text>", "seconds": <float>}
+    """
+    path = os.fspath(path)
+    if not os.path.isfile(path):
+        raise FileNotFoundError(f"file not found: {path}")
+    ext = os.path.splitext(path)[1].lower()
+    if ext not in SUPPORTED:
+        raise ValueError(f"unsupported file type '{ext}' - supported: {', '.join(SUPPORTED)}")
+    engine = _get_engine()
+    name = os.path.basename(path)
+    for n, img in enumerate(load_pages(path), 1):
+        res = engine.read_page(img)
+        yield {"file": name, "page": n, "text": render_text(res), "seconds": round(res["seconds"], 2)}
+
+
+def extract_text(path):
+    """OCR a file and return all pages as one string: '<file> - Page N' header followed by the page text."""
+    return "\n\n".join(f"{p['file']} - Page {p['page']}\n{p['text']}" for p in extract(path))

medhaocr-0.1.0/src/medhaocr/__main__.py

@@ -0,0 +1,39 @@
+"""Command line:  medhaocr <file.pdf|.jpg|.jpeg|.png>   (or: python -m medhaocr <file>)
+
+Prints, for every page:
+    <file name> - Page <n>
+    <extracted text>
+"""
+import logging
+import sys
+import warnings
+
+
+def main(argv=None):
+    argv = sys.argv[1:] if argv is None else argv
+    if argv and argv[0] in ("-V", "--version"):
+        from . import __version__
+        print(f"medhaocr {__version__}")
+        return 0
+    if len(argv) != 1 or argv[0] in ("-h", "--help"):
+        print("usage: medhaocr <file.pdf | file.jpg | file.jpeg | file.png>", file=sys.stderr)
+        return 2
+    warnings.filterwarnings("ignore")
+    logging.disable(logging.WARNING)            # keep stdout to the extracted text only
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8")  # Windows consoles: print any character safely
+    from . import extract
+    try:
+        for i, page in enumerate(extract(argv[0])):
+            if i:
+                print()
+            print(f"{page['file']} - Page {page['page']}")
+            print(page["text"], flush=True)
+    except (FileNotFoundError, ValueError) as e:
+        print(f"medhaocr: {e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

medhaocr-0.1.0/src/medhaocr/core.py

@@ -0,0 +1,593 @@
+"""Medha OCR engine: preprocessing, OCR, layout analysis, table structure and rendering (CPU only)."""
+import html
+import os
+import re
+import sys
+import time
+
+import cv2
+import numpy as np
+from rapidocr import EngineType, ModelType, OCRVersion, RapidOCR
+from rapidocr.utils.process_img import get_rotate_crop_image
+
+
+PDF_DPI = 200            # PDF pages are rendered at this resolution
+TARGET_SIDE = 1600       # longest image side used for OCR
+OCR_BUDGET_S = 6.0       # per-page OCR time after which re-reads stop (layout + tables need ~2-3 s more)
+RECHECK_BELOW = 0.97     # lines read with lower confidence are re-read by the stronger model
+MIN_RECHECK = 0.60       # below this it is handwriting/scribble; re-reading does not help
+TEXT_COLS = 120          # width of the layout-text view in characters
+
+# a letter O/I/l inside a number or before a unit is a digit: 5OMG -> 50MG
+UNITS = r"(?:mg|mcg|ml|g|kg|cm|mm|mmhg|bpm|iu|u|%|hrs?|min|days?|m2)"
+MIXED_DIGIT = re.compile(r"(?<=\d)[OoIl](?=\d)|(?<=\d)[Oo](?=\s?" + UNITS + r"\b)|(?<=\d\.)[OoIl]|(?<=\b)[Oo](?=\.\d)",
+                         re.IGNORECASE)
+
+# layout-model classes -> our block kinds (anything not listed is plain text)
+LAYOUT_KIND = {"doc_title": "heading", "header": "heading", "paragraph_title": "title",
+               "header_image": "logo", "image": "image", "chart": "image", "seal": "seal",
+               "table": "table", "footer": "footer", "footnote": "footer", "footer_image": "footer"}
+
+
+# ----------------------------------------------------------------------------- input
+def load_pages(path):
+    """Yield BGR page images: every page of a PDF, or the single image."""
+    ext = os.path.splitext(path)[1].lower()
+    if ext == ".pdf":
+        import pypdfium2 as pdfium
+        pdf = pdfium.PdfDocument(path)
+        try:
+            for i in range(len(pdf)):
+                bitmap = pdf[i].render(scale=PDF_DPI / 72)
+                img = bitmap.to_numpy()                   # BGR(A) for pdfium's default bitmap format
+                if bitmap.mode in ("RGB", "RGBA", "RGBX"):
+                    img = img[..., [2, 1, 0]]
+                elif img.ndim == 3 and img.shape[2] == 4:
+                    img = img[..., :3]
+                elif img.ndim == 2:
+                    img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+                yield np.ascontiguousarray(img[..., :3])
+        finally:
+            pdf.close()
+    elif ext in (".jpg", ".jpeg", ".png"):
+        img = cv2.imdecode(np.fromfile(path, dtype=np.uint8), cv2.IMREAD_COLOR)
+        if img is None:
+            raise ValueError(f"cannot read image: {path}")
+        yield img
+    else:
+        raise ValueError(f"unsupported file type '{ext}' (use pdf, jpg, jpeg or png)")
+
+
+# ----------------------------------------------------------------------------- preprocessing
+def crop_border(img, pad=6):
+    """Remove the black scanner frame."""
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    _, mask = cv2.threshold(gray, 80, 255, cv2.THRESH_BINARY)
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((15, 15), np.uint8))
+    pts = cv2.findNonZero(mask)
+    if pts is None:
+        return img
+    x, y, w, h = cv2.boundingRect(pts)
+    return img[y + pad:y + h - pad, x + pad:x + w - pad]
+
+
+def resize_to(img, side):
+    h, w = img.shape[:2]
+    s = side / max(h, w)
+    return img if s >= 1 else cv2.resize(img, (int(w * s), int(h * s)), interpolation=cv2.INTER_AREA)
+
+
+def deskew(img, max_deg=3.0, step=0.1):
+    """Straighten a tilted scan: pick the angle giving the sharpest horizontal text-row profile."""
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    small = cv2.resize(gray, None, fx=800 / gray.shape[1], fy=800 / gray.shape[1], interpolation=cv2.INTER_AREA)
+    bw = cv2.adaptiveThreshold(small, 1, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 25, 15).astype(np.float32)
+    h, w = bw.shape
+    best, angle = -1.0, 0.0
+    for a in np.arange(-max_deg, max_deg + 1e-6, step):
+        rot = cv2.warpAffine(bw, cv2.getRotationMatrix2D((w / 2, h / 2), a, 1.0), (w, h), flags=cv2.INTER_NEAREST)
+        s = float(np.sum(np.diff(rot.sum(1)) ** 2))
+        if s > best:
+            best, angle = s, a
+    if abs(angle) < 0.05:
+        return img
+    H, W = img.shape[:2]
+    m = cv2.getRotationMatrix2D((W / 2, H / 2), angle, 1.0)
+    return cv2.warpAffine(img, m, (W, H), flags=cv2.INTER_CUBIC, borderValue=(255, 255, 255))
+
+
+def remove_punch_holes(img):
+    """Paint out solid round blobs (binder punch holes) so they are not read as characters."""
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    _, bw = cv2.threshold(gray, 70, 255, cv2.THRESH_BINARY_INV)
+    n, labels, stats, _ = cv2.connectedComponentsWithStats(bw, 8)
+    out, s = img.copy(), img.shape[1] / 1600
+    for i in range(1, n):
+        x, y, w, h, area = stats[i]
+        if 22 * s <= w <= 70 * s and 22 * s <= h <= 70 * s and 0.7 < w / h < 1.4 and area / (w * h) > 0.6:
+            out[labels == i] = 255
+    return out
+
+
+def preprocess(img):
+    return remove_punch_holes(deskew(resize_to(crop_border(img), TARGET_SIDE)))
+
+
+# ----------------------------------------------------------------------------- engines
+def _ocr_engine(rec_model):
+    return RapidOCR(params={
+        "Global.use_cls": False, "Global.log_level": "critical", "Global.text_score": 0.0,
+        "Det.ocr_version": OCRVersion.PPOCRV6, "Det.model_type": ModelType.SMALL, "Det.engine_type": EngineType.OPENVINO,
+        "Rec.ocr_version": OCRVersion.PPOCRV6, "Rec.model_type": rec_model, "Rec.engine_type": EngineType.ONNXRUNTIME,
+        "Rec.rec_batch_num": 1,   # no padding: each line's result is independent of other lines
+    })
+
+
+def _bbox(line):
+    b = line["box"]
+    return float(b[:, 0].min()), float(b[:, 1].min()), float(b[:, 0].max()), float(b[:, 1].max())
+
+
+class MedhaOCR:
+    def __init__(self):
+        from concurrent.futures import ThreadPoolExecutor
+        from rapid_layout import RapidLayout
+        from rapid_table import ModelType as TableModel, RapidTable, RapidTableInput
+        self.pool = ThreadPoolExecutor(1)
+        self.fast = _ocr_engine(ModelType.TINY)     # detector + fast recogniser for every line
+        self.strong = _ocr_engine(ModelType.SMALL)  # stronger recogniser for uncertain lines
+        self.layout = RapidLayout(model_type="pp_doc_layoutv2", conf_thresh=0.4)
+        self.table = RapidTable(RapidTableInput(model_type=TableModel.SLANETPLUS, use_ocr=False))
+        self.table.cfg.use_ocr = True               # we pass our own OCR results; no second OCR engine is loaded
+
+    # ---- 1. text lines
+    def read_lines(self, img, t0):
+        det = self.fast(img, use_rec=False)
+        if det.boxes is None:
+            return []
+        boxes = [np.asarray(b, dtype=np.float32) for b in det.boxes]
+        crops = [get_rotate_crop_image(img, b.copy()) for b in boxes]
+        r = self.fast.recognize_txt(crops)
+        lines = [{"box": b, "text": t, "score": float(s)} for b, t, s in zip(boxes, r.txts, r.scores)]
+
+        # re-read uncertain printed lines with the stronger model (tall + unsure = handwriting: skipped)
+        hs = np.array([b[:, 1].max() - b[:, 1].min() for b in boxes])
+        sure = [i for i, ln in enumerate(lines) if ln["score"] > 0.97]
+        med_h = float(np.median(hs[sure] if sure else hs))
+        todo = [i for i, ln in enumerate(lines)
+                if MIN_RECHECK <= ln["score"] and not (hs[i] > 1.35 * med_h and ln["score"] < 0.93)
+                and (ln["score"] < RECHECK_BELOW or MIXED_DIGIT.search(ln["text"]) or re.search(r"\d{8,}", ln["text"]))]
+        # least confident first, short lines first (cheap, and short values like 'Class III' matter most)
+        for i in sorted(todo, key=lambda i: (round(lines[i]["score"], 2), len(lines[i]["text"]))):
+            if time.perf_counter() - t0 > OCR_BUDGET_S:
+                break
+            r2 = self.strong.recognize_txt([crops[i]])
+            t, s = r2.txts[0], float(r2.scores[0])
+            old = lines[i]["text"]
+            same = t.replace(" ", "") == old.replace(" ", "")
+            if t.strip() and ((same and t.count(" ") > old.count(" ")) or (not same and s > lines[i]["score"])):
+                lines[i].update(text=t, score=s)
+
+        lines = drop_junk([ln for ln in lines if ln["text"].strip()])
+        for ln in lines:
+            ln["text"] = clean(ln["text"])
+        return lines
+
+    # ---- 2. layout regions
+    def read_regions(self, img):
+        r = self.layout(img)
+        if r.boxes is None:
+            return []
+        return [{"kind": LAYOUT_KIND.get(c, "text"), "box": [float(v) for v in b], "lines": []}
+                for b, c in zip(r.boxes, r.class_names)]
+
+    # ---- 3. table structure
+    def read_table(self, img, region):
+        x0, y0, x1, y1 = (int(round(v)) for v in region["box"])
+        x0, y0 = max(0, x0), max(0, y0)
+        crop = img[y0:y1, x0:x1]
+        lines = region["lines"]
+        if crop.size == 0 or not lines:
+            return None
+        boxes = np.array([ln["box"] - np.array([x0, y0], dtype=np.float32) for ln in lines])
+        out = self.table([crop], ocr_results=[(boxes, tuple(ln["text"] for ln in lines),
+                                              tuple(ln["score"] for ln in lines))])
+        if not out.cell_bboxes or len(out.cell_bboxes[0]) == 0:
+            return None
+        return fill_table(out.cell_bboxes[0], out.logic_points[0], boxes, [ln["text"] for ln in lines])
+
+    # ---- whole page
+    def read_page(self, img):
+        t0 = time.perf_counter()
+        img = preprocess(img)
+        layout_job = self.pool.submit(self.read_regions, img)   # layout model runs in parallel with OCR
+        lines = self.read_lines(img, t0)
+        annotate_style(img, lines)
+        rules = detect_rules(img)
+        regions = layout_job.result()
+        pictures = []                                      # logos, photos, barcodes, stamps: kept as images
+        for rg in regions:
+            if rg["kind"] in ("logo", "image", "seal"):
+                x0, y0, x1, y1 = (int(round(v)) for v in rg["box"])
+                snip = img[max(0, y0):y1, max(0, x0):x1]
+                if snip.size:
+                    pictures.append({"box": (x0, y0, x1, y1), "snip": snip.copy(), "kind": rg["kind"]})
+        blocks = build_blocks(lines, regions)
+        for ln in lines:                                   # headings/titles found by the layout model are bold
+            if ln.get("kind") in ("heading", "title"):
+                ln["bold"] = True
+        for blk in blocks:
+            if blk["type"] == "table":
+                blk["grid"] = self.read_table(img, blk["region"])
+                if blk["grid"] is None:            # not a real grid (e.g. a boxed form): keep positional layout
+                    blk.update(type="rows", rows=group_rows(blk["region"]["lines"]))
+        H, W = img.shape[:2]
+        return {"blocks": blocks, "lines": lines, "rules": rules, "pictures": pictures, "width": W, "height": H,
+                "seconds": time.perf_counter() - t0}
+
+
+# ----------------------------------------------------------------------------- text clean-up
+def clean(text):
+    text = MIXED_DIGIT.sub(lambda m: "0" if m.group(0) in "Oo" else "1", text)      # 5OMG -> 50MG
+    text = re.sub("^[O0o\u25cb]\\s+(?=[A-Z(<])", "", text)                          # leading checkbox circle
+    text = re.sub("(?<=\\s)[O0\u25cb]\\s+(?=[A-Z][a-z])", "", text)                 # checkbox circle mid-line
+    text = re.sub(r"(?<![A-Za-z])[Oo](?=[A-Z][a-z]{2,})", "", text)                  # 'OUpper' -> 'Upper'
+    return text
+
+
+def drop_junk(lines):
+    """Remove signatures, logo fragments and specks (by size and confidence)."""
+    if not lines:
+        return lines
+    heights = [ln["box"][:, 1].max() - ln["box"][:, 1].min() for ln in lines]
+    med_h = float(np.median(heights))
+    keep = []
+    for ln, h in zip(lines, heights):
+        t, s = ln["text"].strip(), ln["score"]
+        scribble = h > 2.5 * med_h and len(t) <= 12 and s < 0.9
+        fragment = ((len(t) <= 4 and s < 0.7) or (len(t) <= 2 and s < 0.85)) and not t.isdigit()
+        if not (scribble or fragment):
+            keep.append(ln)
+    return keep
+
+
+# ----------------------------------------------------------------------------- visual style
+def _crop_box(img, box, pad=0):
+    H, W = img.shape[:2]
+    x0, y0 = max(0, int(box[:, 0].min()) - pad), max(0, int(box[:, 1].min()) - pad)
+    x1, y1 = min(W, int(box[:, 0].max()) + pad), min(H, int(box[:, 1].max()) + pad)
+    return img[y0:y1, x0:x1]
+
+
+def annotate_style(img, lines):
+    """Per line: size (px), ink colour, bold flag, handwriting flag (+ image snippet of handwriting)."""
+    if not lines:
+        return
+    for ln in lines:
+        crop = _crop_box(img, ln["box"])
+        h = ln["box"][:, 1].max() - ln["box"][:, 1].min()
+        ln["size"] = float(h)
+        ln["stroke"], ln["color"] = 0.0, "#111111"
+        if crop.size == 0:
+            continue
+        g = cv2.cvtColor(crop, cv2.COLOR_BGR2GRAY)
+        _, bw = cv2.threshold(g, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)
+        ink = bw > 0
+        if ink.sum() < 10:
+            continue
+        cs, _ = cv2.findContours(bw, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
+        perimeter = sum(cv2.arcLength(c, True) for c in cs)
+        ln["stroke"] = 2 * ink.sum() / max(perimeter, 1.0) / max(h, 1.0)   # stroke width relative to height
+        b, gch, r = (np.median(crop[..., k][ink]) for k in range(3))
+        dark = min(1.0, 90 / max(1.0, (r + gch + b) / 3))                   # print ink is darker than scanned grey
+        ln["color"] = "#%02x%02x%02x" % tuple(int(v * dark) for v in (r, gch, b))
+    heights = np.array([ln["size"] for ln in lines])
+    strokes = np.array([ln["stroke"] for ln in lines])
+    med_h = float(np.median(heights))
+    for ln in lines:
+        peers = strokes[(heights > 0.8 * ln["size"]) & (heights < 1.25 * ln["size"]) & (strokes > 0)]
+        ref = np.median(peers) if len(peers) >= 5 else np.median(strokes[strokes > 0])
+        ln["bold"] = bool(ln["stroke"] > 1.3 * ref)
+        ln["hand"] = bool((ln["score"] < 0.85 and ln["size"] > 1.3 * med_h) or ln["score"] < 0.75)
+        if ln["hand"]:
+            ln["snip"] = _crop_box(img, ln["box"], pad=2).copy()
+
+
+def detect_rules(img):
+    """Printed form lines / table borders as segments (x0, y0, x1, y1, thickness)."""
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    bw = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 25, 12)
+    H, W = gray.shape
+    segs = []
+    for kernel, horizontal in (((max(40, W // 25), 1), True), ((1, max(40, H // 35)), False)):
+        m = cv2.morphologyEx(bw, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_RECT, kernel))
+        cs, _ = cv2.findContours(m, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        for c in cs:
+            x, y, w, h = cv2.boundingRect(c)
+            if horizontal and w >= kernel[0] and h <= 8:
+                segs.append((x, y + h / 2, x + w, y + h / 2, max(1, h)))
+            elif not horizontal and h >= kernel[1] and w <= 8:
+                segs.append((x + w / 2, y, x + w / 2, y + h, max(1, w)))
+    return segs
+
+
+# ----------------------------------------------------------------------------- structure
+def build_blocks(lines, regions):
+    """Assign text lines to layout regions, then cut the page into horizontal bands (reading order).
+    Returns blocks: {"type": "table", "region"} or {"type": "rows", "rows": [[item, ...], ...]}."""
+    # each line goes to the region covering most of it (tables win ties, then the smaller region)
+    orphans = []
+    for ln in lines:
+        x0, y0, x1, y1 = _bbox(ln)
+        area = max(1.0, (x1 - x0) * (y1 - y0))
+        best = None
+        for rg in regions:
+            rx0, ry0, rx1, ry1 = rg["box"]
+            ov = max(0.0, min(x1, rx1) - max(x0, rx0)) * max(0.0, min(y1, ry1) - max(y0, ry0)) / area
+            key = (ov >= 0.5, rg["kind"] == "table", -(rx1 - rx0) * (ry1 - ry0))
+            if ov >= 0.5 and (best is None or key > best[0]):
+                best = (key, rg)
+        if best:
+            best[1]["lines"].append(ln)
+        else:
+            orphans.append(ln)
+    regions = regions + [{"kind": "text", "box": list(_bbox(ln)), "lines": [ln]} for ln in orphans]
+
+    # every line carries the kind of its region; logos/images become one "[logo: ...]" item
+    usable = []
+    for rg in regions:
+        if rg["kind"] in ("logo", "image", "seal"):
+            words = " ".join(i["text"] for row in group_rows(rg["lines"]) for i in row)
+            x0, y0, x1, y1 = rg["box"]
+            box = np.array([[x0, y0], [x1, y0], [x1, y1], [x0, y1]], dtype=np.float32)
+            label = f"[{rg['kind']}: {words}]" if words else f"[{rg['kind']}]"
+            rg["lines"] = [{"box": box, "text": label, "score": 1.0}]
+        if not rg["lines"]:
+            continue
+        for ln in rg["lines"]:
+            ln["kind"] = rg["kind"] if rg["kind"] != "table" else "text"
+        usable.append(rg)
+
+    # horizontal bands: regions that sit side by side share a band; a table is always its own band
+    bands = []
+    for rg in sorted(usable, key=lambda r: r["box"][1]):
+        y0, y1 = rg["box"][1], rg["box"][3]
+        if bands and rg["kind"] != "table" and not bands[-1]["table"]:
+            b = bands[-1]
+            if min(y1, b["y1"]) - max(y0, b["y0"]) > 0.3 * min(y1 - y0, b["y1"] - b["y0"]):
+                b["regions"].append(rg)
+                b["y0"], b["y1"] = min(b["y0"], y0), max(b["y1"], y1)
+                continue
+        bands.append({"y0": y0, "y1": y1, "table": rg["kind"] == "table", "regions": [rg]})
+
+    blocks = []
+    for b in bands:
+        if b["table"]:
+            blocks.append({"type": "table", "region": b["regions"][0], "y0": b["y0"], "y1": b["y1"]})
+        else:
+            blocks.append({"type": "rows", "rows": group_rows([ln for rg in b["regions"] for ln in rg["lines"]]),
+                           "y0": b["y0"], "y1": b["y1"]})
+    return blocks
+
+
+def group_rows(lines):
+    """Group text boxes into rows (top to bottom), items in a row left to right."""
+    rows = []
+    for ln in sorted(lines, key=lambda ln: ln["box"][:, 1].mean()):
+        cy = ln["box"][:, 1].mean()
+        h = ln["box"][:, 1].max() - ln["box"][:, 1].min()
+        near = [(abs(cy - r["cy"]), r) for r in rows if abs(cy - r["cy"]) < 0.45 * min(h, r["h"])]
+        if near:
+            min(near, key=lambda n: n[0])[1]["items"].append(ln)
+        else:
+            rows.append({"cy": cy, "h": h, "items": [ln]})
+    rows.sort(key=lambda r: r["cy"])
+    return [sorted(r["items"], key=lambda i: i["box"][:, 0].min()) for r in rows]
+
+
+def fill_table(cell_boxes, logic, line_boxes, texts):
+    """Put OCR lines into the table structure predicted by SLANet+.
+    The predicted cell boxes drift on long tables, so the row positions are first aligned to the text
+    (least-squares fit y_cell = a*y_text + b, refined 5 times), then each line goes to its row and to the
+    cell of that row under its x-centre. Returns a rectangular grid of strings, or None if the region is
+    not really a grid (a boxed form where cells hold whole paragraphs)."""
+    cells = []
+    for cb, (r0, r1, c0, c1) in zip(cell_boxes, logic):
+        xs, ys = cb[0::2], cb[1::2]
+        cells.append({"r0": int(r0), "r1": int(r1), "c0": int(c0), "c1": int(c1),
+                      "x0": float(xs.min()), "x1": float(xs.max()), "y0": float(ys.min()), "y1": float(ys.max()),
+                      "lines": []})
+    R = max(c["r1"] for c in cells) + 1
+    C = max(c["c1"] for c in cells) + 1
+    centers = np.full(R, np.nan)
+    for r in range(R):
+        ys = [(c["y0"] + c["y1"]) / 2 for c in cells if c["r0"] == c["r1"] == r]
+        if ys:
+            centers[r] = np.median(ys)
+    known = ~np.isnan(centers)
+    if known.sum() < 2:
+        return None
+    centers = np.interp(np.arange(R), np.flatnonzero(known), centers[known])
+
+    ly = np.array([(b[:, 1].min() + b[:, 1].max()) / 2 for b in line_boxes])
+    lx = np.array([(b[:, 0].min() + b[:, 0].max()) / 2 for b in line_boxes])
+    a, b = 1.0, 0.0
+    for _ in range(5):                                   # align text rows to predicted rows
+        rows = np.abs((a * ly + b)[:, None] - centers[None, :]).argmin(1)
+        if len(set(rows)) < 2:
+            break
+        a, b = np.polyfit(ly, centers[rows], 1)
+    rows = np.abs((a * ly + b)[:, None] - centers[None, :]).argmin(1)
+
+    for i, r in enumerate(rows):
+        cand = [c for c in cells if c["r0"] <= r <= c["r1"]] or cells
+        inside = [c for c in cand if c["x0"] <= lx[i] <= c["x1"]]
+        cell = min(inside or cand, key=lambda c: (c["x1"] - c["x0"]) if inside else
+                   min(abs(lx[i] - c["x0"]), abs(lx[i] - c["x1"])))
+        cell["lines"].append(i)
+
+    filled = [c for c in cells if c["lines"]]
+    if not filled or len(texts) / len(filled) > 2.5:      # paragraphs in boxes, not a data grid
+        return None
+    grid = [[""] * C for _ in range(R)]
+    for c in filled:
+        order = sorted(c["lines"], key=lambda i: (round(ly[i] / 12), lx[i]))
+        grid[c["r0"]][c["c0"]] = " ".join(texts[i] for i in order)
+    return [row for row in grid if any(row)] or None      # all predicted columns kept (blank cells stay blank)
+
+
+# ----------------------------------------------------------------------------- rendering
+def render_text(page):
+    """Layout text: headings as '#', rows aligned to their position on the page, tables as aligned grids."""
+    items = [i for blk in page["blocks"] if blk["type"] == "rows" for row in blk["rows"] for i in row]
+    xs = [i["box"][:, 0].min() for i in items]
+    left = min(xs) if xs else 0.0
+    scale = TEXT_COLS / max(1.0, page["width"] - left)
+    line_h = float(np.median([i["box"][:, 1].max() - i["box"][:, 1].min() for i in items] or [20]))
+    out, footer_seen, prev_y1 = [], False, None
+    for blk in page["blocks"]:
+        if prev_y1 is not None and (blk["type"] == "table" or blk["y0"] - prev_y1 > 0.9 * line_h):
+            out.append("")                                   # blank line only where the page has a gap
+        prev_y1 = blk["y1"]
+        if blk["type"] == "table":
+            out.append(grid_to_text(blk["grid"]))
+            prev_y1 = -1e9                                   # always a blank line after a table
+            continue
+        for row in blk["rows"]:
+            kinds = {i.get("kind", "text") for i in row}
+            if kinds == {"footer"} and not footer_seen:
+                out.append("-" * TEXT_COLS)
+                footer_seen = True
+            line = ""
+            for i in row:
+                col = int((i["box"][:, 0].min() - left) * scale)
+                line += " " * (col - len(line)) if col > len(line) else ("  " if line else "")
+                line += i["text"]
+            if kinds == {"heading"}:
+                line = "# " + line.strip()
+            elif kinds <= {"heading", "title"}:
+                line = "## " + line.strip()
+            out.append(line.rstrip())
+    return "\n".join(out).strip("\n")
+
+
+def grid_to_text(grid):
+    widths = [max(len(r[c]) for r in grid) for c in range(len(grid[0]))]
+    fmt = lambda r: "| " + " | ".join(v.ljust(w) for v, w in zip(r, widths)) + " |"
+    lines = [fmt(grid[0]), "|" + "|".join("-" * (w + 2) for w in widths) + "|"]
+    return "\n".join(lines + [fmt(r) for r in grid[1:]])
+
+
+HTML_HEAD = """<!doctype html><html><head><meta charset="utf-8"><title>Medha OCR - {title}</title><style>
+body{{background:#e9ecef;font-family:Segoe UI,Arial,sans-serif;margin:0;padding:24px;color:#111}}
+.page{{background:#fff;max-width:980px;margin:0 auto 28px;padding:36px 44px;box-shadow:0 1px 6px #0002}}
+.pg{{color:#888;font-size:12px;margin-bottom:14px}}
+.row{{position:relative;min-height:1.5em;line-height:1.5em;white-space:nowrap}}
+.row span{{position:absolute;white-space:nowrap}}
+.heading{{font-size:1.35em;font-weight:700;min-height:1.8em}} .title{{font-weight:700;margin-top:.5em}}
+.footer{{color:#555;font-size:.85em}} hr{{border:0;border-top:1px solid #ccc;margin:14px 0}}
+.logo,.image,.seal{{color:#1a5fb4;font-style:italic}}
+.block{{margin-bottom:.6em}} table{{border-collapse:collapse;margin:8px 0 14px;font-size:.92em}}
+td{{border:1px solid #999;padding:3px 8px;vertical-align:top}} tr:first-child td{{font-weight:700;background:#f3f5f8}}
+</style></head><body>"""
+
+
+def render_html(pages, title):
+    out = [HTML_HEAD.format(title=html.escape(title))]
+    for n, page in enumerate(pages, 1):
+        items = [i for blk in page["blocks"] if blk["type"] == "rows" for row in blk["rows"] for i in row]
+        left = min([i["box"][:, 0].min() for i in items] or [0.0])
+        span = max(1.0, page["width"] - left)
+        out.append(f'<section class="page"><div class="pg">Page {n}</div>')
+        footer_seen = False
+        for blk in page["blocks"]:
+            out.append('<div class="block">')
+            if blk["type"] == "table":
+                out.append("<table>")
+                for row in blk["grid"]:
+                    out.append("<tr>" + "".join(f"<td>{html.escape(v)}</td>" for v in row) + "</tr>")
+                out.append("</table>")
+            else:
+                for row in blk["rows"]:
+                    kinds = {i.get("kind", "text") for i in row}
+                    cls = "heading" if kinds == {"heading"} else "title" if kinds <= {"heading", "title"} else \
+                        "footer" if kinds == {"footer"} else ""
+                    if cls == "footer" and not footer_seen:
+                        out.append("<hr>")
+                        footer_seen = True
+                    spans = "".join(
+                        f'<span class="{i.get("kind", "")}" style="left:{100 * (i["box"][:, 0].min() - left) / span:.1f}%">'
+                        f'{html.escape(i["text"])}</span>' for i in row)
+                    out.append(f'<div class="row {cls}">{spans}</div>')
+            out.append("</div>")
+        out.append("</section>")
+    out.append("</body></html>")
+    return "\n".join(out)
+
+
+VIEW_W = 900             # page width (px) in the page view
+
+
+def page_elements(page, view_w=VIEW_W):
+    """Everything needed to redraw a page at view_w pixels wide: rules, pictures, text items, handwriting."""
+    s = view_w / page["width"]
+    pics = [p for p in page["pictures"]]
+    in_pic = lambda ln: any(p["kind"] == "logo" and p["box"][0] <= ln["box"][:, 0].mean() <= p["box"][2]
+                            and p["box"][1] <= ln["box"][:, 1].mean() <= p["box"][3] for p in pics)
+    snip = lambda im, w, h: cv2.resize(im, (max(1, int(w)), max(1, int(h))), interpolation=cv2.INTER_AREA)
+    el = {"w": view_w, "h": page["height"] * s, "rules": [], "images": [], "texts": []}
+    # one body-text size per page: detected box heights jitter, real documents use a few fixed sizes
+    printed = [ln["size"] for ln in page["lines"] if not ln.get("hand") and ln["score"] > 0.9]
+    body = float(np.median(printed)) if printed else 0.0
+    norm = lambda h: body if body and 0.8 * body <= h <= 1.3 * body else h
+    for x0, y0, x1, y1, t in page["rules"]:
+        el["rules"].append((x0 * s, y0 * s, x1 * s, y1 * s, max(1.0, t * s)))
+    for p in pics:
+        x0, y0, x1, y1 = p["box"]
+        el["images"].append({"x": x0 * s, "y": y0 * s, "img": snip(p["snip"], (x1 - x0) * s, (y1 - y0) * s),
+                             "title": p["kind"]})
+    for ln in page["lines"]:
+        if in_pic(ln):
+            continue                                       # text inside a logo is drawn by the logo image
+        x0, y0 = ln["box"][:, 0].min() * s, ln["box"][:, 1].min() * s
+        w, h = (ln["box"][:, 0].max() - ln["box"][:, 0].min()) * s, ln["size"] * s
+        if ln.get("hand") and ln.get("snip") is not None:
+            el["images"].append({"x": x0, "y": y0, "img": snip(ln["snip"], w + 4 * s, h + 4 * s),
+                                 "title": "handwriting (OCR: " + ln["text"] + ")"})
+        else:
+            el["texts"].append({"x": x0, "y": y0, "w": w, "px": max(6.0, norm(ln["size"]) * s * 0.8), "text": ln["text"],
+                                "bold": ln.get("bold", False), "color": ln.get("color", "#111")})
+    return el
+
+
+def _png_b64(img):
+    import base64
+    return base64.b64encode(cv2.imencode(".png", img)[1].tobytes()).decode()
+
+
+def render_page_html(pages, title):
+    """Faithful page view: every line at its own position, size, weight and colour; form lines; pictures."""
+    out = [f"""<!doctype html><html><head><meta charset="utf-8"><title>Medha OCR - {html.escape(title)}</title><style>
+body{{background:#e9ecef;margin:0;padding:24px;font-family:Arial,Helvetica,sans-serif}}
+.pg{{color:#666;font-size:12px;margin:0 auto 4px;width:{VIEW_W}px}}
+.pv{{position:relative;background:#fff;margin:0 auto 28px;box-shadow:0 1px 6px #0003;overflow:hidden}}
+.pv svg{{position:absolute;left:0;top:0}} .pv img{{position:absolute}}
+.t{{position:absolute;white-space:nowrap;line-height:1;transform-origin:0 0}}
+</style></head><body>"""]
+    for n, page in enumerate(pages, 1):
+        el = page_elements(page)
+        out.append(f'<div class="pg">Page {n}</div><div class="pv" style="width:{el["w"]:.0f}px;height:{el["h"]:.0f}px">')
+        out.append(f'<svg width="{el["w"]:.0f}" height="{el["h"]:.0f}">' + "".join(
+            f'<line x1="{a:.1f}" y1="{b:.1f}" x2="{c:.1f}" y2="{d:.1f}" stroke="#444" stroke-width="{t:.1f}"/>'
+            for a, b, c, d, t in el["rules"]) + "</svg>")
+        for im in el["images"]:
+            out.append(f'<img src="data:image/png;base64,{_png_b64(im["img"])}" title="{html.escape(im["title"])}" '
+                       f'style="left:{im["x"]:.1f}px;top:{im["y"]:.1f}px">')
+        for t in el["texts"]:
+            out.append(f'<span class="t" data-w="{t["w"]:.1f}" style="left:{t["x"]:.1f}px;top:{t["y"]:.1f}px;'
+                       f'font-size:{t["px"]:.1f}px;font-weight:{700 if t["bold"] else 400};color:{t["color"]}">'
+                       f'{html.escape(t["text"])}</span>')
+        out.append("</div>")
+    out.append("""<script>for(const e of document.querySelectorAll('.t')){const w=e.getBoundingClientRect().width;
+if(w>0)e.style.transform='scaleX('+(parseFloat(e.dataset.w)/w)+')';}</script></body></html>""")
+    return "\n".join(out)

medhaocr-0.1.0/src/medhaocr.egg-info/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: medhaocr
+Version: 0.1.0
+Summary: CPU-only OCR for scanned and digital documents (PDF, JPG, JPEG, PNG) that keeps headings, tables and layout
+Author: Maruti L Sankannanavar
+License-Expression: Apache-2.0
+Keywords: ocr,pdf,scanned documents,layout,tables,cpu
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rapidocr>=3.9
+Requires-Dist: rapid-layout>=1.2
+Requires-Dist: rapid-table>=3.0
+Requires-Dist: onnxruntime>=1.20
+Requires-Dist: openvino>=2025.0
+Requires-Dist: opencv-python-headless>=4.10
+Requires-Dist: numpy>=1.26
+Requires-Dist: pypdfium2>=4.30
+Dynamic: license-file
+
+# medhaocr
+
+OCR for scanned and digital documents that runs on a normal CPU - no GPU, no cloud. Give it a
+**PDF, JPG, JPEG or PNG** (the type is detected automatically) and it prints the text of every page, keeping
+headings, side-by-side fields and tables in place.
+
+## Install
+
+Python 3.10 or newer, then:
+
+```
+pip install medhaocr
+```
+
+The first run downloads the OCR models once (~250 MB, needs internet); after that it works offline.
+
+## Use from the command line
+
+```
+medhaocr scan.pdf
+medhaocr photo.jpg
+medhaocr scan.pdf > scan.txt        # save the text to a file
+```
+
+Output - the file name and page number, then that page's text:
+
+```
+scan.pdf - Page 1
+# INVOICE
+Invoice No   : 1234                    Date : 01/01/2025
+| Item     | Qty | Amount |
+|----------|-----|--------|
+| Paper A4 | 2   | 500.00 |
+
+scan.pdf - Page 2
+...
+```
+
+## Use from Python
+
+```python
+from medhaocr import extract, extract_text
+
+for page in extract("scan.pdf"):          # one result per page
+    print(page["file"], page["page"], page["seconds"])
+    print(page["text"])
+
+text = extract_text("photo.jpg")          # all pages as one string
+```
+
+## What it does
+
+Per page: crop scanner borders, straighten tilted scans, remove punch holes -> detect and read every text line
+(PP-OCRv6; a fast model reads every line, a stronger one re-reads uncertain lines) -> find headings, text blocks,
+tables and logos (PP-DocLayout v2) -> rebuild table rows and columns (SLANet+) -> print in reading order.
+Typically 4-9 seconds per page on a laptop CPU.
+
+Best on digital and scanned printed documents. Handwriting is not supported. Always check important values
+(numbers, dates, IDs) against the original.
+
+## License
+
+Apache-2.0

medhaocr-0.1.0/src/medhaocr.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/medhaocr/__init__.py
+src/medhaocr/__main__.py
+src/medhaocr/core.py
+src/medhaocr.egg-info/PKG-INFO
+src/medhaocr.egg-info/SOURCES.txt
+src/medhaocr.egg-info/dependency_links.txt
+src/medhaocr.egg-info/entry_points.txt
+src/medhaocr.egg-info/requires.txt
+src/medhaocr.egg-info/top_level.txt

medhaocr-0.1.0/src/medhaocr.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

medhaocr-0.1.0/src/medhaocr.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+medhaocr = medhaocr.__main__:main

medhaocr-0.1.0/src/medhaocr.egg-info/requires.txt

@@ -0,0 +1,8 @@
+rapidocr>=3.9
+rapid-layout>=1.2
+rapid-table>=3.0
+onnxruntime>=1.20
+openvino>=2025.0
+opencv-python-headless>=4.10
+numpy>=1.26
+pypdfium2>=4.30

medhaocr-0.1.0/src/medhaocr.egg-info/top_level.txt

@@ -0,0 +1 @@
+medhaocr