diff --git a/.gitattributes b/.gitattributes
index 1ef325f1b111266a6b26e0196871bd78baa8c2f3..1cf1df9110199449371df3536cb7ae773a75661a 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,4 +1,6 @@
*.7z filter=lfs diff=lfs merge=lfs -text
+*.ipynb filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text
*.arrow filter=lfs diff=lfs merge=lfs -text
*.bin filter=lfs diff=lfs merge=lfs -text
*.bz2 filter=lfs diff=lfs merge=lfs -text
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..bd8cd18eb507aaaea59caa98a03af1bb0584a482
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,143 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+.DS_Store
+data/
+models/
+output-*/
+outputs-*/
+outputs/
+*.jpg
+*.jpeg
+*.png
+docs/feedbacks/
+*.tar
+*.pth
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+.idea/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+# However, in case of collaboration, if having platform-specific dependencies or dependencies
+# having no cross-platform support, pipenv may install dependencies that don't work, or not
+# install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..a11adbafa61de469117ae782cc5168bde7b89667
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,19 @@
+# Read the Docs configuration file for MkDocs projects
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+# Required
+version: 2
+
+# Set the version of Python and other tools you might need
+build:
+ os: ubuntu-22.04
+ tools:
+ python: "3.9"
+
+mkdocs:
+ configuration: mkdocs.yml
+
+# Optionally declare the Python requirements required to build your docs
+python:
+ install:
+ - requirements: docs/requirements.txt
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..334b993f68bd352ca77efe9bf7e65e14cce19711
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 BreezeDeus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..3091378b9f6f51b4bf61fbdc7152571a3e720e7a
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,44 @@
+predict:
+ p2t predict -l en,ch_sim -a mfd -t yolov7_tiny -i docs/examples/mixed.jpg --save-analysis-res tmp-output.jpg
+# p2t predict -l en,ch_sim --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' \
+# --use-analyzer -a mfd -t yolov7 --resized-shape 768 \
+# --analyzer-model-fp ~/.cnstd/1.2/analysis/mfd-yolov7-epoch224-20230613.pt \
+# --latex-ocr-model-fp ~/.pix2text/formula/p2t-mfr-20230702.pth \
+# -i docs/examples/mixed.jpg --save-analysis-res tmp-output.jpg
+# p2t predict -l vi \
+# --use-analyzer -a mfd -t yolov7 --resized-shape 768 \
+# --analyzer-model-fp ~/.cnstd/1.2/analysis/mfd-yolov7-epoch224-20230613.pt \
+# --latex-ocr-model-fp ~/.pix2text/formula/p2t-mfr-20230702.pth \
+# -i docs/examples/vietnamese.jpg --save-analysis-res tmp-output.jpg
+# p2t predict -l en,ch_tra \
+# --use-analyzer -a mfd -t yolov7 --resized-shape 768 \
+# --analyzer-model-fp ~/.cnstd/1.2/analysis/mfd-yolov7-epoch224-20230613.pt \
+# --latex-ocr-model-fp ~/.pix2text/formula/p2t-mfr-20230702.pth --rec-kwargs '{"det_bbox_max_expand_ratio": 0}'\
+# -i docs/examples/ch_tra7.jpg --save-analysis-res tmp-output.jpg
+
+evaluate-mfr:
+ p2t evaluate -l en,ch_sim --mfd-config '{"model_name": "mfd"}' \
+ --formula-ocr-config '{"model_name":"mfr-1.5","model_backend":"onnx"}' \
+ --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' \
+ --resized-shape 768 --auto-line-break --file-type formula \
+ --max-samples 50 --prefix-img-dir data \
+ -i data/exported_call_events_with_images.json -o data/exported_cer_mfr1.0.json \
+ --output-excel data/exported_cer_mfr1.0.xls --output-html data/exported_cer_mfr1.0.html
+
+
+package:
+ rm -rf build
+ python setup.py sdist bdist_wheel
+
+VERSION := $(shell sed -n "s/^__version__ = '\(.*\)'/\1/p" pix2text/__version__.py)
+upload:
+ python -m twine upload dist/pix2text-$(VERSION)* --verbose
+
+# 开启 OCR HTTP 服务
+serve:
+ p2t serve -l en,ch_sim -a mfd -t yolov7 --analyzer-model-fp ~/.cnstd/1.2/analysis/mfd-yolov7-epoch224-20230613.pt --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}'
+
+docker-build:
+ docker build -t breezedeus/pix2text:v$(VERSION) .
+
+.PHONY: package upload serve daemon
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..20086e72ac0dc9641cc87f6063891d6c4d299b67
--- /dev/null
+++ b/README.md
@@ -0,0 +1,284 @@
+
+
+
+
+[](https://discord.gg/GgD87WM8Tf)
+[](https://pepy.tech/project/pix2text)
+[](https://visitorbadge.io/status?path=https%3A%2F%2Fgithub.com%2Fbreezedeus%2FPix2Text)
+[](./LICENSE)
+[](https://badge.fury.io/py/pix2text)
+[](https://github.com/breezedeus/pix2text)
+[](https://github.com/breezedeus/pix2text)
+
+
+[](https://twitter.com/breezedeus)
+
+[📖 Doc](https://pix2text.readthedocs.io) |
+[👩🏻💻 Online Service](https://p2t.breezedeus.com) |
+[👨🏻💻 Demo](https://huggingface.co/spaces/breezedeus/Pix2Text-Demo) |
+[💬 Contact](https://www.breezedeus.com/article/join-group)
+
+
+
+[中文](./README_cn.md) | English
+
+
+
+
+
+# Pix2Text
+
+## Update 2025.07.25: **V1.1.4** Released
+
+Major Changes:
+
+- Upgraded the Mathematical Formula Detection (MFD) and Mathematical Formula Recognition (MFR) models to version 1.5. All default configurations, documentation, and examples now use `mfd-1.5` and `mfr-1.5` as the standard models.
+
+## Update 2025.04.15: **V1.1.3** Released
+
+Major Changes:
+
+- Support for `VlmTableOCR` and `VlmTextFormulaOCR` models based on the VLM interface (see [LiteLLM documentation](https://docs.litellm.ai/docs/)) allowing the use of closed-source VLM models. Installation command: `pip install pix2text[vlm]`.
+ - Usage examples can be found in [tests/test_vlm.py](tests/test_vlm.py) and [tests/test_pix2text.py](tests/test_pix2text.py).
+
+## Update 2024.11.17: **V1.1.2** Released
+
+Major Changes:
+
+* A new layout analysis model [DocLayout-YOLO](https://github.com/opendatalab/DocLayout-YOLO) has been integrated, improving the accuracy of layout analysis.
+
+## Update 2024.06.18：**V1.1.1** Released
+
+Major changes:
+
+* Support the new mathematical formula detection models (MFD): [breezedeus/pix2text-mfd](https://huggingface.co/breezedeus/pix2text-mfd) ([Mirror](https://hf-mirror.com/breezedeus/pix2text-mfd)), which significantly improves the accuracy of formula detection.
+
+See details: [Pix2Text V1.1.1 Released, Bringing Better Mathematical Formula Detection Models | Breezedeus.com](https://www.breezedeus.com/article/p2t-mfd-v1.1.1).
+
+## Update 2024.04.28: **V1.1** Released
+
+Major changes:
+
+* Added layout analysis and table recognition models, supporting the conversion of images with complex layouts into Markdown format. See examples: [Pix2Text Online Documentation / Examples](https://pix2text.readthedocs.io/zh-cn/stable/examples_en/).
+* Added support for converting entire PDF files to Markdown format. See examples: [Pix2Text Online Documentation / Examples](https://pix2text.readthedocs.io/zh-cn/stable/examples_en/).
+* Enhanced the interface with more features, including adjustments to existing interface parameters.
+* Launched the [Pix2Text Online Documentation](https://pix2text.readthedocs.io).
+
+## Update 2024.02.26: **V1.0** Released
+
+Main Changes:
+
+* The Mathematical Formula Recognition (MFR) model employs a new architecture and has been trained on a new dataset, achieving state-of-the-art (SOTA) accuracy. For detailed information, please see: [Pix2Text V1.0 New Release: The Best Open-Source Formula Recognition Model | Breezedeus.com](https://www.breezedeus.com/article/p2t-v1.0).
+
+See more at: [RELEASE.md](docs/RELEASE.md) .
+
+
+
+
+
+
+↓↓↓ Click to show details ↓↓↓
+
+| Language | Code Name |
+| ------------------- | ----------- |
+| Abaza | abq |
+| Adyghe | ady |
+| Afrikaans | af |
+| Angika | ang |
+| Arabic | ar |
+| Assamese | as |
+| Avar | ava |
+| Azerbaijani | az |
+| Belarusian | be |
+| Bulgarian | bg |
+| Bihari | bh |
+| Bhojpuri | bho |
+| Bengali | bn |
+| Bosnian | bs |
+| Simplified Chinese | ch_sim |
+| Traditional Chinese | ch_tra |
+| Chechen | che |
+| Czech | cs |
+| Welsh | cy |
+| Danish | da |
+| Dargwa | dar |
+| German | de |
+| English | en |
+| Spanish | es |
+| Estonian | et |
+| Persian (Farsi) | fa |
+| French | fr |
+| Irish | ga |
+| Goan Konkani | gom |
+| Hindi | hi |
+| Croatian | hr |
+| Hungarian | hu |
+| Indonesian | id |
+| Ingush | inh |
+| Icelandic | is |
+| Italian | it |
+| Japanese | ja |
+| Kabardian | kbd |
+| Kannada | kn |
+| Korean | ko |
+| Kurdish | ku |
+| Latin | la |
+| Lak | lbe |
+| Lezghian | lez |
+| Lithuanian | lt |
+| Latvian | lv |
+| Magahi | mah |
+| Maithili | mai |
+| Maori | mi |
+| Mongolian | mn |
+| Marathi | mr |
+| Malay | ms |
+| Maltese | mt |
+| Nepali | ne |
+| Newari | new |
+| Dutch | nl |
+| Norwegian | no |
+| Occitan | oc |
+| Pali | pi |
+| Polish | pl |
+| Portuguese | pt |
+| Romanian | ro |
+| Russian | ru |
+| Serbian (cyrillic) | rs_cyrillic |
+| Serbian (latin) | rs_latin |
+| Nagpuri | sck |
+| Slovak | sk |
+| Slovenian | sl |
+| Albanian | sq |
+| Swedish | sv |
+| Swahili | sw |
+| Tamil | ta |
+| Tabassaran | tab |
+| Telugu | te |
+| Thai | th |
+| Tajik | tjk |
+| Tagalog | tl |
+| Turkish | tr |
+| Uyghur | ug |
+| Ukranian | uk |
+| Urdu | ur |
+| Uzbek | uz |
+| Vietnamese | vi |
+
+
+> Ref: [Supported Languages](https://www.jaided.ai/easyocr/) .
+
+
+
+
+
+## Online Service
+
+Everyone can use the **[P2T Online Service](https://p2t.breezedeus.com)** for free, with a daily limit of 10,000 characters per account, which should be sufficient for normal use. *Please refrain from bulk API calls, as machine resources are limited, and this could prevent others from accessing the service.*
+
+Due to hardware constraints, the Online Service currently only supports **Simplified Chinese** and **English** languages. To try the models in other languages, please use the following **Online Demo**.
+
+## Online Demo 🤗
+
+You can also try the **[Online Demo](https://huggingface.co/spaces/breezedeus/Pix2Text-Demo)** to see the performance of **P2T** in various languages. However, the online demo operates on lower hardware specifications and may be slower. For Simplified Chinese or English images, it is recommended to use the **[P2T Online Service](https://p2t.breezedeus.com)**.
+
+## Examples
+
+See: [Pix2Text Online Documentation/Examples](https://pix2text.readthedocs.io/zh-cn/stable/examples_en/).
+
+## Usage
+
+See: [Pix2Text Online Documentation/Usage](https://pix2text.readthedocs.io/zh-cn/stable/usage/).
+
+## Models
+
+See: [Pix2Text Online Documentation/Models](https://pix2text.readthedocs.io/zh-cn/stable/models/).
+
+## Install
+
+Well, one line of command is enough if it goes well.
+
+```bash
+pip install pix2text
+```
+
+If you need to recognize languages other than **English** and **Simplified Chinese**, please use the following command to install additional packages:
+
+```bash
+pip install pix2text[multilingual]
+```
+
+If the installation is slow, you can specify an installation source, such as using the Aliyun source:
+
+```bash
+pip install pix2text -i https://mirrors.aliyun.com/pypi/simple
+```
+
+For more information, please refer to: [Pix2Text Online Documentation/Install](https://pix2text.readthedocs.io/zh-cn/stable/install/).
+
+## Command Line Tool
+
+See: [Pix2Text Online Documentation/Command Tool](https://pix2text.readthedocs.io/zh-cn/stable/command/).
+
+## HTTP Service
+
+See: [Pix2Text Online Documentation/Command Tool/Start Service](https://pix2text.readthedocs.io/zh-cn/stable/command/).
+
+
+## MacOS Desktop Application
+
+Please refer to [Pix2Text-Mac](https://github.com/breezedeus/Pix2Text-Mac) for installing the Pix2Text Desktop App for MacOS.
+
+
+
+
+
+
+
+[](https://discord.gg/GgD87WM8Tf)
+[](https://pepy.tech/project/pix2text)
+[](https://visitorbadge.io/status?path=https%3A%2F%2Fgithub.com%2Fbreezedeus%2FPix2Text)
+[](./LICENSE)
+[](https://badge.fury.io/py/pix2text)
+[](https://github.com/breezedeus/pix2text)
+[](https://github.com/breezedeus/pix2text)
+
+
+[](https://twitter.com/breezedeus)
+
+[📖 在线文档](https://pix2text.readthedocs.io) |
+[👩🏻💻 网页版](https://p2t.breezedeus.com) |
+[👨🏻💻 在线 Demo](https://huggingface.co/spaces/breezedeus/Pix2Text-Demo) |
+[💬 交流群](https://www.breezedeus.com/article/join-group)
+
+
+
+[English](./README.md) | 中文
+
+
+
+
+# Pix2Text (P2T)
+
+## Update 2025.07.25：发布 **V1.1.4**
+
+主要变更：
+
+- 数学公式检测（MFD）和数学公式识别（MFR）模型升级到 1.5 版本，所有默认配置、文档和示例均以 `mfd-1.5` 和 `mfr-1.5` 为标准模型。
+
+## Update 2025.04.15：分布 **V1.1.3**
+
+主要变更：
+
+- 支持基于 VLM 接口（具体参考 [LiteLLM 文档](https://docs.litellm.ai/docs/)）的 `VlmTableOCR` 和 `VlmTextFormulaOCR` 模型，可使用闭源 VLM 模型。安装命令：`pip install pix2text[vlm]`。
+ - 使用方式见 [tests/test_vlm.py](tests/test_vlm.py) 和 [tests/test_pix2text.py](tests/test_pix2text.py)。
+
+## Update 2024.11.17：发布 **V1.1.2**
+
+主要变更：
+
+* 版面分析模型加入 [DocLayout-YOLO](https://github.com/opendatalab/DocLayout-YOLO)，提升版面分析的准确性。
+
+## Update 2024.06.18：发布 **V1.1.1**
+
+主要变更：
+
+* 支持新的数学公式检测模型（MFD）：[breezedeus/pix2text-mfd](https://huggingface.co/breezedeus/pix2text-mfd) ([国内镜像](https://hf-mirror.com/breezedeus/pix2text-mfd))，公式检测精度获得较大提升。
+
+具体说明请见：[Pix2Text V1.1.1 发布，带来更好的数学公式检测模型 | Breezedeus.com](https://www.breezedeus.com/article/p2t-mfd-v1.1.1)。
+
+## Update 2024.04.28：发布 **V1.1**
+
+主要变更：
+
+* 加入了版面分析和表格识别模型，支持把复杂排版的图片转换为 Markdown 格式，示例见：[Pix2Text 在线文档/Examples](https://pix2text.readthedocs.io/zh-cn/stable/examples/)。
+* 支持把整个 PDF 文件转换为 Markdown 格式，示例见：[Pix2Text 在线文档/Examples](https://pix2text.readthedocs.io/zh-cn/stable/examples/)。
+* 加入了更丰富的接口，已有接口的参数也有所调整。
+* 上线了 [Pix2Text 在线文档](https://pix2text.readthedocs.io)。
+
+## Update 2024.02.26：发布 **V1.0**
+
+主要变更：
+
+* 数学公式识别（MFR）模型使用新架构，在新的数据集上训练，获得了 SOTA 的精度。具体说明请见：[Pix2Text V1.0 新版发布：最好的开源公式识别模型 | Breezedeus.com](https://www.breezedeus.com/article/p2t-v1.0)。
+
+了解更多：[RELEASE.md](docs/RELEASE.md) 。
+
+
+
+
+
+
+↓↓↓ Click to show details ↓↓↓
+
+
+| Language | Code Name |
+| ------------------- | ----------- |
+| Abaza | abq |
+| Adyghe | ady |
+| Afrikaans | af |
+| Angika | ang |
+| Arabic | ar |
+| Assamese | as |
+| Avar | ava |
+| Azerbaijani | az |
+| Belarusian | be |
+| Bulgarian | bg |
+| Bihari | bh |
+| Bhojpuri | bho |
+| Bengali | bn |
+| Bosnian | bs |
+| Simplified Chinese | ch_sim |
+| Traditional Chinese | ch_tra |
+| Chechen | che |
+| Czech | cs |
+| Welsh | cy |
+| Danish | da |
+| Dargwa | dar |
+| German | de |
+| English | en |
+| Spanish | es |
+| Estonian | et |
+| Persian (Farsi) | fa |
+| French | fr |
+| Irish | ga |
+| Goan Konkani | gom |
+| Hindi | hi |
+| Croatian | hr |
+| Hungarian | hu |
+| Indonesian | id |
+| Ingush | inh |
+| Icelandic | is |
+| Italian | it |
+| Japanese | ja |
+| Kabardian | kbd |
+| Kannada | kn |
+| Korean | ko |
+| Kurdish | ku |
+| Latin | la |
+| Lak | lbe |
+| Lezghian | lez |
+| Lithuanian | lt |
+| Latvian | lv |
+| Magahi | mah |
+| Maithili | mai |
+| Maori | mi |
+| Mongolian | mn |
+| Marathi | mr |
+| Malay | ms |
+| Maltese | mt |
+| Nepali | ne |
+| Newari | new |
+| Dutch | nl |
+| Norwegian | no |
+| Occitan | oc |
+| Pali | pi |
+| Polish | pl |
+| Portuguese | pt |
+| Romanian | ro |
+| Russian | ru |
+| Serbian (cyrillic) | rs_cyrillic |
+| Serbian (latin) | rs_latin |
+| Nagpuri | sck |
+| Slovak | sk |
+| Slovenian | sl |
+| Albanian | sq |
+| Swedish | sv |
+| Swahili | sw |
+| Tamil | ta |
+| Tabassaran | tab |
+| Telugu | te |
+| Thai | th |
+| Tajik | tjk |
+| Tagalog | tl |
+| Turkish | tr |
+| Uyghur | ug |
+| Ukranian | uk |
+| Urdu | ur |
+| Uzbek | uz |
+| Vietnamese | vi |
+
+
+> Ref: [Supported Languages](https://www.jaided.ai/easyocr/) .
+
+
+
+
+
+## P2T 网页版
+
+所有人都可以免费使用 **[P2T网页版](https://p2t.breezedeus.com)**，每人每天可以免费识别 10000 个字符，正常使用应该够用了。*请不要批量调用接口，机器资源有限，批量调用会导致其他人无法使用服务。*
+
+受限于机器资源，网页版当前只支持**简体中文和英文**，要尝试其他语言上的效果，请使用以下的**在线 Demo**。
+
+
+
+## 在线 Demo 🤗
+
+也可以使用 **[在线 Demo](https://huggingface.co/spaces/breezedeus/Pix2Text-Demo)**（无法科学上网可以使用 [国内镜像](https://hf.qhduan.com/spaces/breezedeus/Pix2Text-Demo)） 尝试 **P2T** 在不同语言上的效果。但在线 Demo 使用的硬件配置较低，速度会较慢。如果是简体中文或者英文图片，建议使用 **[P2T网页版](https://p2t.breezedeus.com)**。
+
+## 示例
+
+参见：[Pix2Text在线文档/示例](https://pix2text.readthedocs.io/zh-cn/stable/examples/)。
+
+## 使用说明
+
+参见：[Pix2Text在线文档/使用说明](https://pix2text.readthedocs.io/zh-cn/stable/usage/)。
+
+## 模型下载
+
+参见：[Pix2Text在线文档/模型](https://pix2text.readthedocs.io/zh-cn/stable/models/)。
+
+
+
+## 安装
+
+嗯，顺利的话一行命令即可。
+
+```bash
+pip install pix2text
+```
+
+如果需要识别**英文**与**简体中文**之外的文字，请使用以下命令安装额外的包：
+
+```bash
+pip install pix2text[multilingual]
+```
+
+安装速度慢的话，可以指定国内的安装源，如使用阿里云的安装源：
+
+```bash
+pip install pix2text -i https://mirrors.aliyun.com/pypi/simple
+```
+
+
+
+
+{: style="width:280px"}
+
+
+
+## 2. 支付宝打赏 (Alipay reward)
+
+通过**支付宝**给作者打赏。
+Give the author a reward through Alipay.
+
+
+{: style="width:280px"}
+
+
+
+## 3. Buy me a Coffee
+If you are not in mainland China, you can also support the author through:
+
+
+
+
+{: style="width:280px"}
+
+
+
+## 二、微信交流群
+
+扫码加小助手为好友，备注 `p2t`，小助手会定期统一邀请大家入群：
+
+
+{: style="width:270px"}
+
+
+正常情况小助手会定期邀请入群，但无法保证时间。如果期望尽快得到答复，可以加入上面的知识星球 [**P2T/CnOCR/CnSTD私享群**](https://t.zsxq.com/FEYZRJQ) 。
+
+
+## 三、Discord
+
+欢迎加入 [**Pix2Text Discord 服务器**](https://discord.gg/GgD87WM8Tf) 。
+
+Welcome to join [**Pix2Text Discord Server**](https://discord.gg/GgD87WM8Tf) .
+
+
+## 四、邮件 / Email
+
+**邮箱**：breezedeus AT gmail.com，看的不勤，除非其他方式联系不上。
+
+Email: breezedeus AT gmail.com .
diff --git a/docs/demo.md b/docs/demo.md
new file mode 100644
index 0000000000000000000000000000000000000000..95b43e7f7981d0cc256eb9095efc1ed6819e48d0
--- /dev/null
+++ b/docs/demo.md
@@ -0,0 +1,20 @@
+## P2T 网页版
+
+所有人都可以免费使用 **[P2T网页版](https://p2t.breezedeus.com)**，每人每天可以免费识别 10000 个字符，正常使用应该够用了。如果无法打开，请尝试科学上网。*请不要批量调用接口，机器资源有限，批量调用会导致其他人无法使用服务。*
+
+受限于机器资源，网页版当前只支持**简体中文和英文**，要尝试其他语言上的效果，请使用以下的**在线 Demo**。
+
+
+
+
+
+
+## 在线 Demo 🤗
+
+也可以使用 **[在线 Demo](https://huggingface.co/spaces/breezedeus/Pix2Text-Demo)**（无法科学上网可以使用 [国内镜像](https://hf.qhduan.com/spaces/breezedeus/Pix2Text-Demo)） 尝试 **P2T** 在不同语言上的效果。但在线 Demo 使用的硬件配置较低，速度会较慢。如果是简体中文或者英文图片，建议使用 **[P2T网页版](https://p2t.breezedeus.com)**。
+
+
+
+
+
+更多说明请参考 [Pix2Text 主页](https://www.breezedeus.com/article/pix2text_cn) 。
\ No newline at end of file
diff --git a/docs/examples.md b/docs/examples.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d37fb4f0a13c4dfa305a912fb1d55cdeac9feed
--- /dev/null
+++ b/docs/examples.md
@@ -0,0 +1,221 @@
+
+
+[English](examples_en.md) | 中文
+
+
+
+# 示例
+## 识别 PDF 文件，返回其 Markdown 格式
+
+对于 PDF 文件，可以使用函数 `.recognize_pdf()` 对整个文件或者指定页进行识别，并把结果输出为 Markdown 文件。如针对以下 PDF 文件 ([examples/test-doc.pdf](examples/test-doc.pdf))，
+调用方式如下：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = './examples/test-doc.pdf'
+p2t = Pix2Text.from_config()
+doc = p2t.recognize_pdf(img_fp, page_numbers=[0, 1])
+doc.to_markdown('output-md') # 导出的 Markdown 信息保存在 output-md 目录中
+```
+
+也可以使用命令行完成一样的功能，如下面命令使用了付费版模型（MFD + MFR + CnOCR 三个付费模型）进行识别：
+
+```bash
+p2t predict -l en,ch_sim --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --rec-kwargs '{"page_numbers": [0, 1]}' --resized-shape 768 --file-type pdf -i docs/examples/test-doc.pdf -o output-md --save-debug-res output-debug
+```
+
+识别结果见 [output-md/output.md](output-md/output.md)。
+
+
+{: style="width:600px"}
+
+
+调用方式如下：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = './examples/test-doc.pdf'
+p2t = Pix2Text.from_config()
+page = p2t.recognize_page(img_fp)
+page.to_markdown('output-page') # 导出的 Markdown 信息保存在 output-page 目录中
+```
+
+也可以使用命令行完成一样的功能，如下面命令使用了付费版模型（MFD + MFR + CnOCR 三个付费模型）进行识别：
+
+```bash
+p2t predict -l en,ch_sim --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --resized-shape 768 --file-type page -i docs/examples/page2.png -o output-page --save-debug-res output-debug-page
+```
+
+识别结果和 [output-md/output.md](output-md/output.md) 类似。
+
+## 识别既有公式又有文本的段落图片
+
+对于既有公式又有文本的段落图片，识别时不需要使用版面分析模型。
+可以使用函数 `.recognize_text_formula()` 识别图片中的文字和数学公式。如针对以下图片 ([examples/en1.jpg](examples/en1.jpg))：
+
+
+{: style="width:600px"}
+
+
+调用方式如下：
+
+```python
+from pix2text import Pix2Text, merge_line_texts
+
+img_fp = './examples/en1.jpg'
+p2t = Pix2Text.from_config()
+outs = p2t.recognize_text_formula(img_fp, resized_shape=768, return_text=True)
+print(outs)
+```
+
+返回结果 `outs` 是个 `dict`，其中 key `position` 表示Box位置信息，`type` 表示类别信息，而 `text` 表示识别的结果。具体说明见[接口说明](#接口说明)。
+
+也可以使用命令行完成一样的功能，如下面命令使用了付费版模型（MFD + MFR + CnOCR 三个付费模型）进行识别：
+
+```bash
+p2t predict -l en,ch_sim --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --resized-shape 768 --file-type text_formula -i docs/examples/en1.jpg --save-debug-res out-debug-en1.jpg
+```
+
+或者使用免费开源模型进行识别：
+
+```bash
+p2t predict -l en,ch_sim --resized-shape 768 --file-type text_formula -i docs/examples/en1.jpg --save-debug-res out-debug-en1.jpg
+```
+
+## 识别纯公式图片
+
+对于只包含数学公式的图片，使用函数 `.recognize_formula()` 可以把数学公式识别为 LaTeX 表达式。如针对以下图片 ([examples/math-formula-42.png](examples/math-formula-42.png))：
+
+
+{: style="width:300px"}
+
+
+
+调用方式如下：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = './examples/math-formula-42.png'
+p2t = Pix2Text.from_config()
+outs = p2t.recognize_formula(img_fp)
+print(outs)
+```
+
+返回结果为字符串，即对应的 LaTeX 表达式。具体说明见[说明](usage.md)。
+
+也可以使用命令行完成一样的功能，如下面命令使用了付费版模型（MFR 一个付费模型）进行识别：
+
+```bash
+p2t predict -l en,ch_sim --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --file-type formula -i docs/examples/math-formula-42.png
+```
+
+或者使用免费开源模型进行识别：
+
+```bash
+p2t predict -l en,ch_sim --file-type formula -i docs/examples/math-formula-42.png
+```
+
+## 识别纯文字图片
+
+对于只包含文字不包含数学公式的图片，使用函数 `.recognize_text()` 可以识别出图片中的文字。此时 Pix2Text 相当于一般的文字 OCR 引擎。如针对以下图片 ([examples/general.jpg](examples/general.jpg))：
+
+
+{: style="width:400px"}
+
+
+
+调用方式如下：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = './examples/general.jpg'
+p2t = Pix2Text.from_config()
+outs = p2t.recognize_text(img_fp)
+print(outs)
+```
+
+返回结果为字符串，即对应的文字序列。具体说明见[接口说明](https://pix2text.readthedocs.io/zh-cn/latest/pix2text/pix_to_text/)。
+
+也可以使用命令行完成一样的功能，如下面命令使用了付费版模型（CnOCR 一个付费模型）进行识别：
+
+```bash
+p2t predict -l en,ch_sim --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --file-type text --no-return-text -i docs/examples/general.jpg --save-debug-res out-debug-general.jpg
+```
+
+或者使用免费开源模型进行识别：
+
+```bash
+p2t predict -l en,ch_sim --file-type text --no-return-text -i docs/examples/general.jpg --save-debug-res out-debug-general.jpg
+```
+
+
+## 针对不同语言
+
+### 英文
+
+**识别效果**：
+
+
+
+**识别命令**：
+
+```bash
+p2t predict -l en --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --resized-shape 768 --file-type text_formula -i docs/examples/en1.jpg
+```
+
+### 简体中文
+
+**识别效果**：
+
+
+
+**识别命令**：
+
+```bash
+p2t predict -l en,ch_sim --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --resized-shape 768 --auto-line-break --file-type text_formula -i docs/examples/mixed.jpg --save-debug-res out-debug-mixed.jpg
+```
+
+### 繁体中文
+
+**识别效果**：
+
+
+
+**识别命令**：
+
+```bash
+p2t predict -l en,ch_tra --mfd-config '{"model_name": "mfd-pro", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --resized-shape 768 --auto-line-break --file-type text_formula -i docs/examples/ch_tra.jpg --save-debug-res out-debug-tra.jpg
+```
+
+> 注意 ⚠️ ：请通过以下命令安装 pix2text 的多语言版本：
+> ```bash
+> pip install pix2text[multilingual]
+> ```
+
+
+### 越南语
+**识别效果**：
+
+
+
+**识别命令**：
+
+```bash
+p2t predict -l en,vi --mfd-config '{"model_name": "mfd-pro", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro","model_backend":"onnx"}' --resized-shape 608 --no-auto-line-break --file-type text_formula -i docs/examples/vietnamese.jpg --save-debug-res out-debug-vi.jpg
+```
+
+> 注意 ⚠️ ：请通过以下命令安装 pix2text 的多语言版本：
+> ```bash
+> pip install pix2text[multilingual]
+> ```
diff --git a/docs/examples/test-doc.pdf b/docs/examples/test-doc.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..9deeb4c32963c21df2d3b9349a4d1cf71ba8af87
--- /dev/null
+++ b/docs/examples/test-doc.pdf
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:746024d672224466f2fbcc46385afe71e186b3d6542ae4c7132f7fd9aac36ac7
+size 1631522
diff --git a/docs/examples_en.md b/docs/examples_en.md
new file mode 100644
index 0000000000000000000000000000000000000000..4ddd20a7330aac9d7f626347196e9a7e3bcf6826
--- /dev/null
+++ b/docs/examples_en.md
@@ -0,0 +1,219 @@
+
+
+[中文](examples.md) | English
+
+
+
+# Examples
+## Recognize PDF Files and Return Markdown Format
+
+For PDF files, you can use the `.recognize_pdf()` function to recognize the entire file or specific pages and output the results as a Markdown file. For example, for the following PDF file ([examples/test-doc.pdf](examples/test-doc.pdf)),
+you can call the function like this:
+
+```python
+from pix2text import Pix2Text
+
+img_fp = './examples/test-doc.pdf'
+p2t = Pix2Text.from_config()
+doc = p2t.recognize_pdf(img_fp, page_numbers=[0, 1])
+doc.to_markdown('output-md') # The exported Markdown information is saved in the output-md directory
+```
+
+You can also achieve the same functionality using the command line. Below is a command that uses the premium models (MFD + MFR + CnOCR) for recognition:
+
+```bash
+p2t predict -l en,ch_sim --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --rec-kwargs '{"page_numbers": [0, 1]}' --resized-shape 768 --file-type pdf -i docs/examples/test-doc.pdf -o output-md --save-debug-res output-debug
+```
+
+The recognition result can be found in [output-md/output.md](output-md/output.md).
+
+
+{: style="width:600px"}
+
+
+You can call the function like this:
+
+```python
+from pix2text import Pix2Text
+
+img_fp = './examples/test-doc.pdf'
+p2t = Pix2Text.from_config()
+page = p2t.recognize_page(img_fp)
+page.to_markdown('output-page') # The exported Markdown information is saved in the output-page directory
+```
+
+You can also achieve the same functionality using the command line. Below is a command that uses the premium models (MFD + MFR + CnOCR) for recognition:
+
+```bash
+p2t predict -l en,ch_sim --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --resized-shape 768 --file-type page -i docs/examples/page2.png -o output-page --save-debug-res output-debug-page
+```
+
+The recognition result is similar to [output-md/output.md](output-md/output.md).
+
+
+## Recognize Paragraph Images with Both Formulas and Texts
+
+For paragraph images containing both formulas and texts, you don't need to use the layout analysis model. You can use the `.recognize_text_formula()` function to recognize both texts and mathematical formulas in the image. For example, for the following image ([examples/en1.jpg](examples/en1.jpg)):
+
+
+{: style="width:600px"}
+
+
+You can call the function like this:
+
+```python
+from pix2text import Pix2Text, merge_line_texts
+
+img_fp = './examples/en1.jpg'
+p2t = Pix2Text.from_config()
+outs = p2t.recognize_text_formula(img_fp, resized_shape=768, return_text=True)
+print(outs)
+```
+
+The returned result `outs` is a dictionary, where the key `position` represents the box position information, `type` represents the category information, and `text` represents the recognition result. For detailed explanations, see [API Documentation](#api-documentation).
+
+You can also achieve the same functionality using the command line. Below is a command that uses the premium models (MFD + MFR + CnOCR) for recognition:
+
+```bash
+p2t predict -l en,ch_sim --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --resized-shape 768 --file-type text_formula -i docs/examples/en1.jpg --save-debug-res out-debug-en1.jpg
+```
+
+Or use the free open-source models for recognition:
+
+```bash
+p2t predict -l en,ch_sim --resized-shape 768 --file-type text_formula -i docs/examples/en1.jpg --save-debug-res out-debug-en1.jpg
+```
+
+## Recognize Pure Formula Images
+
+For images containing only mathematical formulas, you can use the `.recognize_formula()` function to recognize the formulas as LaTeX expressions. For example, for the following image ([examples/math-formula-42.png](examples/math-formula-42.png)):
+
+
+{: style="width:300px"}
+
+
+You can call the function like this:
+
+```python
+from pix2text import Pix2Text
+
+img_fp = './examples/math-formula-42.png'
+p2t = Pix2Text.from_config()
+outs = p2t.recognize_formula(img_fp)
+print(outs)
+```
+
+The returned result is a string representing the corresponding LaTeX expression. For detailed explanations, see [Usage](usage.md).
+
+You can also achieve the same functionality using the command line. Below is a command that uses the premium model (MFR) for recognition:
+
+```bash
+p2t predict -l en,ch_sim --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --file-type formula -i docs/examples/math-formula-42.png
+```
+
+Or use the free open-source model for recognition:
+
+```bash
+p2t predict -l en,ch_sim --file-type formula -i docs/examples/math-formula-42.png
+```
+
+## Recognize Pure Text Images
+
+For images containing only text without mathematical formulas, you can use the `.recognize_text()` function to recognize the text in the image. In this case, Pix2Text acts as a general text OCR engine. For example, for the following image ([examples/general.jpg](examples/general.jpg)):
+
+
+{: style="width:400px"}
+
+
+You can call the function like this:
+
+```python
+from pix2text import Pix2Text
+
+img_fp = './examples/general.jpg'
+p2t = Pix2Text.from_config()
+outs = p2t.recognize_text(img_fp)
+print(outs)
+```
+
+The returned result is a string representing the corresponding text sequence. For detailed explanations, see [API Documentation](https://pix2text.readthedocs.io/zh-cn/latest/pix2text/pix_to_text/).
+
+You can also achieve the same functionality using the command line. Below is a command that uses the premium model (CnOCR) for recognition:
+
+```bash
+p2t predict -l en,ch_sim --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --file-type text --no-return-text -i docs/examples/general.jpg --save-debug-res out-debug-general.jpg
+```
+
+Or use the free open-source model for recognition:
+
+```bash
+p2t predict -l en,ch_sim --file-type text --no-return-text -i docs/examples/general.jpg --save-debug-res out-debug-general.jpg
+```
+
+## For Different Languages
+
+### English
+
+**Recognition Result**:
+
+
+
+**Recognition Command**:
+
+```bash
+p2t predict -l en --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --resized-shape 768 --file-type text_formula -i docs/examples/en1.jpg
+```
+
+### Simplified Chinese
+
+**Recognition Result**:
+
+
+
+**Recognition Command**:
+
+```bash
+p2t predict -l en,ch_sim --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --text-ocr-config '{"rec_model_name": "doc-densenet_lite_666-gru_large"}' --resized-shape 768 --auto-line-break --file-type text_formula -i docs/examples/mixed.jpg --save-debug-res out-debug-mixed.jpg
+```
+
+### Traditional Chinese
+
+**Recognition Result**:
+
+
+
+**Recognition Command**:
+
+```bash
+p2t predict -l en,ch_tra --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --resized-shape 768 --auto-line-break --file-type text_formula -i docs/examples/ch_tra.jpg --save-debug-res out-debug-tra.jpg
+```
+
+> Note ⚠️: Please install the multilingual version of pix2text using the following command:
+> ```bash
+> pip install pix2text[multilingual]
+> ```
+
+### Vietnamese
+
+**Recognition Result**:
+
+
+
+**Recognition Command**:
+
+```bash
+p2t predict -l en,vi --mfd-config '{"model_name": "mfd-pro-1.5", "model_backend": "onnx"}' --formula-ocr-config '{"model_name":"mfr-pro-1.5","model_backend":"onnx"}' --resized-shape 608 --no-auto-line-break --file-type text_formula -i docs/examples/vietnamese.jpg --save-debug-res out-debug-vi.jpg
+```
+
+> Note ⚠️: Please install the multilingual version of pix2text using the following command:
+> ```bash
+> pip install pix2text[multilingual]
+> ```
\ No newline at end of file
diff --git a/docs/faq.md b/docs/faq.md
new file mode 100644
index 0000000000000000000000000000000000000000..48ef9733506d912ab77976e2ff5caabab4854b56
--- /dev/null
+++ b/docs/faq.md
@@ -0,0 +1,8 @@
+# 常见问题（FAQ）
+
+## Pix2Text 是免费的吗？
+
+Pix2Text 代码和基础模型是免费的，而且是开源的。可以按需自行调整发布或商业使用。
+
+但请注意，Pix2Text 的不同付费模型包含不同的 license，购买时请参考具体的 license 说明。
+
diff --git a/docs/figs/breezedeus.ico b/docs/figs/breezedeus.ico
new file mode 100644
index 0000000000000000000000000000000000000000..b070848947e791d69303f4dafc18a36a2ec740c1
Binary files /dev/null and b/docs/figs/breezedeus.ico differ
diff --git a/docs/index.md b/docs/index.md
new file mode 100644
index 0000000000000000000000000000000000000000..f5cae58d90c3a079049c2d13aa121280273be508
--- /dev/null
+++ b/docs/index.md
@@ -0,0 +1,263 @@
+
+{: style="width:180px"}
+
+
+# Pix2Text (P2T)
+[](https://discord.gg/GgD87WM8Tf)
+[](https://pepy.tech/project/pix2text)
+[](https://visitorbadge.io/status?path=https%3A%2F%2Fpix2text.readthedocs.io%2Fzh-cn%2Fstable%2F)
+[](./LICENSE)
+[](https://badge.fury.io/py/pix2text)
+[](https://github.com/breezedeus/pix2text)
+[](https://github.com/breezedeus/pix2text)
+
+
+[](https://twitter.com/breezedeus)
+
+
+[📖 使用](usage.md) |
+[🛠️ 安装](install.md) |
+[🧳 模型](models.md) |
+[🛀🏻 在线Demo](demo.md) |
+[💬 交流群](contact.md)
+
+[English](index_en.md) | 中文
+
+
+**Pix2Text (P2T)** 期望成为 **[Mathpix](https://mathpix.com/)** 的**免费开源 Python** 替代工具，目前已经可以完成 **Mathpix** 的核心功能。
+**Pix2Text (P2T) 可以识别图片中的版面、表格、图片、文字、数学公式等内容，并整合所有内容后以 Markdown 格式输出。P2T 也可以把一整个 PDF 文件（PDF 的内容可以是扫描图片或者其他任何格式）转换为 Markdown 格式。**
+
+**Pix2Text (P2T)** 整合了以下模型：
+
+- **版面分析模型**：[breezedeus/pix2text-layout-docyolo](https://huggingface.co/breezedeus/pix2text-layout-docyolo) （[国内镜像](https://hf-mirror.com/breezedeus/pix2text-layout-docyolo)）。
+- **表格识别模型**：[breezedeus/pix2text-table-rec](https://huggingface.co/breezedeus/pix2text-table-rec) （[国内镜像](https://hf-mirror.com/breezedeus/pix2text-table-rec)）。
+- **文字识别引擎**：支持 **`80+` 种语言**，如**英文、简体中文、繁体中文、越南语**等。其中，**英文**和**简体中文**识别使用的是开源 OCR 工具 [CnOCR](https://github.com/breezedeus/cnocr) ，其他语言的识别使用的是开源 OCR 工具 [EasyOCR](https://github.com/JaidedAI/EasyOCR) 。
+- **数学公式检测模型（MFD）**：[breezedeus/pix2text-mfd-1.5](https://huggingface.co/breezedeus/pix2text-mfd-1.5) （[国内镜像](https://hf-mirror.com/breezedeus/pix2text-mfd-1.5)）。基于 [CnSTD](https://github.com/breezedeus/cnstd) 实现。
+- **数学公式识别模型（MFR）**：[breezedeus/pix2text-mfr-1.5](https://huggingface.co/breezedeus/pix2text-mfr-1.5) （[国内镜像](https://hf-mirror.com/breezedeus/pix2text-mfr-1.5)）。
+
+其中多个模型来自其他开源作者， 非常感谢他们的贡献。
+
+
+
+
+
+
+↓↓↓ Click to show details ↓↓↓
+
+| Language | Code Name |
+| ------------------- | ----------- |
+| Abaza | abq |
+| Adyghe | ady |
+| Afrikaans | af |
+| Angika | ang |
+| Arabic | ar |
+| Assamese | as |
+| Avar | ava |
+| Azerbaijani | az |
+| Belarusian | be |
+| Bulgarian | bg |
+| Bihari | bh |
+| Bhojpuri | bho |
+| Bengali | bn |
+| Bosnian | bs |
+| Simplified Chinese | ch_sim |
+| Traditional Chinese | ch_tra |
+| Chechen | che |
+| Czech | cs |
+| Welsh | cy |
+| Danish | da |
+| Dargwa | dar |
+| German | de |
+| English | en |
+| Spanish | es |
+| Estonian | et |
+| Persian (Farsi) | fa |
+| French | fr |
+| Irish | ga |
+| Goan Konkani | gom |
+| Hindi | hi |
+| Croatian | hr |
+| Hungarian | hu |
+| Indonesian | id |
+| Ingush | inh |
+| Icelandic | is |
+| Italian | it |
+| Japanese | ja |
+| Kabardian | kbd |
+| Kannada | kn |
+| Korean | ko |
+| Kurdish | ku |
+| Latin | la |
+| Lak | lbe |
+| Lezghian | lez |
+| Lithuanian | lt |
+| Latvian | lv |
+| Magahi | mah |
+| Maithili | mai |
+| Maori | mi |
+| Mongolian | mn |
+| Marathi | mr |
+| Malay | ms |
+| Maltese | mt |
+| Nepali | ne |
+| Newari | new |
+| Dutch | nl |
+| Norwegian | no |
+| Occitan | oc |
+| Pali | pi |
+| Polish | pl |
+| Portuguese | pt |
+| Romanian | ro |
+| Russian | ru |
+| Serbian (cyrillic) | rs_cyrillic |
+| Serbian (latin) | rs_latin |
+| Nagpuri | sck |
+| Slovak | sk |
+| Slovenian | sl |
+| Albanian | sq |
+| Swedish | sv |
+| Swahili | sw |
+| Tamil | ta |
+| Tabassaran | tab |
+| Telugu | te |
+| Thai | th |
+| Tajik | tjk |
+| Tagalog | tl |
+| Turkish | tr |
+| Uyghur | ug |
+| Ukranian | uk |
+| Urdu | ur |
+| Uzbek | uz |
+| Vietnamese | vi |
+
+> Ref: [Supported Languages](https://www.jaided.ai/easyocr/) .
+
+
+
+
+
+## P2T 网页版
+
+所有人都可以免费使用 **[P2T网页版](https://p2t.breezedeus.com)**，每人每天可以免费识别 10000 个字符，正常使用应该够用了。*请不要批量调用接口，机器资源有限，批量调用会导致其他人无法使用服务。*
+
+受限于机器资源，网页版当前只支持**简体中文和英文**，要尝试其他语言上的效果，请使用以下的**在线 Demo**。
+
+
+
+## 在线 Demo 🤗
+
+也可以使用 **[在线 Demo](https://huggingface.co/spaces/breezedeus/Pix2Text-Demo)**（无法科学上网可以使用 [国内镜像](https://hf.qhduan.com/spaces/breezedeus/Pix2Text-Demo)） 尝试 **P2T** 在不同语言上的效果。但在线 Demo 使用的硬件配置较低，速度会较慢。如果是简体中文或者英文图片，建议使用 **[P2T网页版](https://p2t.breezedeus.com)**。
+
+
+## 安装
+
+嗯，顺利的话一行命令即可。
+
+```bash
+pip install pix2text
+```
+
+如果需要识别**英文**与**简体中文**之外的文字，请使用以下命令安装额外的包：
+
+```bash
+pip install pix2text[multilingual]
+```
+
+安装速度慢的话，可以指定国内的安装源，如使用阿里云的安装源：
+
+```bash
+pip install pix2text -i https://mirrors.aliyun.com/pypi/simple
+```
+
+如果是初次使用**OpenCV**，那估计安装都不会很顺利，bless。
+
+**Pix2Text** 主要依赖 [**CnSTD>=1.2.4**](https://github.com/breezedeus/cnstd)、[**CnOCR>=2.3**](https://github.com/breezedeus/cnocr) ，以及 [**transformers>=4.37.0**](https://github.com/huggingface/transformers) 。如果安装过程遇到问题，也可参考它们的安装说明文档。
+
+> **Warning**
+>
+> 如果电脑中从未安装过 `PyTorch`，`OpenCV` python包，初次安装可能会遇到不少问题，但一般都是常见问题，可以自行百度/Google解决。
+
+更多说明参考 [安装说明](install.md) 。
+
+
+## 使用说明
+
+参见：[使用说明](usage.md)。
+
+## 示例
+
+参见：[示例](examples.md)。
+
+## 模型下载
+
+参见：[模型](models.md)。
+
+## 命令行工具
+
+参见：[命令行工具](command.md)。
+
+
+## HTTP 服务
+
+使用命令 **`p2t serve`** 开启一个 HTTP 服务，用于接收图片（当前不支持 PDF）并返回识别结果。
+
+```bash
+p2t serve -l en,ch_sim -H 0.0.0.0 -p 8503
+```
+
+之后可以使用 curl 调用服务：
+
+```bash
+curl -X POST \
+ -F "file_type=page" \
+ -F "resized_shape=768" \
+ -F "embed_sep= $,$ " \
+ -F "isolated_sep=$$\n, \n$$" \
+ -F "image=@docs/examples/page2.png;type=image/jpeg" \
+ http://0.0.0.0:8503/pix2text
+```
+
+更多说明参考 [命令说明/开启服务](command.md) 。
+
+## Mac 桌面客户端
+
+请参考 [Pix2Text-Mac](https://github.com/breezedeus/Pix2Text-Mac) 安装 Pix2Text 的 MacOS 桌面客户端。
+
+
+
+
+{: style="width:180px"}
+
+
+# Pix2Text (P2T)
+[](https://discord.gg/GgD87WM8Tf)
+[](https://pepy.tech/project/pix2text)
+[](https://visitorbadge.io/status?path=https%3A%2F%2Fpix2text.readthedocs.io%2Fzh-cn%2Fstable%2F)
+[](./LICENSE)
+[](https://badge.fury.io/py/pix2text)
+[](https://github.com/breezedeus/pix2text)
+[](https://github.com/breezedeus/pix2text)
+
+
+[](https://twitter.com/breezedeus)
+
+
+[📖 Usage](usage.md) |
+[🛠️ Install](install.md) |
+[🧳 Models](models.md) |
+[🛀🏻 Demo](demo.md) |
+[💬 Contact](contact.md)
+
+[中文](index.md) | English
+
+
+**Pix2Text (P2T)** aims to be a **free and open-source Python** alternative to **[Mathpix](https://mathpix.com/)**, and it can already accomplish **Mathpix**'s core functionality. **Pix2Text (P2T) can recognize layouts, tables, images, text, mathematical formulas, and integrate all of these contents into Markdown format. P2T can also convert an entire PDF file (which can contain scanned images or any other format) into Markdown format.**
+
+**Pix2Text (P2T)** integrates the following models:
+
+- **Layout Analysis Model**: [breezedeus/pix2text-layout-docyolo](https://huggingface.co/breezedeus/pix2text-layout-docyolo) ([Mirror](https://hf-mirror.com/breezedeus/pix2text-layout-docyolo)).
+- **Table Recognition Model**: [breezedeus/pix2text-table-rec](https://huggingface.co/breezedeus/pix2text-table-rec) ([Mirror](https://hf-mirror.com/breezedeus/pix2text-table-rec)).
+- **Text Recognition Engine**: Supports **80+ languages** such as **English, Simplified Chinese, Traditional Chinese, Vietnamese**, etc. For English and Simplified Chinese recognition, it uses the open-source OCR tool [CnOCR](https://github.com/breezedeus/cnocr), while for other languages, it uses the open-source OCR tool [EasyOCR](https://github.com/JaidedAI/EasyOCR).
+- **Mathematical Formula Detection Model (MFD)**: [breezedeus/pix2text-mfd-1.5](https://huggingface.co/breezedeus/pix2text-mfd-1.5) ([Mirror](https://hf-mirror.com/breezedeus/pix2text-mfd-1.5)). Implemented based on [CnSTD](https://github.com/breezedeus/cnstd).
+- **Mathematical Formula Recognition Model (MFR)**: [breezedeus/pix2text-mfr-1.5](https://huggingface.co/breezedeus/pix2text-mfr-1.5) ([Mirror](https://hf-mirror.com/breezedeus/pix2text-mfr-1.5)).
+
+Several models are contributed by other open-source authors, and their contributions are highly appreciated.
+
+
+
+
+
+For detailed explanations, please refer to the [Models](models.md).
+
+As a Python3 toolkit, P2T may not be very user-friendly for those who are not familiar with Python. Therefore, we also provide a **[free-to-use P2T Online Web](https://p2t.breezedeus.com)**, where you can directly upload images and get P2T parsing results. The web version uses the latest models, resulting in better performance compared to the open-source models.
+
+Welcome to join [**Pix2Text Discord Server**](https://discord.gg/GgD87WM8Tf), if you have any questions or suggestions.
+
+If you're interested, feel free to add the WeChat assistant as a friend by scanning the QR code and mentioning `p2t`. The assistant will regularly invite everyone to join the group where the latest developments related to P2T tools will be announced:
+
+
+{: style="width:300px"}
+
+
+The author also maintains a **Knowledge Planet** [**P2T/CnOCR/CnSTD Private Group**](https://t.zsxq.com/FEYZRJQ), where questions are answered promptly. You're welcome to join. The **knowledge planet private group** will also gradually release some private materials related to P2T/CnOCR/CnSTD, including **some unreleased models**, **discounts on purchasing premium models**, **code snippets for different application scenarios**, and answers to difficult problems encountered during use. The planet will also publish the latest research materials related to P2T/OCR/STD.
+
+For more contact method, please refer to [Contact](contact.md).
+
+
+## List of Supported Languages
+
+The text recognition engine of Pix2Text supports **`80+` languages**, including **English, Simplified Chinese, Traditional Chinese, Vietnamese**, etc. Among these, **English** and **Simplified Chinese** recognition utilize the open-source OCR tool **[CnOCR](https://github.com/breezedeus/cnocr)**, while recognition for other languages employs the open-source OCR tool **[EasyOCR](https://github.com/JaidedAI/EasyOCR)**. Special thanks to the respective authors.
+
+List of **Supported Languages** and **Language Codes** are shown below:
+
+
+↓↓↓ Click to show details ↓↓↓
+
+| Language | Code Name |
+| ------------------- | ----------- |
+| Abaza | abq |
+| Adyghe | ady |
+| Afrikaans | af |
+| Angika | ang |
+| Arabic | ar |
+| Assamese | as |
+| Avar | ava |
+| Azerbaijani | az |
+| Belarusian | be |
+| Bulgarian | bg |
+| Bihari | bh |
+| Bhojpuri | bho |
+| Bengali | bn |
+| Bosnian | bs |
+| Simplified Chinese | ch_sim |
+| Traditional Chinese | ch_tra |
+| Chechen | che |
+| Czech | cs |
+| Welsh | cy |
+| Danish | da |
+| Dargwa | dar |
+| German | de |
+| English | en |
+| Spanish | es |
+| Estonian | et |
+| Persian (Farsi) | fa |
+| French | fr |
+| Irish | ga |
+| Goan Konkani | gom |
+| Hindi | hi |
+| Croatian | hr |
+| Hungarian | hu |
+| Indonesian | id |
+| Ingush | inh |
+| Icelandic | is |
+| Italian | it |
+| Japanese | ja |
+| Kabardian | kbd |
+| Kannada | kn |
+| Korean | ko |
+| Kurdish | ku |
+| Latin | la |
+| Lak | lbe |
+| Lezghian | lez |
+| Lithuanian | lt |
+| Latvian | lv |
+| Magahi | mah |
+| Maithili | mai |
+| Maori | mi |
+| Mongolian | mn |
+| Marathi | mr |
+| Malay | ms |
+| Maltese | mt |
+| Nepali | ne |
+| Newari | new |
+| Dutch | nl |
+| Norwegian | no |
+| Occitan | oc |
+| Pali | pi |
+| Polish | pl |
+| Portuguese | pt |
+| Romanian | ro |
+| Russian | ru |
+| Serbian (cyrillic) | rs_cyrillic |
+| Serbian (latin) | rs_latin |
+| Nagpuri | sck |
+| Slovak | sk |
+| Slovenian | sl |
+| Albanian | sq |
+| Swedish | sv |
+| Swahili | sw |
+| Tamil | ta |
+| Tabassaran | tab |
+| Telugu | te |
+| Thai | th |
+| Tajik | tjk |
+| Tagalog | tl |
+| Turkish | tr |
+| Uyghur | ug |
+| Ukranian | uk |
+| Urdu | ur |
+| Uzbek | uz |
+| Vietnamese | vi |
+
+
+> Ref: [Supported Languages](https://www.jaided.ai/easyocr/) .
+
+
+
+
+## Online Service
+
+Everyone can use the **[P2T Online Service](https://p2t.breezedeus.com)** for free, with a daily limit of 10,000 characters per account, which should be sufficient for normal use. *Please refrain from bulk API calls, as machine resources are limited, and this could prevent others from accessing the service.*
+
+Due to hardware constraints, the Online Service currently only supports **Simplified Chinese** and **English** languages. To try the models in other languages, please use the following **Online Demo**.
+
+
+
+## Online Demo 🤗
+
+You can also try the **[Online Demo](https://huggingface.co/spaces/breezedeus/Pix2Text-Demo)** ([Mirror](https://hf-mirror.com/spaces/breezedeus/Pix2Text-Demo)) to see the performance of **P2T** in various languages. However, the online demo operates on lower hardware specifications and may be slower. For Simplified Chinese or English images, it is recommended to use the **[P2T Online Service](https://p2t.breezedeus.com)**.
+
+
+## Install
+
+Well, one line of command is enough if it goes well.
+
+```bash
+pip install pix2text
+```
+
+If you need to recognize languages other than **English** and **Simplified Chinese**, please use the following command to install additional packages:
+
+```bash
+pip install pix2text[multilingual]
+```
+
+
+
+If the installation is slow, you can specify a domestic installation source, such as using the Aliyun source:
+
+```bash
+pip install pix2text -i https://mirrors.aliyun.com/pypi/simple
+```
+
+
+If it is your first time to use **OpenCV**, then probably the installation will not be very easy. Bless.
+
+**Pix2Text** mainly depends on [**CnSTD>=1.2.1**](https://github.com/breezedeus/cnstd), [**CnOCR>=2.2.2.1**](https://github.com/breezedeus/cnocr), and [**transformers>=4.37.0**](https://github.com/huggingface/transformers). If you encounter problems with the installation, you can also refer to their installation instruction documentations.
+
+
+> **Warning**
+>
+> If you have never installed the `PyTorch`, `OpenCV` python packages before, you may encounter a lot of problems during the first installation, but they are usually common problems that can be solved by Baidu/Google.
+
+For more instructions, please refer to [Install](install.md) .
+
+## Usage
+
+Refer to: [Usage](usage.md).
+
+## Examples
+
+Refer to: [Examples](examples.md).
+
+## Model Downloads
+
+Refer to: [Models](models.md).
+
+## Command Line Tools
+
+Refer to: [Command Line Tools](command.md).
+
+## HTTP Service
+
+To start an HTTP service for receiving images (currently does not support PDF) and returning recognition results, use the command **`p2t serve`**.
+
+```bash
+p2t serve -l en,ch_sim -H 0.0.0.0 -p 8503
+```
+
+Afterwards, you can call the service using curl:
+
+```bash
+curl -X POST \
+ -F "file_type=page" \
+ -F "resized_shape=768" \
+ -F "embed_sep= $,$ " \
+ -F "isolated_sep=$$\n, \n$$" \
+ -F "image=@docs/examples/page2.png;type=image/jpeg" \
+ http://0.0.0.0:8503/pix2text
+```
+
+For more information, refer to [Command/Starting the Service](command.md).
+
+## MacOS Desktop Application
+
+Please refer to [Pix2Text-Mac](https://github.com/breezedeus/Pix2Text-Mac) for installing the Pix2Text Desktop App for MacOS.
+
+
+
+
\AppData\Roaming\pix2text\1.1\layout-parser`）目录下即可，目录不存在的话请自己创建。
+
+> 注：上面路径的 `1.1` 是 pix2text 的版本号，`1.1.*` 都对应 `1.1`。如果是其他版本请自行替换。
+
+## 表格识别模型
+**表格识别模型** 下载地址：[breezedeus/pix2text-table-rec](https://huggingface.co/breezedeus/pix2text-table-rec) （不能科学上网请使用 [国内镜像](https://hf-mirror.com/breezedeus/pix2text-table-rec)）。
+把这里面的所有文件都下载到 `~/.pix2text/1.1/table-rec` （Windows 系统放在 `C:\Users\\AppData\Roaming\pix2text\1.1\table-rec`）目录下即可，目录不存在的话请自己创建。
+
+> 注：上面路径的 `1.1` 是 pix2text 的版本号，`1.1.*` 都对应 `1.1`。如果是其他版本请自行替换。
+
+## 数学公式检测模型（MFD）
+### `pix2text >= 1.1.1`
+Pix2Text 自 **V1.1.1** 开始，**数学公式检测模型** 下载地址：[breezedeus/pix2text-mfd](https://huggingface.co/breezedeus/pix2text-mfd) （不能科学上网请使用 [国内镜像](https://hf-mirror.com/breezedeus/pix2text-mfd)）。
+
+### `pix2text < 1.1.1`
+**数学公式检测模型**（MFD）来自 [CnSTD](https://github.com/breezedeus/cnstd) 的数学公式检测模型（MFD），请参考其代码库说明。
+
+如果系统无法自动成功下载模型文件，则需要手动从 [**cnstd-cnocr-models**](https://huggingface.co/breezedeus/cnstd-cnocr-models) （[国内镜像](https://hf-mirror.com/breezedeus/cnstd-cnocr-models)）项目中下载，或者从[百度云盘](https://pan.baidu.com/s/1zDMzArCDrrXHWL0AWxwYQQ?pwd=nstd)（提取码为 `nstd`）下载对应的zip文件并把它存放于 `~/.cnstd/1.2`（Windows下为 `C:\Users\\AppData\Roaming\cnstd\1.2`）目录中。
+
+## 数学公式识别模型（MFR）
+**数学公式识别模型** 下载地址：[breezedeus/pix2text-mfr](https://huggingface.co/breezedeus/pix2text-mfr) （不能科学上网请使用 [国内镜像](https://hf-mirror.com/breezedeus/pix2text-mfr)）。
+把这里面的所有文件都下载到 `~/.pix2text/1.1/mfr-1.5-onnx` （Windows 系统放在 `C:\Users\\AppData\Roaming\pix2text\1.1\mfr-1.5-onnx`）目录下即可，目录不存在的话请自己创建。
+
+> 注：上面路径的 `1.1` 是 pix2text 的版本号，`1.1.*` 都对应 `1.1`。如果是其他版本请自行替换。
+
+## 文字识别引擎
+Pix2Text 的**文字识别引擎**可以识别 **`80+` 种语言**，如**英文、简体中文、繁体中文、越南语**等。其中，**英文**和**简体中文**识别使用的是开源 OCR 工具 [CnOCR](https://github.com/breezedeus/cnocr) ，其他语言的识别使用的是开源 OCR 工具 [EasyOCR](https://github.com/JaidedAI/EasyOCR) 。
+
+正常情况下，CnOCR 的模型都会自动下载。如果无法自动下载，可以参考以下说明手动下载。
+CnOCR 的开源模型都放在 [**cnstd-cnocr-models**](https://huggingface.co/breezedeus/cnstd-cnocr-models) （[国内镜像](https://hf-mirror.com/breezedeus/cnstd-cnocr-models)）项目中，可免费下载使用。
+如果下载太慢，也可以从 [百度云盘](https://pan.baidu.com/s/1RhLBf8DcLnLuGLPrp89hUg?pwd=nocr) 下载， 提取码为 `nocr`。具体方法可参考 [CnOCR在线文档/使用方法](https://cnocr.readthedocs.io/zh-cn/latest/usage) 。
+
+CnOCR 中的文字检测引擎使用的是 [CnSTD](https://github.com/breezedeus/cnstd)，
+如果系统无法自动成功下载模型文件，则需要手动从 [**cnstd-cnocr-models**](https://huggingface.co/breezedeus/cnstd-cnocr-models) （[国内镜像](https://hf-mirror.com/breezedeus/cnstd-cnocr-models)）项目中下载，或者从[百度云盘](https://pan.baidu.com/s/1zDMzArCDrrXHWL0AWxwYQQ?pwd=nstd)（提取码为 `nstd`）下载对应的zip文件并把它存放于 `~/.cnstd/1.2`（Windows下为 `C:\Users\\AppData\Roaming\cnstd\1.2`）目录中。
+
+关于 CnOCR 模型的更多信息请参考 [CnOCR在线文档/可用模型](https://cnocr.readthedocs.io/zh-cn/latest/models)。
+
+CnOCR 也提供**高级版的付费模型**，具体参考本文末尾的说明。
+
+- CnOCR 付费模型：具体参考 [CnOCR详细资料 | Breezedeus.com](https://www.breezedeus.com/article/cnocr)。
+
+
+{: style="width:270px"}
+
+
+更多联系方式见 [交流群](contact.md)。
\ No newline at end of file
diff --git a/docs/pix2text/latex_ocr.md b/docs/pix2text/latex_ocr.md
new file mode 100644
index 0000000000000000000000000000000000000000..da75cbe9b3f1f5b54598a11c29e6397b7a5ee4ac
--- /dev/null
+++ b/docs/pix2text/latex_ocr.md
@@ -0,0 +1 @@
+:::pix2text.latex_ocr
diff --git a/docs/pix2text/pix_to_text.md b/docs/pix2text/pix_to_text.md
new file mode 100644
index 0000000000000000000000000000000000000000..878b6ff24c4f0c827b6cf41430c3aef87633d0c5
--- /dev/null
+++ b/docs/pix2text/pix_to_text.md
@@ -0,0 +1 @@
+:::pix2text.pix_to_text
diff --git a/docs/pix2text/table_ocr.md b/docs/pix2text/table_ocr.md
new file mode 100644
index 0000000000000000000000000000000000000000..c78c6bd2d9d3ef1d7ee2cb87e735a1ac64b6700a
--- /dev/null
+++ b/docs/pix2text/table_ocr.md
@@ -0,0 +1 @@
+:::pix2text.table_ocr
diff --git a/docs/pix2text/text_formula_ocr.md b/docs/pix2text/text_formula_ocr.md
new file mode 100644
index 0000000000000000000000000000000000000000..5efdb41c60086202bd04ff4b53f25a5686b37736
--- /dev/null
+++ b/docs/pix2text/text_formula_ocr.md
@@ -0,0 +1 @@
+:::pix2text.text_formula_ocr
diff --git a/docs/requirements.txt b/docs/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0b15e66ff06869841203bf64630f7e01c49e047f
--- /dev/null
+++ b/docs/requirements.txt
@@ -0,0 +1,387 @@
+#
+# This file is autogenerated by pip-compile with Python 3.9
+# by the following command:
+#
+# pip-compile --output-file=requirements.txt requirements.in
+#
+#--index-url https://mirrors.aliyun.com/pypi/simple
+#--extra-index-url https://pypi.tuna.tsinghua.edu.cn/simple
+#--extra-index-url https://pypi.org/simple
+
+aiohttp==3.9.3
+ # via
+ # datasets
+ # fsspec
+aiosignal==1.3.1
+ # via aiohttp
+appdirs==1.4.4
+ # via wandb
+async-timeout==4.0.3
+ # via aiohttp
+attrs==23.2.0
+ # via aiohttp
+certifi==2024.2.2
+ # via
+ # requests
+ # sentry-sdk
+charset-normalizer==3.3.2
+ # via requests
+click==8.1.7
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # wandb
+cnocr[ort-cpu]==2.3.0.2
+ # via
+ # -r requirements.in
+ # cnocr
+cnstd==1.2.4.1
+ # via
+ # -r requirements.in
+ # cnocr
+coloredlogs==15.0.1
+ # via
+ # onnxruntime
+ # optimum
+contourpy==1.2.0
+ # via matplotlib
+cycler==0.12.1
+ # via matplotlib
+datasets==2.17.0
+ # via
+ # evaluate
+ # optimum
+dill==0.3.8
+ # via
+ # datasets
+ # evaluate
+ # multiprocess
+docker-pycreds==0.4.0
+ # via wandb
+easyocr==1.7.1
+ # via -r requirements.in
+evaluate==0.4.1
+ # via optimum
+filelock==3.13.1
+ # via
+ # datasets
+ # huggingface-hub
+ # torch
+ # transformers
+flatbuffers==23.5.26
+ # via onnxruntime
+fonttools==4.49.0
+ # via matplotlib
+frozenlist==1.4.1
+ # via
+ # aiohttp
+ # aiosignal
+fsspec[http]==2023.10.0
+ # via
+ # datasets
+ # evaluate
+ # huggingface-hub
+ # pytorch-lightning
+ # torch
+gitdb==4.0.11
+ # via gitpython
+gitpython==3.1.42
+ # via wandb
+huggingface-hub==0.20.3
+ # via
+ # cnstd
+ # datasets
+ # evaluate
+ # optimum
+ # tokenizers
+ # transformers
+humanfriendly==10.0
+ # via coloredlogs
+idna==3.6
+ # via
+ # requests
+ # yarl
+imageio==2.34.0
+ # via scikit-image
+importlib-resources==6.1.1
+ # via matplotlib
+jinja2==3.0.3
+ # via torch
+kiwisolver==1.4.5
+ # via matplotlib
+lazy-loader==0.3
+ # via scikit-image
+lightning-utilities==0.10.1
+ # via
+ # pytorch-lightning
+ # torchmetrics
+markupsafe==2.1.5
+ # via jinja2
+matplotlib==3.8.3
+ # via
+ # cnstd
+ # seaborn
+mpmath==1.3.0
+ # via sympy
+multidict==6.0.5
+ # via
+ # aiohttp
+ # yarl
+multiprocess==0.70.16
+ # via
+ # datasets
+ # evaluate
+networkx==3.2.1
+ # via
+ # scikit-image
+ # torch
+ninja==1.11.1.1
+ # via easyocr
+numpy==1.26.4
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # contourpy
+ # datasets
+ # easyocr
+ # evaluate
+ # imageio
+ # matplotlib
+ # onnx
+ # onnxruntime
+ # opencv-python
+ # opencv-python-headless
+ # optimum
+ # pandas
+ # pyarrow
+ # pytorch-lightning
+ # scikit-image
+ # scipy
+ # seaborn
+ # shapely
+ # tifffile
+ # torchmetrics
+ # torchvision
+ # transformers
+onnx==1.15.0
+ # via
+ # cnocr
+ # cnstd
+ # optimum
+onnxruntime==1.17.0
+ # via
+ # cnocr
+ # optimum
+opencv-python==4.9.0.80
+ # via
+ # -r requirements.in
+ # cnstd
+opencv-python-headless==4.9.0.80
+ # via easyocr
+optimum[onnxruntime]==1.16.2
+ # via -r requirements.in
+packaging==23.2
+ # via
+ # datasets
+ # evaluate
+ # huggingface-hub
+ # lightning-utilities
+ # matplotlib
+ # onnxruntime
+ # optimum
+ # pytorch-lightning
+ # scikit-image
+ # torchmetrics
+ # transformers
+pandas==2.2.0
+ # via
+ # cnstd
+ # datasets
+ # evaluate
+ # seaborn
+pillow==10.2.0
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # easyocr
+ # imageio
+ # matplotlib
+ # scikit-image
+ # torchvision
+polygon3==3.0.9.1
+ # via cnstd
+protobuf==4.25.3
+ # via
+ # onnx
+ # onnxruntime
+ # optimum
+ # transformers
+ # wandb
+psutil==5.9.8
+ # via wandb
+pyarrow==15.0.0
+ # via datasets
+pyarrow-hotfix==0.6
+ # via datasets
+pyclipper==1.3.0.post5
+ # via
+ # cnstd
+ # easyocr
+pymupdf==1.24.1
+ # via -r requirements.in
+pymupdfb==1.24.1
+ # via pymupdf
+pyparsing==3.1.1
+ # via matplotlib
+pyspellchecker==0.8.1
+ # via -r requirements.in
+python-bidi==0.4.2
+ # via easyocr
+python-dateutil==2.8.2
+ # via
+ # matplotlib
+ # pandas
+pytorch-lightning==2.2.0.post0
+ # via
+ # cnocr
+ # cnstd
+pytz==2024.1
+ # via pandas
+pyyaml==6.0.1
+ # via
+ # cnstd
+ # datasets
+ # easyocr
+ # huggingface-hub
+ # pytorch-lightning
+ # transformers
+ # wandb
+regex==2023.12.25
+ # via transformers
+requests==2.31.0
+ # via
+ # datasets
+ # evaluate
+ # fsspec
+ # huggingface-hub
+ # responses
+ # torchvision
+ # transformers
+ # wandb
+responses==0.18.0
+ # via evaluate
+safetensors==0.4.2
+ # via transformers
+scikit-image==0.22.0
+ # via easyocr
+scipy==1.12.0
+ # via
+ # cnstd
+ # easyocr
+ # scikit-image
+seaborn==0.13.2
+ # via cnstd
+sentencepiece==0.1.99
+ # via transformers
+sentry-sdk==1.40.4
+ # via wandb
+setproctitle==1.3.3
+ # via wandb
+shapely==2.0.2
+ # via
+ # cnstd
+ # easyocr
+six==1.16.0
+ # via
+ # docker-pycreds
+ # python-bidi
+ # python-dateutil
+smmap==5.0.1
+ # via gitdb
+sympy==1.12
+ # via
+ # onnxruntime
+ # optimum
+ # torch
+tifffile==2024.2.12
+ # via scikit-image
+tokenizers==0.15.2
+ # via transformers
+torch==2.2.0
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # easyocr
+ # optimum
+ # pytorch-lightning
+ # torchmetrics
+ # torchvision
+torchmetrics==1.3.1
+ # via
+ # cnocr
+ # pytorch-lightning
+torchvision==0.17.0
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # easyocr
+tqdm==4.66.2
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # datasets
+ # evaluate
+ # huggingface-hub
+ # pytorch-lightning
+ # transformers
+transformers[sentencepiece]==4.37.2
+ # via
+ # -r requirements.in
+ # optimum
+typing-extensions==4.9.0
+ # via
+ # huggingface-hub
+ # lightning-utilities
+ # pytorch-lightning
+ # torch
+ # wandb
+tzdata==2024.1
+ # via pandas
+unidecode==1.3.8
+ # via cnstd
+urllib3==2.2.0
+ # via
+ # requests
+ # responses
+ # sentry-sdk
+wandb==0.16.3
+ # via cnocr
+xxhash==3.4.1
+ # via
+ # datasets
+ # evaluate
+yarl==1.9.4
+ # via aiohttp
+zipp==3.17.0
+ # via importlib-resources
+
+doclayout-yolo<0.1
+litellm<2.0
+
+# The following packages are considered to be unsafe in a requirements file:
+# setuptools
+
+# for mkdocs
+pygments==2.11
+jinja2<3.1.0
+mkdocs==1.2.2
+mkdocs-macros-plugin==0.6.0
+mkdocs-material==7.3.0
+mkdocs-material-extensions==1.0.3
+mkdocstrings==0.16.1
diff --git a/docs/train.md b/docs/train.md
new file mode 100644
index 0000000000000000000000000000000000000000..08f3e0a35e44a66b370ab6b70107400e61722426
--- /dev/null
+++ b/docs/train.md
@@ -0,0 +1,3 @@
+# Model Train
+
+TODO
diff --git a/docs/usage.md b/docs/usage.md
new file mode 100644
index 0000000000000000000000000000000000000000..c5d8c2a49dd9a625dc0206bc9aa3cf74208c748c
--- /dev/null
+++ b/docs/usage.md
@@ -0,0 +1,547 @@
+# Usage
+
+## 模型文件自动下载
+
+首次使用 **Pix2Text** 时，系统会**自动下载**所需的开源模型，并存于 `~/.pix2text` 目录（Windows下默认路径为 `C:\Users\\AppData\Roaming\pix2text`）。
+CnOCR 和 CnSTD 中的模型分别存于 `~/.cnocr` 和 `~/.cnstd` 中（Windows 下默认路径为 `C:\Users\\AppData\Roaming\cnocr` 和 `C:\Users\\AppData\Roaming\cnstd`）。
+下载过程请耐心等待，无法科学上网时系统会自动尝试其他可用站点进行下载，所以可能需要等待较长时间。
+对于没有网络连接的机器，可以先把模型下载到其他机器上，然后拷贝到对应目录。
+
+如果系统无法自动成功下载模型文件，则需要手动下载模型文件，可以参考 [huggingface.co/breezedeus](https://huggingface.co/breezedeus) （[国内镜像](https://hf-mirror.com/breezedeus)）自己手动下载。
+
+具体说明见 [模型下载](models.md)。
+
+
+## 初始化
+### 方法一
+
+类 [Pix2Text](pix2text/pix_to_text.md) 是识别主类，包含了多个识别函数识别不同类型的 **图片** 或 **PDF文件** 中的内容。类 `Pix2Text` 的初始化函数如下：
+
+```python
+class Pix2Text(object):
+ def __init__(
+ self,
+ *,
+ layout_parser: Optional[LayoutParser] = None,
+ text_formula_ocr: Optional[TextFormulaOCR] = None,
+ table_ocr: Optional[TableOCR] = None,
+ **kwargs,
+ ):
+ """
+ Initialize the Pix2Text object.
+ Args:
+ layout_parser (LayoutParser): The layout parser object; default value is `None`, which means to create a default one
+ text_formula_ocr (TextFormulaOCR): The text and formula OCR object; default value is `None`, which means to create a default one
+ table_ocr (TableOCR): The table OCR object; default value is `None`, which means not to recognize tables
+ **kwargs (dict): Other arguments, currently not used
+ """
+```
+
+其中的几个参数含义如下：
+
+* `layout_parser`：版面分析模型对象，默认值为 `None`，表示使用默认的版面分析模型；
+* `text_formula_ocr`：文字与公式识别模型对象，默认值为 `None`，表示使用默认的文字与公式识别模型；
+* `table_ocr`：表格识别模型对象，默认值为 `None`，表示不识别表格；
+* `**kwargs`：其他参数，目前未使用。
+
+
+每个参数都有默认取值，所以可以不传入任何参数值进行初始化：`p2t = Pix2Text()`。但请注意，如果不传入任何参数值，那么只会导入默认的版面分析模型和文字与公式识别模型，而**不会导入表格识别模型**。
+
+初始化 Pix2Text 实例的更好的方法是使用以下的函数。
+
+### 方法二
+可以通过指定配置信息来初始化 `Pix2Text` 类的实例：
+
+```python
+@classmethod
+def from_config(
+ cls,
+ total_configs: Optional[dict] = None,
+ enable_formula: bool = True,
+ enable_table: bool = True,
+ device: str = None,
+ **kwargs,
+):
+ """
+ Create a Pix2Text object from the configuration.
+ Args:
+ total_configs (dict): The total configuration; default value is `None`, which means to use the default configuration.
+ If not None, it should contain the following keys:
+
+ * `layout`: The layout parser configuration
+ * `text_formula`: The TextFormulaOCR configuration
+ * `table`: The table OCR configuration
+ enable_formula (bool): Whether to enable formula recognition; default value is `True`
+ enable_table (bool): Whether to enable table recognition; default value is `True`
+ device (str): The device to run the model; optional values are 'cpu', 'gpu' or 'cuda';
+ default value is `None`, which means to select the device automatically
+ **kwargs (dict): Other arguments
+
+ Returns: a Pix2Text object
+
+ """
+```
+
+其中的几个参数含义如下：
+
+* `total_configs`：总配置，包含以下几个键值：
+ - `layout`：版面分析模型的配置；
+ - `text_formula`：文字与公式识别模型的配置；
+ - `table`：表格识别模型的配置；
+ 默认值为 `None`，表示使用默认配置。
+* `enable_formula`：是否启用公式识别，默认值为 `True`；
+* `enable_table`：是否启用表格识别，默认值为 `True`；
+* `device`：运行模型的设备，可选值为 `'cpu'`, `'gpu'` 或 `'cuda'`，默认值为 `None`，表示自动选择设备；
+* `**kwargs`：其他参数，目前未使用。
+
+这个函数的返回值是一个 `Pix2Text` 类的实例，可以直接使用这个实例进行识别。
+
+推荐使用此函数初始化 Pix2Text 的实例，如：`p2t = Pix2Text.from_config()`。
+
+一个包含配置信息的示例如下：
+
+```python
+import os
+from pix2text import Pix2Text
+
+text_formula_config = dict(
+ languages=('en', 'ch_sim'), # 设置识别的语言
+ mfd=dict( # 声明 MFD 的初始化参数
+ model_path=os.path.expanduser(
+ '~/.pix2text/1.1/mfd-onnx/mfd-v20240618.onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ formula=dict(
+ model_name='mfr-pro',
+ model_backend='onnx',
+ model_dir=os.path.expanduser(
+ '~/.pix2text/1.1/mfr-pro-onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ text=dict(
+ rec_model_name='doc-densenet_lite_666-gru_large',
+ rec_model_backend='onnx',
+ rec_model_fp=os.path.expanduser(
+ '~/.cnocr/2.3/doc-densenet_lite_666-gru_large/cnocr-v2.3-doc-densenet_lite_666-gru_large-epoch=005-ft-model.onnx'
+ # noqa
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+)
+total_config = {
+ 'layout': {'scores_thresh': 0.45},
+ 'text_formula': text_formula_config,
+}
+p2t = Pix2Text.from_config(total_configs=total_config)
+```
+
+使用 VLM API 做文字和公式识别的示例如下：
+
+```python
+import os
+from pix2text import Pix2Text
+
+model_name=os.getenv("GEMINI_MODEL") # "gemini/gemini-2.0-flash-lite"
+api_key=os.getenv("GEMINI_API_KEY") # ""
+
+total_config = {
+ 'layout': None,
+ 'text_formula': {
+ "model_type": "VlmTextFormulaOCR", # 指定类名
+ "model_name": model_name,
+ "api_key": api_key,
+ },
+ "table": {
+ "model_type": "VlmTableOCR", # 指定类名
+ "model_name": model_name,
+ "api_key": api_key,
+ },
+}
+p2t = Pix2Text.from_config(total_configs=total_config)
+```
+`model_name` 和 `api_key` 的取值，具体可参考 [LiteLLM 文档](https://docs.litellm.ai/docs/)。
+
+更多初始化的示例请参见 [tests/test_pix2text.py](https://github.com/breezedeus/Pix2Text/blob/main/tests/test_pix2text.py)。
+
+## 各种识别接口
+
+类 `Pix2Text` 提供了不同的识别函数来识别不同类似的图片或者 PDF 文件内容，下面分别说明。
+
+
+### 1. 函数 `.recognize_pdf()`
+
+此函数用于识别一整个 PDF 文件中的内容。**PDF 文件的内容可以只包含图片而无文字内容**，
+如示例文件 [examples/test-doc.pdf](examples/test-doc.pdf)。
+识别时，可以指定识别的页数，也可以指定识别的 PDF 文件编号。
+函数定义如下：
+
+```python
+def recognize_pdf(
+ self,
+ pdf_fp: Union[str, Path],
+ pdf_number: int = 0,
+ pdf_id: Optional[str] = None,
+ page_numbers: Optional[List[int]] = None,
+ **kwargs,
+) -> Document:
+ """
+ recognize a pdf file
+ Args:
+ pdf_fp (Union[str, Path]): pdf file path
+ pdf_number (int): pdf number
+ pdf_id (str): pdf id
+ page_numbers (List[int]): page numbers to recognize; default is `None`, which means to recognize all pages
+ kwargs (dict): Optional keyword arguments. The same as `recognize_page`
+
+ Returns: a Document object. Use `doc.to_markdown('output-dir')` to get the markdown output of the recognized document.
+
+ """
+```
+
+**函数说明**：
+
+* 输入参数 `pdf_fp`：PDF 文件的路径；
+* 输入参数 `pdf_number`：PDF 文件的编号，默认值为 `0`；
+* 输入参数 `pdf_id`：PDF 文件的 ID，默认值为 `None`；
+* 输入参数 `page_numbers`：需要识别的页码列表（页码从 0 开始计数，如 `[0, 1]` 表示只识别文件的第 1、2 页内容），默认值为 `None`，表示识别所有页；
+* 输入参数 `**kwargs`：其他参数，具体说明参考下面的函数 `recognize_page()`。
+
+**返回值**：返回一个 `Document` 对象，可以使用 `doc.to_markdown('output-dir')` 来获取识别结果的 markdown 输出。
+
+**调用示例**：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = 'examples/test-doc.pdf'
+p2t = Pix2Text.from_config()
+out_md = p2t.recognize_pdf(
+ img_fp,
+ page_numbers=[0, 1],
+ table_as_image=True,
+ save_debug_res=f'./output-debug',
+)
+out_md.to_markdown('output-pdf-md')
+```
+
+### 2. 函数 `.recognize_page()`
+
+此函数用于识别一张包含复杂排版的页面图片中的内容。图片可以包含多列、图片、表格等内容，如示例图片 [examples/page2.png](examples/page2.png)。
+函数定义如下：
+
+```python
+def recognize_page(
+ self,
+ img: Union[str, Path, Image.Image],
+ page_number: int = 0,
+ page_id: Optional[str] = None,
+ **kwargs,
+) -> Page:
+ """
+ Analyze the layout of the image, and then recognize the information contained in each section.
+
+ Args:
+ img (str or Image.Image): an image path, or `Image.Image` loaded by `Image.open()`
+ page_number (str): page number; default value is `0`
+ page_id (str): page id; default value is `None`, which means to use the `str(page_number)`
+ kwargs ():
+ * resized_shape (int): Resize the image width to this size for processing; default value is `768`
+ * mfr_batch_size (int): batch size for MFR; When running on GPU, this value is suggested to be set to greater than 1; default value is `1`
+ * embed_sep (tuple): Prefix and suffix for embedding latex; only effective when `return_text` is `True`; default value is `(' $', '$ ')`
+ * isolated_sep (tuple): Prefix and suffix for isolated latex; only effective when `return_text` is `True`; default value is two-dollar signs
+ * line_sep (str): The separator between lines of text; only effective when `return_text` is `True`; default value is a line break
+ * auto_line_break (bool): Automatically line break the recognized text; only effective when `return_text` is `True`; default value is `True`
+ * det_text_bbox_max_width_expand_ratio (float): Expand the width of the detected text bbox. This value represents the maximum expansion ratio above and below relative to the original bbox height; default value is `0.3`
+ * det_text_bbox_max_height_expand_ratio (float): Expand the height of the detected text bbox. This value represents the maximum expansion ratio above and below relative to the original bbox height; default value is `0.2`
+ * embed_ratio_threshold (float): The overlap threshold for embed formulas and text lines; default value is `0.6`.
+ When the overlap between an embed formula and a text line is greater than or equal to this threshold,
+ the embed formula and the text line are considered to be on the same line;
+ otherwise, they are considered to be on different lines.
+ * table_as_image (bool): If `True`, the table will be recognized as an image (don't parse the table content as text) ; default value is `False`
+ * title_contain_formula (bool): If `True`, the title of the page will be recognized as a mixed image (text and formula). If `False`, it will be recognized as a text; default value is `False`
+ * text_contain_formula (bool): If `True`, the text of the page will be recognized as a mixed image (text and formula). If `False`, it will be recognized as a text; default value is `True`
+ * formula_rec_kwargs (dict): generation arguments passed to formula recognizer `latex_ocr`; default value is `{}`
+ * save_debug_res (str): if `save_debug_res` is set, the directory to save the debug results; default value is `None`, which means not to save
+
+ Returns: a Page object. Use `page.to_markdown('output-dir')` to get the markdown output of the recognized page.
+ """
+```
+
+**函数说明**：
+
+* 输入参数 `img`：图片路径或者 `Image.Image` 对象；
+* 输入参数 `page_number`：页码，默认值为 `0`；
+* 输入参数 `page_id`：页码 ID，默认值为 `None`，此时会使用 `str(page_number)` 作为其取值；
+* kwargs：其他参数，具体说明如下：
+ - `resized_shape`：调整图片的宽度为此大小以进行处理，默认值为 `768`；
+ - `mfr_batch_size`：MFR 预测时使用的批大小；在 GPU 上运行时，建议将此值设置为大于 `1`；默认值为 `1`；
+ - `embed_sep`：嵌入 LaTeX 的前缀和后缀；仅在 `return_text` 为 `True` 时有效；默认值为 `(' $', '$ ')`；
+ - `isolated_sep`：孤立 LaTeX 的前缀和后缀；仅在 `return_text` 为 `True` 时有效；默认值为两个美元符号；
+ - `line_sep`：文本行之间的分隔符；仅在 `return_text` 为 `True` 时有效；默认值为换行符；
+ - `auto_line_break`：自动换行识别的文本；仅在 `return_text` 为 `True` 时有效；默认值为 `True`；
+ - `det_text_bbox_max_width_expand_ratio`：扩展检测文本框的宽度。此值表示相对于原始框高度的最大扩展比率；默认值为 `0.3`；
+ - `det_text_bbox_max_height_expand_ratio`：扩展检测文本框的高度。此值表示相对于原始框高度的最大扩展比率；默认值为 `0.2`；
+ - `embed_ratio_threshold`：嵌入公式和文本行之间的重叠阈值；默认值为 `0.6`。当嵌入公式和文本行之间的重叠大于或等于此阈值时，认为嵌入公式和文本行在同一行；否则，认为它们在不同行
+ - `table_as_image`：如果为 `True`，则将表格识别为图像（不将表格内容解析为文本）；默认值为 `False`
+ - `title_contain_formula`：如果为 `True`，则将页面标题作为为混合图像（文本和公式）进行识别。如果为 `False`，则将其作为文本图片进行识别（不识别公式）；默认值为 `False`
+ - `text_contain_formula`：如果为 `True`，则将页面文本作为混合图像（文本和公式）进行识别。如果为 `False`，则将其作为文本进行识别（不识别公式）；默认值为 `True`
+ - `formula_rec_kwargs`：传递给公式识别器 `latex_ocr` 的生成参数；默认值为 `{}`
+ - `save_debug_res`：如果设置了 `save_debug_res`，则把各种中间的解析结果存入此目录以便于调试；默认值为 `None`，表示不保存
+
+**返回值**：返回一个 `Page` 对象，可以使用 `page.to_markdown('output-dir')` 来获取识别结果的 markdown 输出。
+
+**调用示例**：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = 'examples/page2.png'
+p2t = Pix2Text.from_config()
+out_page = p2t.recognize_page(
+ img_fp,
+ title_contain_formula=False,
+ text_contain_formula=False,
+ save_debug_res=f'./output-debug',
+)
+out_page.to_markdown('output-page-md')
+```
+
+
+### 3. 函数 `.recognize_text_formula()`
+
+此函数用于识别一张包含文字和公式的图片（如段落截图）中的内容，如示例图片 [examples/mixed.jpg](examples/mixed.jpg)。
+函数定义如下：
+
+```python
+def recognize_text_formula(
+ self, img: Union[str, Path, Image.Image], return_text: bool = True, **kwargs,
+) -> Union[str, List[str], List[Any], List[List[Any]]]:
+ """
+ Analyze the layout of the image, and then recognize the information contained in each section.
+
+ Args:
+ img (str or Image.Image): an image path, or `Image.Image` loaded by `Image.open()`
+ return_text (bool): Whether to return the recognized text; default value is `True`
+ kwargs ():
+ * resized_shape (int): Resize the image width to this size for processing; default value is `768`
+ * save_analysis_res (str): Save the mfd result image in this file; default is `None`, which means not to save
+ * mfr_batch_size (int): batch size for MFR; When running on GPU, this value is suggested to be set to greater than 1; default value is `1`
+ * embed_sep (tuple): Prefix and suffix for embedding latex; only effective when `return_text` is `True`; default value is `(' $', '$ ')`
+ * isolated_sep (tuple): Prefix and suffix for isolated latex; only effective when `return_text` is `True`; default value is two-dollar signs
+ * line_sep (str): The separator between lines of text; only effective when `return_text` is `True`; default value is a line break
+ * auto_line_break (bool): Automatically line break the recognized text; only effective when `return_text` is `True`; default value is `True`
+ * det_text_bbox_max_width_expand_ratio (float): Expand the width of the detected text bbox. This value represents the maximum expansion ratio above and below relative to the original bbox height; default value is `0.3`
+ * det_text_bbox_max_height_expand_ratio (float): Expand the height of the detected text bbox. This value represents the maximum expansion ratio above and below relative to the original bbox height; default value is `0.2`
+ * embed_ratio_threshold (float): The overlap threshold for embed formulas and text lines; default value is `0.6`.
+ When the overlap between an embed formula and a text line is greater than or equal to this threshold,
+ the embed formula and the text line are considered to be on the same line;
+ otherwise, they are considered to be on different lines.
+ * table_as_image (bool): If `True`, the table will be recognized as an image; default value is `False`
+ * formula_rec_kwargs (dict): generation arguments passed to formula recognizer `latex_ocr`; default value is `{}`
+
+ Returns: a str when `return_text` is `True`; or a list of ordered (top to bottom, left to right) dicts when `return_text` is `False`,
+ with each dict representing one detected box, containing keys:
+
+ * `type`: The category of the image; Optional: 'text', 'isolated', 'embedding'
+ * `text`: The recognized text or Latex formula
+ * `score`: The confidence score [0, 1]; the higher, the more confident
+ * `position`: Position information of the block, `np.ndarray`, with shape of [4, 2]
+ * `line_number`: The line number of the box (first line `line_number==0`), boxes with the same value indicate they are on the same line
+
+ """
+```
+
+**函数说明**：
+
+* 输入参数 `img`：图片路径或者 `Image.Image` 对象；
+* 输入参数 `return_text`：是否返回纯文本；取值为 `False` 时返回带有结构化信息的 list；默认值为 `True`；
+* 输入参数 `kwargs`：其他参数，具体说明如下：
+ - `resized_shape`：调整图片的宽度为此大小以进行处理，默认值为 `768`；
+ - `save_analysis_res`：保存 MFD 解析结果图像的文件名；默认值为 `None`，表示不保存；
+ - `mfr_batch_size`：MFR 预测时使用的批大小；在 GPU 上运行时，建议将此值设置为大于 `1`；默认值为 `1`；
+ - `embed_sep`：嵌入 LaTeX 的前缀和后缀；仅在 `return_text` 为 `True` 时有效；默认值为 `(' $', '$ ')`；
+ - `isolated_sep`：孤立 LaTeX 的前缀和后缀；仅在 `return_text` 为 `True` 时有效；默认值为两个美元符号；
+ - `line_sep`：文本行之间的分隔符；仅在 `return_text` 为 `True` 时有效；默认值为换行符；
+ - `auto_line_break`：自动换行识别的文本；仅在 `return_text` 为 `True` 时有效；默认值为 `True`；
+ - `det_text_bbox_max_width_expand_ratio`：扩展检测文本框的宽度。此值表示相对于原始框高度的最大扩展比率；默认值为 `0.3`；
+ - `det_text_bbox_max_height_expand_ratio`：扩展检测文本框的高度。此值表示相对于原始框高度的最大扩展比率；默认值为 `0.2`；
+ - `embed_ratio_threshold`：嵌入公式和文本行之间的重叠阈值；默认值为 `0.6`。当嵌入公式和文本行之间的重叠大于或等于此阈值时，认为嵌入公式和文本行在同一行；否则，认
+ - `table_as_image`：如果为 `True`，则将表格识别为图像；默认值为 `False`
+ - `formula_rec_kwargs`：传递给公式识别器 `latex_ocr` 的生成参数；默认值为 `{}`
+
+**返回值**：当 `return_text` 为 `True` 时，返回一个字符串；当 `return_text` 为 `False` 时，返回一个有序的（从上到下，从左到右）字典列表，每个字典表示一个检测框，包含以下键值：
+ - `type`：图像的类别；可选值：'text'、'isolated'、'embedding'
+ - `text`：识别的文本或 LaTeX 公式
+ - `score`：置信度分数 [0, 1]；分数越高，置信度越高
+ - `position`：块的位置信息，`np.ndarray`，形状为 `[4, 2]`
+ - `line_number`：框的行号（第一行 `line_number==0`），具有相同值的框表示它们在同一行
+
+**调用示例**：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = 'examples/mixed.jpg'
+p2t = Pix2Text.from_config()
+out = p2t.recognize_text_formula(
+ img_fp,
+ save_analysis_res=f'./output-debug',
+)
+```
+
+### 4. 函数 `.recognize_formula()`
+
+此函数用于识别一张纯公式的图片中的内容，如示例图片 [examples/formula2.png](examples/formula2.png)。
+函数定义如下：
+
+```python
+def recognize_formula(
+ self,
+ imgs: Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]],
+ batch_size: int = 1,
+ return_text: bool = True,
+ rec_config: Optional[dict] = None,
+ **kwargs,
+) -> Union[str, List[str], Dict[str, Any], List[Dict[str, Any]]]:
+ """
+ Recognize pure Math Formula images to LaTeX Expressions
+ Args:
+ imgs (Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]): The image or list of images
+ batch_size (int): The batch size
+ return_text (bool): Whether to return only the recognized text; default value is `True`
+ rec_config (Optional[dict]): The config for recognition
+ **kwargs (): Special model parameters. Not used for now
+
+ Returns: The LaTeX Expression or list of LaTeX Expressions;
+ str or List[str] when `return_text` is True;
+ Dict[str, Any] or List[Dict[str, Any]] when `return_text` is False, with the following keys:
+
+ * `text`: The recognized LaTeX text
+ * `score`: The confidence score [0, 1]; the higher, the more confident
+
+ """
+```
+
+**函数说明**：
+
+* 输入参数 `imgs`：图片路径或者 `Image.Image` 对象，或者图片路径或者 `Image.Image` 对象的列表；
+* 输入参数 `batch_size`：批大小，默认值为 `1`；
+* 输入参数 `return_text`：是否返回纯文本；取值为 `False` 时返回带有结构化信息的 list；默认值为 `True`；
+* 输入参数 `rec_config`：识别配置，可选值；
+* 输入参数 `kwargs`：其他参数，目前未使用。
+
+**返回值**：当 `return_text` 为 `True` 时，返回一个字符串；当 `return_text` 为 `False` 时，返回一个有序的（从上到下，从左到右）字典列表，每个字典表示一个检测框，包含以下键值：
+ - `text`：识别的 LaTeX 文本
+ - `score`：置信度分数 [0, 1]；分数越高，置信度越高
+
+**调用示例**：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = 'examples/formula2.png'
+p2t = Pix2Text.from_config()
+out = p2t.recognize_formula(
+ img_fp,
+ save_analysis_res=f'./output-debug',
+)
+```
+
+### 5. 函数 `.recognize_text()`
+
+此函数用于识别一张纯文字的图片中的内容，如示例图片 [examples/general.jpg](examples/general.jpg)。
+函数定义如下：
+
+```python
+def recognize_text(
+ self,
+ imgs: Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]],
+ return_text: bool = True,
+ rec_config: Optional[dict] = None,
+ **kwargs,
+) -> Union[str, List[str], List[Any], List[List[Any]]]:
+ """
+ Recognize a pure Text Image.
+ Args:
+ imgs (Union[str, Path, Image.Image], List[str], List[Path], List[Image.Image]): The image or list of images
+ return_text (bool): Whether to return only the recognized text; default value is `True`
+ rec_config (Optional[dict]): The config for recognition
+ kwargs (): Other parameters for `text_ocr.ocr()`
+
+ Returns: Text str or list of text strs when `return_text` is True;
+ `List[Any]` or `List[List[Any]]` when `return_text` is False, with the same length as `imgs` and the following keys:
+
+ * `position`: Position information of the block, `np.ndarray`, with a shape of [4, 2]
+ * `text`: The recognized text
+ * `score`: The confidence score [0, 1]; the higher, the more confident
+
+ """
+```
+
+**函数说明**：
+
+* 输入参数 `imgs`：图片路径或者 `Image.Image` 对象，或者图片路径或者 `Image.Image` 对象的列表；
+* 输入参数 `return_text`：是否返回纯文本；取值为 `False` 时返回带有结构化信息的 list；默认值为 `True`；
+* 输入参数 `rec_config`：识别配置，可选值；
+* 输入参数 `kwargs`：其他参数，具体说明参考函数 `text_ocr.ocr()`。
+
+**返回值**：当 `return_text` 为 `True` 时，返回一个字符串；当 `return_text` 为 `False` 时，返回一个有序的（从上到下，从左到右）字典列表，每个字典表示一个检测框，包含以下键值：
+ - `position`：块的位置信息，`np.ndarray`，形状为 `[4, 2]`
+ - `text`：识别的文本
+ - `score`：置信度分数 [0, 1]；分数越高，置信度越高
+
+**调用示例**：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = 'examples/general.jpg'
+p2t = Pix2Text.from_config()
+out = p2t.recognize_text(img_fp)
+```
+
+### 6. 函数 `.recognize()`
+
+是不是觉得上面的接口太丰富了，使用起来有点麻烦？没关系，这个函数可以根据指定的图片类型调用上面的不同函数进行识别。
+
+```python
+def recognize(
+ self,
+ img: Union[str, Path, Image.Image],
+ file_type: Literal[
+ 'pdf', 'page', 'text_formula', 'formula', 'text'
+ ] = 'text_formula',
+ **kwargs,
+) -> Union[Document, Page, str, List[str], List[Any], List[List[Any]]]:
+ """
+ Recognize the content of the image or pdf file according to the specified type.
+ It will call the corresponding recognition function `.recognize_{file_type}()` according to the `file_type`.
+ Args:
+ img (Union[str, Path, Image.Image]): The image/pdf file path or `Image.Image` object
+ file_type (str): Supported image types: 'pdf', 'page', 'text_formula', 'formula', 'text'
+ **kwargs (dict): Arguments for the corresponding recognition function
+
+ Returns: recognized results
+
+ """
+```
+
+**函数说明**：
+
+* 输入参数 `img`：图片/PDF文件路径或者 `Image.Image` 对象；
+* 输入参数 `file_type`：图片类型，可选值为 `'pdf'`, `'page'`, `'text_formula'`, `'formula'`, `'text'`；
+* 输入参数 `kwargs`：其他参数，具体说明参考上面的函数。
+
+**返回值**：根据 `file_type` 的不同，返回不同的结果。具体说明参考上面的函数。
+
+**调用示例**：
+
+```python
+from pix2text import Pix2Text
+
+img_fp = 'examples/general.jpg'
+p2t = Pix2Text.from_config()
+out = p2t.recognize(img_fp, file_type='text') # 等价于 p2t.recognize_text(img_fp)
+```
+
+
+更多使用示例请参见 [tests/test_pix2text.py](https://github.com/breezedeus/Pix2Text/blob/main/tests/test_pix2text.py)。
diff --git a/mkdocs.yml b/mkdocs.yml
new file mode 100644
index 0000000000000000000000000000000000000000..b80823305aadea54705001eaeedbb393ea705463
--- /dev/null
+++ b/mkdocs.yml
@@ -0,0 +1,119 @@
+# Project information
+site_name: Pix2Text
+site_url: https://pix2text.readthedocs.io
+site_description: Pix2Text Online Documents
+site_author: Breezedeus
+
+# Repository
+repo_url: https://github.com/breezedeus/pix2text
+repo_name: Breezedeus/Pix2Text
+edit_uri: "" #disables edit button
+
+# Copyright
+copyright: Copyright © 2022 - 2024
+
+# Social media
+extra:
+ social:
+ - icon: fontawesome/brands/github
+ link: https://github.com/breezedeus
+ - icon: fontawesome/brands/zhihu
+ link: https://www.zhihu.com/people/breezedeus-50
+ - icon: fontawesome/brands/youtube
+ link: https://www.youtube.com/@breezedeus
+ - icon: fontawesome/brands/youtube
+ link: https://space.bilibili.com/509307267
+ - icon: fontawesome/brands/twitter
+ link: https://twitter.com/breezedeus
+
+# Configuration
+theme:
+ name: material
+# name: readthedocs
+ logo: figs/breezedeus.png
+ favicon: figs/breezedeus.ico
+ palette:
+ primary: indigo
+ accent: indigo
+ font:
+ text: Roboto
+ code: Roboto Mono
+ features:
+ - navigation.tabs
+ - navigation.expand
+ icon:
+ repo: fontawesome/brands/github
+
+# Extensions
+markdown_extensions:
+ - meta
+ - pymdownx.emoji:
+ emoji_index: !!python/name:materialx.emoji.twemoji
+ emoji_generator: !!python/name:materialx.emoji.to_svg
+ - admonition # alerts
+ - pymdownx.details # collapsible alerts
+ - pymdownx.superfences # nest code and content inside alerts
+ - attr_list # add HTML and CSS to Markdown elements
+ - md_in_html
+ - pymdownx.inlinehilite # inline code highlights
+ - pymdownx.keys # show keystroke symbols
+ - pymdownx.snippets # insert content from other files
+ - pymdownx.tabbed # content tabs
+ - footnotes
+ - def_list
+ - pymdownx.arithmatex: # mathjax
+ generic: true
+ - pymdownx.tasklist:
+ custom_checkbox: true
+ clickable_checkbox: false
+ - codehilite
+ - pymdownx.highlight:
+ use_pygments: true
+ - toc:
+ toc_depth: 4
+
+# Plugins
+plugins:
+ - search
+ - macros
+ - mkdocstrings:
+ default_handler: python
+ handlers:
+ python:
+ rendering:
+ show_root_heading: false
+ show_source: true
+ show_category_heading: true
+ watch:
+ - cnocr
+
+# Extra CSS
+extra_css:
+ - static/css/custom.css
+
+# Extra JS
+extra_javascript:
+ - https://cdnjs.cloudflare.com/ajax/libs/tablesort/5.2.1/tablesort.min.js
+ - https://polyfill.io/v3/polyfill.min.js?features=es6
+ - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
+
+# Page tree
+nav:
+ - 🏠 Home: index.md
+ - 🛠️ Install: install.md
+ - 🛀🏻 Demo: demo.md
+ - 🧳 Models: models.md
+ - 📚 Examples: examples.md
+ - 📖 Usage: usage.md
+ - 🎮 APIs:
+ - Pix2Text: pix2text/pix_to_text.md
+ - TextFormulaOCR: pix2text/text_formula_ocr.md
+ - LatexOCR: pix2text/latex_ocr.md
+ - TableOCR: pix2text/table_ocr.md
+ - 💬 Contact: contact.md
+ - 🎛️ More:
+ - 🏄🏻 ️Command Tools: command.md
+ - 🕹 Model Training: train.md
+ - 🗒 RELEASE Notes: RELEASE.md
+ - 🙋🏽 FAQ: faq.md
+ - 🥤 Buy Me Coffee: buymeacoffee.md
diff --git a/pix2text/__init__.py b/pix2text/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dbb12981bd6ff51970f268eaef98613f1ad3ea9
--- /dev/null
+++ b/pix2text/__init__.py
@@ -0,0 +1,14 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+
+from .utils import read_img, set_logger, merge_line_texts
+from .render import render_html
+from .doc_xl_layout import DocXLayoutParser
+# from .layoutlmv3 import LayoutLMv3LayoutParser
+# from .doc_yolo_layout_parser import DocYoloLayoutParser
+from .latex_ocr import LatexOCR
+from .formula_detector import MathFormulaDetector
+from .text_formula_ocr import TextFormulaOCR
+from .table_ocr import TableOCR
+from .pix_to_text import Pix2Text
diff --git a/pix2text/__version__.py b/pix2text/__version__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ba119332568710e088d3df9d70736e769ca7c40
--- /dev/null
+++ b/pix2text/__version__.py
@@ -0,0 +1,5 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2025, [Breezedeus](https://www.breezedeus.com).
+
+__version__ = '1.1.4'
diff --git a/pix2text/app.py b/pix2text/app.py
new file mode 100644
index 0000000000000000000000000000000000000000..cffd2ff30f15a713e1e248384da4ad893617b302
--- /dev/null
+++ b/pix2text/app.py
@@ -0,0 +1,61 @@
+# coding: utf-8
+# Copyright (C) 2022, [Breezedeus](https://github.com/breezedeus).
+
+from PIL import Image
+import streamlit as st
+
+from pix2text import set_logger, Pix2Text
+
+logger = set_logger()
+st.set_page_config(layout="wide")
+
+
+@st.cache(allow_output_mutation=True)
+def get_model():
+ return Pix2Text()
+
+
+def main():
+ p2t = get_model()
+
+ title = '开源工具 Pix2Text Demo'
+ st.markdown(f"{title} ", unsafe_allow_html=True)
+
+ subtitle = '作者：breezedeus ； ' \
+ '欢迎加入 交流群 '
+
+ st.markdown(f"{subtitle}
", unsafe_allow_html=True)
+ st.markdown('')
+ st.subheader('选择待识别图片')
+ content_file = st.file_uploader('', type=["png", "jpg", "jpeg", "webp"])
+ if content_file is None:
+ st.stop()
+
+ try:
+ img = Image.open(content_file).convert('RGB')
+ img.save('ori.jpg')
+
+ out = p2t(img)
+ logger.info(out)
+ st.markdown('##### 原始图片：')
+ cols = st.columns([1, 3, 1])
+ with cols[1]:
+ st.image(content_file)
+
+ st.subheader('识别结果：')
+ st.markdown(f"* **图片类型**：{out['image_type']}")
+ st.markdown("* **识别内容**：")
+
+ cols = st.columns([1, 3, 1])
+ with cols[1]:
+ st.text(out['text'])
+
+ if out['image_type'] == 'formula':
+ st.markdown(f"$${out['text']}$$")
+
+ except Exception as e:
+ st.error(e)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/pix2text/cli.py b/pix2text/cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..227f52ed3380de65c767eab6b05cc45005e6beb2
--- /dev/null
+++ b/pix2text/cli.py
@@ -0,0 +1,751 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+
+import os
+import logging
+import glob
+import json
+from multiprocessing import Process
+from pprint import pformat
+
+import click
+
+from pix2text import set_logger, Pix2Text
+
+_CONTEXT_SETTINGS = {"help_option_names": ['-h', '--help']}
+logger = set_logger(log_level=logging.INFO)
+
+
+@click.group(context_settings=_CONTEXT_SETTINGS)
+def cli():
+ pass
+
+
+@cli.command('predict')
+@click.option(
+ "-l",
+ "--languages",
+ type=str,
+ default='en,ch_sim',
+ help="Language Codes for Text-OCR to recognize, separated by commas",
+ show_default=True,
+)
+@click.option(
+ "--layout-config",
+ type=str,
+ default=None,
+ help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--mfd-config",
+ type=str,
+ default=None,
+ help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--formula-ocr-config",
+ type=str,
+ default=None,
+ help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--text-ocr-config",
+ type=str,
+ default=None,
+ help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--enable-formula/--disable-formula",
+ default=True,
+ help="Whether to enable formula recognition",
+ show_default=True,
+)
+@click.option(
+ "--enable-table/--disable-table",
+ default=True,
+ help="Whether to enable table recognition",
+ show_default=True,
+)
+@click.option(
+ "-d",
+ "--device",
+ help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
+ type=str,
+ default='cpu',
+ show_default=True,
+)
+@click.option(
+ "--file-type",
+ type=click.Choice(['pdf', 'page', 'text_formula', 'formula', 'text']),
+ default='text_formula',
+ help="Which file type to process, 'pdf', 'page', 'text_formula', 'formula', or 'text'",
+ show_default=True,
+)
+@click.option(
+ "--resized-shape",
+ help="Resize the image width to this size before processing",
+ type=int,
+ default=768,
+ show_default=True,
+)
+@click.option(
+ "-i",
+ "--img-file-or-dir",
+ required=True,
+ help="File path of the input image/pdf or the specified directory",
+)
+@click.option(
+ "--save-debug-res",
+ default=None,
+ help="If `save_debug_res` is set, the directory to save the debug results; default value is `None`, which means not to save",
+ show_default=True,
+)
+@click.option(
+ "--rec-kwargs",
+ type=str,
+ default=None,
+ help="kwargs for calling .recognize(), in JSON string format",
+ show_default=True,
+)
+@click.option(
+ "--return-text/--no-return-text",
+ default=True,
+ help="Whether to return only the text result",
+ show_default=True,
+)
+@click.option(
+ "--auto-line-break/--no-auto-line-break",
+ default=True,
+ help="Whether to automatically determine to merge adjacent line results into a single line result",
+ show_default=True,
+)
+@click.option(
+ "-o",
+ "--output-dir",
+ default='output-md',
+ help="Output directory for the recognized text results. Only effective when `file-type` is `pdf` or `page`",
+ show_default=True,
+)
+@click.option(
+ "--log-level",
+ default='INFO',
+ help="Log Level, such as `INFO`, `DEBUG`",
+ show_default=True,
+)
+def predict(
+ languages,
+ layout_config,
+ mfd_config,
+ formula_ocr_config,
+ text_ocr_config,
+ enable_formula,
+ enable_table,
+ device,
+ file_type,
+ resized_shape,
+ img_file_or_dir,
+ save_debug_res,
+ rec_kwargs,
+ return_text,
+ auto_line_break,
+ output_dir,
+ log_level,
+):
+ """Use Pix2Text (P2T) to predict the text information in an image or PDF."""
+ logger = set_logger(log_level=log_level)
+
+ mfd_config = json.loads(mfd_config) if mfd_config else {}
+ formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
+ languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
+ text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}
+
+ layout_config = json.loads(layout_config) if layout_config else {}
+ text_formula_config = {
+ 'languages': languages, # 'en,ch_sim
+ 'mfd': mfd_config,
+ 'formula': formula_ocr_config,
+ 'text': text_ocr_config,
+ }
+ total_config = {
+ 'layout': layout_config,
+ 'text_formula': text_formula_config,
+ }
+ p2t = Pix2Text.from_config(
+ total_configs=total_config,
+ enable_formula=enable_formula,
+ enable_table=enable_table,
+ device=device,
+ )
+
+ fp_list = []
+ if os.path.isfile(img_file_or_dir):
+ fp_list.append(img_file_or_dir)
+ if save_debug_res:
+ save_debug_res = [save_debug_res]
+ elif os.path.isdir(img_file_or_dir):
+ fn_list = glob.glob1(img_file_or_dir, '*g')
+ fp_list = [os.path.join(img_file_or_dir, fn) for fn in fn_list]
+ if save_debug_res:
+ os.makedirs(save_debug_res, exist_ok=True)
+ save_debug_res = [
+ os.path.join(save_debug_res, 'output-debugs-' + fn) for fn in fn_list
+ ]
+ else:
+ raise ValueError(f'{img_file_or_dir} is not a valid file or directory')
+
+ rec_kwargs = json.loads(rec_kwargs) if rec_kwargs else {}
+ rec_kwargs['resized_shape'] = resized_shape
+ rec_kwargs['return_text'] = return_text
+ rec_kwargs['auto_line_break'] = auto_line_break
+
+ for idx, fp in enumerate(fp_list):
+ if file_type in ('pdf', 'page'):
+ rec_kwargs['save_debug_res'] = (
+ save_debug_res[idx] if save_debug_res is not None else None
+ )
+ else:
+ rec_kwargs['save_analysis_res'] = (
+ save_debug_res[idx] if save_debug_res is not None else None
+ )
+ out = p2t.recognize(fp, file_type=file_type, **rec_kwargs)
+ if file_type in ('pdf', 'page'):
+ out = out.to_markdown(output_dir)
+ logger.info(
+ f'In image: {fp}\nOuts: \n{out if isinstance(out, str) else pformat(out)}\n'
+ )
+
+
+@cli.command('evaluate')
+@click.option(
+ "-l",
+ "--languages",
+ type=str,
+ default='en,ch_sim',
+ help="Language Codes for Text-OCR to recognize, separated by commas",
+ show_default=True,
+)
+@click.option(
+ "--layout-config",
+ type=str,
+ default=None,
+ help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--mfd-config",
+ type=str,
+ default=None,
+ help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--formula-ocr-config",
+ type=str,
+ default=None,
+ help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--text-ocr-config",
+ type=str,
+ default=None,
+ help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--enable-formula/--disable-formula",
+ default=True,
+ help="Whether to enable formula recognition",
+ show_default=True,
+)
+@click.option(
+ "--enable-table/--disable-table",
+ default=True,
+ help="Whether to enable table recognition",
+ show_default=True,
+)
+@click.option(
+ "-d",
+ "--device",
+ help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
+ type=str,
+ default='cpu',
+ show_default=True,
+)
+@click.option(
+ "--file-type",
+ type=click.Choice(['pdf', 'page', 'text_formula', 'formula', 'text']),
+ default='text_formula',
+ help="Which file type to process, 'pdf', 'page', 'text_formula', 'formula', or 'text'",
+ show_default=True,
+)
+@click.option(
+ "--resized-shape",
+ help="Resize the image width to this size before processing",
+ type=int,
+ default=768,
+ show_default=True,
+)
+@click.option(
+ "-i",
+ "--input-json",
+ required=True,
+ help="JSON file containing evaluation data with image paths and ground truth",
+)
+@click.option(
+ "--gt-key",
+ default="model_result",
+ help="Key name for ground truth text in the JSON data",
+ show_default=True,
+)
+@click.option(
+ "--prefix-img-dir",
+ default="data",
+ help="Root directory for image files, will be prepended to img_path in JSON",
+ show_default=True,
+)
+@click.option(
+ "--rec-kwargs",
+ type=str,
+ default=None,
+ help="kwargs for calling .recognize(), in JSON string format",
+ show_default=True,
+)
+@click.option(
+ "--auto-line-break/--no-auto-line-break",
+ default=True,
+ help="Whether to automatically determine to merge adjacent line results into a single line result",
+ show_default=True,
+)
+@click.option(
+ "-o",
+ "--output-json",
+ default='evaluation_results.json',
+ help="Output JSON file for evaluation results",
+ show_default=True,
+)
+@click.option(
+ "--output-excel",
+ default=None,
+ help="Output Excel file with embedded images (optional)",
+ show_default=True,
+)
+@click.option(
+ "--output-html",
+ default=None,
+ help="Output HTML report with embedded images (optional)",
+ show_default=True,
+)
+@click.option(
+ "--max-img-width",
+ default=400,
+ help="Maximum width for embedded images in pixels",
+ show_default=True,
+)
+@click.option(
+ "--max-img-height",
+ default=300,
+ help="Maximum height for embedded images in pixels",
+ show_default=True,
+)
+@click.option(
+ "--max-samples",
+ default=-1,
+ help="Maximum number of samples to process (-1 for all samples)",
+ show_default=True,
+)
+@click.option(
+ "--log-level",
+ default='INFO',
+ help="Log Level, such as `INFO`, `DEBUG`",
+ show_default=True,
+)
+def evaluate(
+ languages,
+ layout_config,
+ mfd_config,
+ formula_ocr_config,
+ text_ocr_config,
+ enable_formula,
+ enable_table,
+ device,
+ file_type,
+ resized_shape,
+ input_json,
+ gt_key,
+ prefix_img_dir,
+ rec_kwargs,
+ auto_line_break,
+ output_json,
+ output_excel,
+ output_html,
+ max_img_width,
+ max_img_height,
+ max_samples,
+ log_level,
+):
+ """Evaluate Pix2Text (P2T) performance using a JSON file with image paths and ground truth."""
+ from pix2text.utils import (
+ calculate_cer_batch,
+ calculate_cer,
+ save_evaluation_results_to_excel_with_images,
+ create_html_report_with_images
+ )
+
+ logger = set_logger(log_level=log_level)
+
+ # Load evaluation data
+ try:
+ with open(input_json, 'r', encoding='utf-8') as f:
+ eval_data = json.load(f)
+ except Exception as e:
+ logger.error(f"Failed to load evaluation data from {input_json}: {e}")
+ return
+
+ if not isinstance(eval_data, list):
+ logger.error("Evaluation data must be a list of dictionaries")
+ return
+
+ # Validate data format
+ for i, item in enumerate(eval_data):
+ if not isinstance(item, dict):
+ logger.error(f"Item {i} is not a dictionary")
+ return
+ if 'img_path' not in item or gt_key not in item:
+ logger.error(f"Item {i} missing required keys 'img_path' or '{gt_key}'")
+ return
+
+ # Initialize Pix2Text
+ mfd_config = json.loads(mfd_config) if mfd_config else {}
+ formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
+ languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
+ text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}
+
+ layout_config = json.loads(layout_config) if layout_config else {}
+ text_formula_config = {
+ 'languages': languages,
+ 'mfd': mfd_config,
+ 'formula': formula_ocr_config,
+ 'text': text_ocr_config,
+ }
+ total_config = {
+ 'layout': layout_config,
+ 'text_formula': text_formula_config,
+ }
+ p2t = Pix2Text.from_config(
+ total_configs=total_config,
+ enable_formula=enable_formula,
+ enable_table=enable_table,
+ device=device,
+ )
+
+ # Prepare recognition kwargs
+ rec_kwargs = json.loads(rec_kwargs) if rec_kwargs else {}
+ rec_kwargs['resized_shape'] = resized_shape
+ rec_kwargs['return_text'] = True
+ rec_kwargs['auto_line_break'] = auto_line_break
+
+ def filter_and_clean_gt(gt):
+ # 只针对部分的图片进行识别
+ # 去掉收尾的'"'
+ if not gt:
+ return False, gt
+ if gt.startswith(r'$$') and gt.endswith(r'$$'):
+ gt = gt[2:-2]
+ if '$$' not in gt:
+ return True, gt.strip()
+ return False, gt
+
+ # Process each image and collect results
+ predictions = []
+ ground_truths = []
+ results = []
+
+ # Apply max_samples limit
+ if max_samples > 0:
+ import random
+ random.seed(42)
+ random.shuffle(eval_data)
+
+ logger.info(f"Limited to {max_samples} samples for evaluation")
+ logger.info(f"Starting evaluation on {len(eval_data)} images...")
+
+ for i, item in enumerate(eval_data):
+ if len(results) >= max_samples:
+ break
+ img_path = item['new_img_path']
+ ground_truth = item[gt_key]
+
+ # Handle ground truth that might be a JSON string
+ if isinstance(ground_truth, str):
+ try:
+ ground_truth = json.loads(ground_truth)
+ except json.JSONDecodeError:
+ # If it's not valid JSON, use as is
+ pass
+
+ # Apply formula filtering if needed
+ is_formula, ground_truth = filter_and_clean_gt(ground_truth)
+ if not is_formula:
+ continue
+
+ # Prepend prefix_img_dir to img_path if it's not an absolute path
+ if not os.path.isabs(img_path):
+ img_path = os.path.join(prefix_img_dir, img_path)
+
+ logger.info(f"Processing image {i+1}/{len(eval_data)}: {img_path}")
+
+ try:
+ # Check if image file exists
+ if not os.path.exists(img_path):
+ logger.warning(f"Image file not found: {img_path}")
+ continue
+
+ # Recognize text
+ prediction = p2t.recognize(img_path, file_type=file_type, **rec_kwargs)
+
+ # Convert to string if needed
+ if not isinstance(prediction, str):
+ if hasattr(prediction, 'to_markdown'):
+ prediction = prediction.to_markdown()
+ else:
+ prediction = str(prediction)
+
+ predictions.append(prediction)
+ ground_truths.append(ground_truth)
+
+ # Calculate individual CER
+ cer = calculate_cer(prediction, ground_truth)
+
+ result = {
+ 'img_path': img_path,
+ 'ground_truth': ground_truth,
+ 'prediction': prediction,
+ 'cer': cer
+ }
+ results.append(result)
+
+ logger.info(f"Image {img_path} CER: {cer:.4f}")
+
+ except Exception as e:
+ logger.error(f"Error processing image {img_path}: {e}")
+ continue
+
+ # resort results by cer
+ # results.sort(key=lambda x: x['cer'], reverse=True)
+
+ # Calculate overall CER
+ if predictions and ground_truths:
+ cer_stats = calculate_cer_batch(predictions, ground_truths)
+
+ # Prepare final results
+ evaluation_results = {
+ 'summary': {
+ 'total_samples': len(results),
+ 'average_cer': cer_stats['average_cer'],
+ 'individual_cers': cer_stats['individual_cers']
+ },
+ 'detailed_results': results
+ }
+
+ # Save results
+ try:
+ with open(output_json, 'w', encoding='utf-8') as f:
+ json.dump(evaluation_results, f, ensure_ascii=False, indent=2)
+ logger.info(f"Evaluation results saved to: {output_json}")
+ except Exception as e:
+ logger.error(f"Failed to save evaluation results: {e}")
+
+ # Print summary
+ logger.info("=" * 50)
+ logger.info("EVALUATION SUMMARY")
+ logger.info("=" * 50)
+ logger.info(f"Total samples processed: {len(results)}")
+ logger.info(f"Average CER: {cer_stats['average_cer']:.4f}")
+ logger.info(f"Best CER: {min(cer_stats['individual_cers']):.4f}")
+ logger.info(f"Worst CER: {max(cer_stats['individual_cers']):.4f}")
+ logger.info("=" * 50)
+
+ else:
+ logger.error("No valid predictions generated")
+
+ # Save results to Excel with embedded images (if requested)
+ if output_excel and results:
+ excel_success = save_evaluation_results_to_excel_with_images(
+ results=results,
+ output_file=output_excel,
+ img_path_key='img_path',
+ gt_key='ground_truth',
+ pred_key='prediction',
+ cer_key='cer',
+ max_img_width=max_img_width,
+ max_img_height=max_img_height
+ )
+ if excel_success:
+ logger.info(f"Excel file with embedded images saved to: {output_excel}")
+ else:
+ logger.warning("Failed to save Excel file with embedded images")
+
+ # Save results to HTML report with embedded images (if requested)
+ if output_html and results:
+ html_success = create_html_report_with_images(
+ results=results,
+ output_file=output_html,
+ img_path_key='img_path',
+ gt_key='ground_truth',
+ pred_key='prediction',
+ cer_key='cer',
+ max_img_width=max_img_width,
+ max_img_height=max_img_height
+ )
+ if html_success:
+ logger.info(f"HTML report with embedded images saved to: {output_html}")
+ else:
+ logger.warning("Failed to save HTML report with embedded images")
+
+
+@cli.command('serve')
+@click.option(
+ "-l",
+ "--languages",
+ type=str,
+ default='en,ch_sim',
+ help="Language Codes for Text-OCR to recognize, separated by commas",
+ show_default=True,
+)
+@click.option(
+ "--layout-config",
+ type=str,
+ default=None,
+ help="Configuration information for the layout parser model, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--mfd-config",
+ type=str,
+ default=None,
+ help="Configuration information for the MFD model, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--formula-ocr-config",
+ type=str,
+ default=None,
+ help="Configuration information for the Latex-OCR mathematical formula recognition model. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--text-ocr-config",
+ type=str,
+ default=None,
+ help="Configuration information for Text-OCR recognition, in JSON string format. Default: `None`, meaning using the default configuration",
+ show_default=True,
+)
+@click.option(
+ "--enable-formula/--disable-formula",
+ default=True,
+ help="Whether to enable formula recognition",
+ show_default=True,
+)
+@click.option(
+ "--enable-table/--disable-table",
+ default=True,
+ help="Whether to enable table recognition",
+ show_default=True,
+)
+@click.option(
+ "-d",
+ "--device",
+ help="Choose to run the code using `cpu`, `gpu`, or a specific GPU like `cuda:0`",
+ type=str,
+ default='cpu',
+ show_default=True,
+)
+@click.option(
+ "-o",
+ "--output-md-root-dir",
+ default='output-md-root',
+ help="Markdown output root directory for the recognized text results. Only effective when `file-type` is `pdf` or `page`",
+ show_default=True,
+)
+@click.option(
+ '-H', '--host', type=str, default='0.0.0.0', help='server host', show_default=True,
+)
+@click.option(
+ '-p', '--port', type=int, default=8503, help='server port', show_default=True,
+)
+@click.option(
+ '--reload',
+ is_flag=True,
+ help='whether to reload the server when the codes have been changed',
+ show_default=True,
+)
+@click.option(
+ "--log-level",
+ default='INFO',
+ help="Log Level, such as `INFO`, `DEBUG`",
+ show_default=True,
+)
+def serve(
+ languages,
+ layout_config,
+ mfd_config,
+ formula_ocr_config,
+ text_ocr_config,
+ enable_formula,
+ enable_table,
+ device,
+ output_md_root_dir,
+ host,
+ port,
+ reload,
+ log_level,
+):
+ """Start the HTTP service."""
+ from pix2text.serve import start_server
+
+ logger = set_logger(log_level=log_level)
+
+ analyzer_config = json.loads(mfd_config) if mfd_config else {}
+ formula_ocr_config = json.loads(formula_ocr_config) if formula_ocr_config else {}
+ languages = [lang.strip() for lang in languages.split(',') if lang.strip()]
+ text_ocr_config = json.loads(text_ocr_config) if text_ocr_config else {}
+
+ layout_config = json.loads(layout_config) if layout_config else {}
+ text_formula_config = {
+ 'languages': languages, # 'en,ch_sim
+ 'mfd': analyzer_config,
+ 'formula': formula_ocr_config,
+ 'text': text_ocr_config,
+ }
+ total_config = {
+ 'layout': layout_config,
+ 'text_formula': text_formula_config,
+ }
+ p2t_config = dict(
+ total_configs=total_config,
+ enable_formula=enable_formula,
+ enable_table=enable_table,
+ device=device,
+ )
+ api = Process(
+ target=start_server,
+ kwargs={
+ 'p2t_config': p2t_config,
+ 'output_md_root_dir': output_md_root_dir,
+ 'host': host,
+ 'port': port,
+ 'reload': reload,
+ },
+ )
+ api.start()
+ api.join()
+
+
+if __name__ == "__main__":
+ cli()
diff --git a/pix2text/consts.py b/pix2text/consts.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ff373278f71248b8787b2ff384d217c85688b5f
--- /dev/null
+++ b/pix2text/consts.py
@@ -0,0 +1,196 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+import os
+import logging
+from collections import OrderedDict
+from copy import copy, deepcopy
+from typing import Set, Tuple, Dict, Any, Optional
+
+from .__version__ import __version__
+
+logger = logging.getLogger(__name__)
+
+# 模型版本只对应到第二层，第三层的改动表示模型兼容。
+# 如: __version__ = '1.0.*'，对应的 MODEL_VERSION 都是 '1.0'
+MODEL_VERSION = '.'.join(__version__.split('.', maxsplit=2)[:2])
+DOWNLOAD_SOURCE = os.environ.get('PIX2TEXT_DOWNLOAD_SOURCE', 'HF')
+
+CN_OSS_ENDPOINT = (
+ "https://sg-models.oss-cn-beijing.aliyuncs.com/pix2text/%s/" % MODEL_VERSION
+)
+
+
+def format_model_info(info: dict) -> dict:
+ out_dict = copy(info)
+ out_dict['cn_oss'] = CN_OSS_ENDPOINT
+ return out_dict
+
+
+class AvailableModels(object):
+ P2T_SPACE = '__pix2text__'
+
+ FREE_MODELS = OrderedDict(
+ {
+ ('mfr', 'onnx'): {
+ 'filename': 'p2t-mfr-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr',
+ 'local_model_id': 'mfr-onnx',
+ },
+ ('mfd', 'onnx'): {
+ 'filename': 'p2t-mfd-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd',
+ 'local_model_id': 'mfd-onnx',
+ },
+ ('mfd-1.5', 'onnx'): {
+ # 'filename': 'p2t-mfd-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-1.5',
+ 'local_model_id': 'mfd-1.5-onnx',
+ },
+ ('mfr-1.5', 'onnx'): {
+ # 'filename': 'p2t-mfr-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-1.5',
+ 'local_model_id': 'mfr-1.5-onnx',
+ },
+ }
+ )
+
+ PAID_MODELS = OrderedDict(
+ {
+ ('mfr', 'pytorch'): {
+ 'filename': 'p2t-mfr-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-pytorch',
+ 'local_model_id': 'mfr-pytorch',
+ },
+ ('mfr-pro', 'onnx'): {
+ 'filename': 'p2t-mfr-pro-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-pro',
+ 'local_model_id': 'mfr-pro-onnx',
+ },
+ ('mfr-pro', 'pytorch'): {
+ 'filename': 'p2t-mfr-pro-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-pro-pytorch',
+ 'local_model_id': 'mfr-pro-pytorch',
+ },
+ ('mfr-plus', 'onnx'): {
+ 'filename': 'p2t-mfr-plus-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-plus',
+ 'local_model_id': 'mfr-plus-onnx',
+ },
+ ('mfr-plus', 'pytorch'): {
+ 'filename': 'p2t-mfr-plus-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-plus-pytorch',
+ 'local_model_id': 'mfr-plus-pytorch',
+ },
+ ('mfd', 'pytorch'): {
+ 'filename': 'p2t-mfd-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-pytorch',
+ 'local_model_id': 'mfd-pytorch',
+ },
+ ('mfd-advanced', 'onnx'): {
+ 'filename': 'p2t-mfd-advanced-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-advanced',
+ 'local_model_id': 'mfd-advanced-onnx',
+ },
+ ('mfd-advanced', 'pytorch'): {
+ 'filename': 'p2t-mfd-advanced-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-advanced-pytorch',
+ 'local_model_id': 'mfd-advanced-pytorch',
+ },
+ ('mfd-pro', 'onnx'): {
+ 'filename': 'p2t-mfd-pro-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-pro',
+ 'local_model_id': 'mfd-pro-onnx',
+ },
+ ('mfd-pro', 'pytorch'): {
+ 'filename': 'p2t-mfd-pro-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-pro-pytorch',
+ 'local_model_id': 'mfd-pro-pytorch',
+ },
+ ('mfd-1.5', 'pytorch'): {
+ # 'filename': 'p2t-mfd-1.5-pytorch.zip',
+ 'hf_model_id': 'breezedeus/pix2text-mfd-1.5-pytorch',
+ 'local_model_id': 'mfd-1.5-pytorch',
+ },
+ ('mfd-advanced-1.5', 'onnx'): {
+ # 'filename': 'p2t-mfd-advanced-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-advanced-1.5',
+ 'local_model_id': 'mfd-advanced-1.5-onnx',
+ },
+ ('mfd-advanced-1.5', 'pytorch'): {
+ # 'filename': 'p2t-mfd-advanced-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-advanced-1.5-pytorch',
+ 'local_model_id': 'mfd-advanced-1.5-pytorch',
+ },
+ ('mfd-pro-1.5', 'onnx'): {
+ # 'filename': 'p2t-mfd-pro-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-pro-1.5',
+ 'local_model_id': 'mfd-pro-1.5-onnx',
+ },
+ ('mfd-pro-1.5', 'pytorch'): {
+ # 'filename': 'p2t-mfd-pro-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfd-pro-1.5-pytorch',
+ 'local_model_id': 'mfd-pro-1.5-pytorch',
+ },
+ ('mfr-1.5', 'pytorch'): {
+ # 'filename': 'p2t-mfr-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-1.5-pytorch',
+ 'local_model_id': 'mfr-1.5-pytorch',
+ },
+ ('mfr-pro-1.5', 'onnx'): {
+ # 'filename': 'p2t-mfr-pro-onnx.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-pro-1.5',
+ 'local_model_id': 'mfr-pro-1.5-onnx',
+ },
+ ('mfr-pro-1.5', 'pytorch'): {
+ # 'filename': 'p2t-mfr-pro-pytorch.zip', # download the file from CN OSS
+ 'hf_model_id': 'breezedeus/pix2text-mfr-pro-1.5-pytorch',
+ 'local_model_id': 'mfr-pro-1.5-pytorch',
+ },
+ }
+ )
+
+ P2T_MODELS = deepcopy(FREE_MODELS)
+ P2T_MODELS.update(PAID_MODELS)
+ OUTER_MODELS = {}
+
+ def all_models(self) -> Set[Tuple[str, str]]:
+ return set(self.P2T_MODELS.keys()) | set(self.OUTER_MODELS.keys())
+
+ def __contains__(self, model_name_backend: Tuple[str, str]) -> bool:
+ return model_name_backend in self.all_models()
+
+ def register_models(self, model_dict: Dict[Tuple[str, str], Any], space: str):
+ assert not space.startswith('__')
+ for key, val in model_dict.items():
+ if key in self.P2T_MODELS or key in self.OUTER_MODELS:
+ logger.warning(
+ 'model %s has already existed, and will be ignored' % key
+ )
+ continue
+ val = deepcopy(val)
+ val['space'] = space
+ self.OUTER_MODELS[key] = val
+
+ def get_space(self, model_name, model_backend) -> Optional[str]:
+ if (model_name, model_backend) in self.P2T_MODELS:
+ return self.P2T_SPACE
+ elif (model_name, model_backend) in self.OUTER_MODELS:
+ return self.OUTER_MODELS[(model_name, model_backend)]['space']
+ return self.P2T_SPACE
+
+ def get_info(self, model_name, model_backend) -> Optional[dict]:
+ if (model_name, model_backend) in self.P2T_MODELS:
+ info = self.P2T_MODELS[(model_name, model_backend)]
+ elif (model_name, model_backend) in self.OUTER_MODELS:
+ info = self.OUTER_MODELS[(model_name, model_backend)]
+ else:
+ logger.warning(
+ 'no url is found for model %s' % ((model_name, model_backend),)
+ )
+ return None
+ info = format_model_info(info)
+ return info
+
+
+AVAILABLE_MODELS = AvailableModels()
diff --git a/pix2text/doc_xl_layout/__init__.py b/pix2text/doc_xl_layout/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbbe308f471b4ef5f62164ff9d44559ad7091b3d
--- /dev/null
+++ b/pix2text/doc_xl_layout/__init__.py
@@ -0,0 +1,4 @@
+# coding: utf-8
+# This whole directory is adapted from https://github.com/AlibabaResearch/AdvancedLiterateMachinery.
+# Thanks to the authors.
+from .doc_xl_layout_parser import DocXLayoutParser
\ No newline at end of file
diff --git a/pix2text/doc_xl_layout/detectors/__init__.py b/pix2text/doc_xl_layout/detectors/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pix2text/doc_xl_layout/detectors/base_detector_subfield.py b/pix2text/doc_xl_layout/detectors/base_detector_subfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..3263d72d504a40cb3c58a33e4a14b77ffd8f5f9b
--- /dev/null
+++ b/pix2text/doc_xl_layout/detectors/base_detector_subfield.py
@@ -0,0 +1,206 @@
+# coding: utf-8
+import os
+import time
+
+import cv2
+import numpy as np
+import torch
+from ..models.model import create_model, load_model
+
+# from ..utils.debugger import Debugger
+from ..utils.image import get_affine_transform
+
+
+class BaseDetector(object):
+ def __init__(self, opt):
+ # if opt.gpus[0] >= 0:
+ # opt.device = torch.device('cuda')
+ # else:
+ # opt.device = torch.device('cpu')
+
+ self.model = create_model(opt.arch, opt.heads, opt.head_conv, opt.convert_onnx, {})
+ self.model = load_model(self.model, opt.load_model)
+ self.model = self.model.to(opt.device)
+ self.model.eval()
+
+ self.mean = np.array(opt.mean, dtype=np.float32).reshape(1, 1, 3)
+ self.std = np.array(opt.std, dtype=np.float32).reshape(1, 1, 3)
+ self.max_per_image = opt.K
+ self.num_classes = opt.num_classes
+ self.scales = opt.test_scales
+ self.opt = opt
+ self.pause = True
+
+ def pre_process(self, image, scale, meta=None):
+ height, width = image.shape[0:2]
+ new_height = int(height * scale)
+ new_width = int(width * scale)
+ if self.opt.fix_res:
+ inp_height, inp_width = self.opt.input_h, self.opt.input_w
+ c = np.array([new_width / 2., new_height / 2.], dtype=np.float32)
+ s = max(height, width) * 1.0
+ else:
+ inp_height = (new_height | self.opt.pad) # + 1
+ inp_width = (new_width | self.opt.pad) # + 1
+ c = np.array([new_width // 2, new_height // 2], dtype=np.float32)
+ s = np.array([inp_width, inp_height], dtype=np.float32)
+
+ trans_input = get_affine_transform(c, s, 0, [inp_width, inp_height])
+ resized_image = cv2.resize(image, (new_width, new_height))
+ inp_image = cv2.warpAffine(
+ resized_image, trans_input, (inp_width, inp_height),
+ flags=cv2.INTER_LINEAR)
+ vis_image = inp_image
+ # import pdb; pdb.set_trace()
+ inp_image = ((inp_image / 255. - self.mean) / self.std).astype(np.float32)
+
+ images = inp_image.transpose(2, 0, 1).reshape(1, 3, inp_height, inp_width)
+ if self.opt.flip_test:
+ images = np.concatenate((images, images[:, :, :, ::-1]), axis=0)
+ images = torch.from_numpy(images)
+ meta = {'c': c, 's': s,
+ 'input_height': inp_height,
+ 'input_width': inp_width,
+ 'vis_image': vis_image,
+ 'out_height': inp_height // self.opt.down_ratio,
+ 'out_width': inp_width // self.opt.down_ratio}
+ return images, meta
+
+ def resize(self, image):
+ h, w, _ = image.shape
+ scale = self.opt.input_h / (max(w, h) + 1e-4)
+ image = cv2.resize(image, (int(w * scale), int(h * scale)))
+ image = cv2.copyMakeBorder(image, 0, self.opt.input_h - int(h * scale), 0, self.opt.input_h - int(w * scale),
+ cv2.BORDER_CONSTANT, value=[0, 0, 0])
+ return image, scale
+
+ def process(self, images, return_time=False):
+ raise NotImplementedError
+
+ def post_process(self, dets, meta, scale=1):
+ raise NotImplementedError
+
+ def merge_outputs(self, detections):
+ raise NotImplementedError
+
+ def debug(self, debugger, images, dets, output, scale=1):
+ raise NotImplementedError
+
+ def show_results(self, debugger, image, results):
+ raise NotImplementedError
+
+ def ps_convert_minmax(self, results):
+ detection = {}
+ for j in range(1, self.num_classes + 1):
+ detection[j] = []
+ for j in range(1, self.num_classes + 1):
+ for bbox in results[j]:
+ if bbox[8] < self.opt.scores_thresh:
+ continue
+ minx = max(min(bbox[0], bbox[2], bbox[4], bbox[6]), 0)
+ miny = max(min(bbox[1], bbox[3], bbox[5], bbox[7]), 0)
+ maxx = max(bbox[0], bbox[2], bbox[4], bbox[6])
+ maxy = max(bbox[1], bbox[3], bbox[5], bbox[7])
+ detection[j].append([minx, miny, maxx, maxy, bbox[8], bbox[-1]])
+ for j in range(1, self.num_classes + 1):
+ detection[j] = np.array(detection[j])
+ return detection
+
+ def Duplicate_removal(self, results):
+ bbox = []
+ for box in results:
+ if box[8] > self.opt.scores_thresh:
+ # for i in range(8):
+ # if box[i] < 0:
+ # box[i] = 0
+ # if box[i]>self.opt.input_h:
+ # box[i]=self.opt.input_h
+ bbox.append(box)
+ if len(bbox) > 0:
+ return np.array(bbox)
+ else:
+ return np.array([[0] * 12])
+
+ def run(self, image_or_path_or_tensor, meta=None):
+ load_time, pre_time, net_time, dec_time, post_time = 0, 0, 0, 0, 0
+ merge_time, tot_time = 0, 0
+ # debugger = Debugger(dataset=self.opt.dataset, ipynb=(self.opt.debug == 3), num_classes=self.opt.num_classes,
+ # theme=self.opt.debugger_theme)
+ start_time = time.time()
+ pre_processed = False
+ if isinstance(image_or_path_or_tensor, np.ndarray):
+ image = image_or_path_or_tensor
+ elif type(image_or_path_or_tensor) == type(''):
+ image = cv2.imread(image_or_path_or_tensor)
+ else:
+ image = image_or_path_or_tensor['image'][0].numpy()
+ pre_processed_images = image_or_path_or_tensor
+ pre_processed = True
+
+ loaded_time = time.time()
+ load_time += (loaded_time - start_time)
+
+ detections = []
+ for scale in self.scales:
+ scale_start_time = time.time()
+ if not pre_processed:
+ images, meta = self.pre_process(image, scale, meta)
+ else:
+ images = pre_processed_images['images'][scale][0]
+ meta = pre_processed_images['meta'][scale]
+ meta = {k: v.numpy()[0] for k, v in meta.items()}
+
+ # import ipdb;ipdb.set_trace()
+ # images = np.load('data.npy').astype(np.float32)
+ # images = torch.from_numpy(images)
+
+ images = images.to(self.opt.device)
+ # torch.cuda.synchronize()
+ pre_process_time = time.time()
+ pre_time += pre_process_time - scale_start_time
+ output, dets, dets_sub, corner, forward_time = self.process(images, return_time=True)
+ # torch.cuda.synchronize()
+ net_time += forward_time - pre_process_time
+ decode_time = time.time()
+ dec_time += decode_time - forward_time
+
+ # if self.opt.debug >= 2:
+ # self.debug(debugger, images, dets, output, scale)
+
+ dets, corner = self.post_process(dets, corner, meta, scale)
+ for j in range(1, self.num_classes + 1):
+ dets[j] = self.Duplicate_removal(dets[j])
+
+ # add sub
+ dets_sub, corner = self.post_process(dets_sub, corner, meta, scale)
+ for j in range(1, self.num_classes + 1):
+ dets_sub[j] = self.Duplicate_removal(dets_sub[j])
+
+ # import ipdb;ipdb.set_trace()
+ # torch.cuda.synchronize()
+ post_process_time = time.time()
+ post_time += post_process_time - decode_time
+
+ dets[12] = dets_sub[12]
+ dets[13] = dets_sub[13]
+
+ detections.append(dets)
+
+ results = self.merge_outputs(detections)
+ # torch.cuda.synchronize()
+ end_time = time.time()
+ merge_time += end_time - post_process_time
+ tot_time += end_time - start_time
+
+ # import pdb; pdb.set_trace()
+ if self.opt.debug >= 1:
+ if isinstance(image_or_path_or_tensor, str):
+ image_name = os.path.basename(image_or_path_or_tensor)
+ else:
+ print("--> warning: use demo.py for a better visualization")
+ image_name = "{}.jpg".format(time.time())
+ # self.show_results(debugger, image, results, corner, image_name)
+
+ return {'results': results, 'tot': tot_time, 'load': load_time,
+ 'pre': pre_time, 'net': net_time, 'dec': dec_time, 'corner': corner,
+ 'post': post_time, 'merge': merge_time, 'output': output}
diff --git a/pix2text/doc_xl_layout/detectors/ctdet_subfield.py b/pix2text/doc_xl_layout/detectors/ctdet_subfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..aee3d617461adbb188b4dafd3f9ed5dcf8af7634
--- /dev/null
+++ b/pix2text/doc_xl_layout/detectors/ctdet_subfield.py
@@ -0,0 +1,225 @@
+# coding: utf-8
+import time
+import numpy as np
+import torch
+
+# from external.nms import soft_nms
+from ..external.shapelyNMS import pnms
+from ..models.decode import ctdet_4ps_decode, ctdet_cls_decode
+from ..models.utils import flip_tensor
+from ..utils.post_process import ctdet_4ps_post_process
+from .base_detector_subfield import BaseDetector
+
+
+class CtdetDetector_Subfield(BaseDetector):
+ def __init__(self, opt):
+ super(CtdetDetector_Subfield, self).__init__(opt)
+
+ def process(self, images, return_time=False):
+ # import ipdb;ipdb.set_trace()
+ with torch.no_grad():
+ output = self.model(images)[-1]
+ if self.opt.convert_onnx == 1:
+ # torch.cuda.synchronize()
+ inputs = ['data']
+ outputs = [
+ 'hm.0.sigmoid',
+ 'hm.0.maxpool',
+ 'cls.0.sigmoid',
+ 'ftype.0.sigmoid',
+ 'wh.2',
+ 'reg.2',
+ 'hm_sub.0.sigmoid',
+ 'hm_sub.0.maxpool',
+ 'wh_sub.2',
+ 'reg_sub.2',
+ ]
+ dynamic_axes = {
+ 'data': {2: 'h', 3: 'w'},
+ 'hm.0.sigmoid': {2: 'H', 3: 'W'},
+ 'hm.0.maxpool': {2: 'H', 3: 'W'},
+ 'cls.0.sigmoid': {2: 'H', 3: 'W'},
+ 'ftype.0.sigmoid': {2: 'H', 3: 'W'},
+ 'wh.2': {2: 'H', 3: 'W'},
+ 'reg.2': {2: 'H', 3: 'W'},
+ 'hm_sub.0.sigmoid': {2: 'H', 3: 'W'},
+ 'hm_sub.0.maxpool': {2: 'H', 3: 'W'},
+ 'wh_sub.2': {2: 'H', 3: 'W'},
+ 'reg_sub.2': {2: 'H', 3: 'W'},
+ }
+
+ onnx_path = self.opt.onnx_path
+ if self.opt.onnx_path == "auto":
+ onnx_path = "{}_{}cls_{}ftype.onnx".format(
+ self.opt.dataset,
+ self.opt.num_classes,
+ self.opt.num_secondary_classes,
+ )
+
+ torch.onnx.export(
+ self.model,
+ images,
+ onnx_path,
+ input_names=inputs,
+ output_names=outputs,
+ dynamic_axes=dynamic_axes,
+ do_constant_folding=True,
+ opset_version=10,
+ )
+ print("--> info: onnx is saved at: {}".format(onnx_path))
+ cls = output['cls_sigmoid']
+ hm = output['hm_sigmoid']
+ ftype = output['ftype_sigmoid']
+
+ # add sub
+ hm_sub = output['hm_sigmoid_sub']
+ else:
+ hm = output['hm'].sigmoid_()
+ cls = output['cls'].sigmoid_()
+ ftype = output['ftype'].sigmoid_()
+
+ # add sub
+ hm_sub = output['hm_sub'].sigmoid_()
+
+ wh = output['wh']
+ reg = output['reg'] if self.opt.reg_offset else None
+
+ # add sub
+ wh_sub = output['wh_sub']
+ reg_sub = output['reg_sub'] if self.opt.reg_offset else None
+
+ if self.opt.flip_test:
+ hm = (hm[0:1] + flip_tensor(hm[1:2])) / 2
+ wh = (wh[0:1] + flip_tensor(wh[1:2])) / 2
+ reg = reg[0:1] if reg is not None else None
+ # torch.cuda.synchronize()
+ forward_time = time.time()
+ # return dets [bboxes, scores, clses]
+ # breakpoint()
+ dets, inds = ctdet_4ps_decode(hm, wh, reg=reg, K=self.opt.K)
+
+ # add sub
+ dets_sub, inds_sub = ctdet_4ps_decode(
+ hm_sub, wh_sub, reg=reg_sub, K=self.opt.K
+ )
+
+ box_cls = ctdet_cls_decode(cls, inds)
+ box_ftype = ctdet_cls_decode(ftype, inds)
+ clses = torch.argmax(box_cls, dim=2, keepdim=True)
+ ftypes = torch.argmax(box_ftype, dim=2, keepdim=True)
+ dets = np.concatenate(
+ (
+ dets.detach().cpu().numpy(),
+ clses.detach().cpu().numpy(),
+ ftypes.detach().cpu().numpy(),
+ ),
+ axis=2,
+ )
+ dets = np.array(dets)
+
+ # add subfield
+ dets_sub = np.concatenate(
+ (
+ dets_sub.detach().cpu().numpy(),
+ clses.detach().cpu().numpy(),
+ ftypes.detach().cpu().numpy(),
+ ),
+ axis=2,
+ )
+ dets_sub = np.array(dets_sub)
+ dets_sub[:, :, -3] += 11
+
+ corner = 0
+
+ if return_time:
+ return output, dets, dets_sub, corner, forward_time
+ else:
+ return output, dets, dets_sub
+
+ def post_process(self, dets, corner, meta, scale=1):
+ if self.opt.nms:
+ detn = pnms(dets[0], self.opt.scores_thresh)
+ if detn.shape[0] > 0:
+ dets = detn.reshape(1, -1, detn.shape[1])
+ k = dets.shape[2] if dets.shape[1] != 0 else 0
+ if dets.shape[1] != 0:
+ dets = dets.reshape(1, -1, dets.shape[2])
+ # return dets is list and what in dets is dict. key of dict is classes, value of dict is [bbox,score]
+ dets = ctdet_4ps_post_process(
+ dets.copy(),
+ [meta['c']],
+ [meta['s']],
+ meta['out_height'],
+ meta['out_width'],
+ self.opt.num_classes,
+ )
+ for j in range(1, self.num_classes + 1):
+ dets[0][j] = np.array(dets[0][j], dtype=np.float32).reshape(-1, k)
+ dets[0][j][:, :8] /= scale
+ else:
+ ret = {}
+ dets = []
+ for j in range(1, self.num_classes + 1):
+ ret[j] = np.array([0] * k, dtype=np.float32) # .reshape(-1, k)
+ dets.append(ret)
+ return dets[0], corner
+
+ def merge_outputs(self, detections):
+ results = {}
+ for j in range(1, self.num_classes + 1):
+ results[j] = np.concatenate(
+ [detection[j] for detection in detections], axis=0
+ ).astype(np.float32)
+ # if len(self.scales) > 1 or self.opt.nms:
+ # results[j] = pnms(results[j],self.opt.nms_thresh)
+ shape_num = 0
+ for j in range(1, self.num_classes + 1):
+ shape_num = shape_num + len(results[j])
+ if shape_num != 0:
+ # print(np.array(results[1]))
+ scores = np.hstack(
+ [results[j][:, 8] for j in range(1, self.num_classes + 1)]
+ )
+ else:
+ scores = []
+ if len(scores) > self.max_per_image:
+ kth = len(scores) - self.max_per_image
+ thresh = np.partition(scores, kth)[kth]
+ for j in range(1, self.num_classes + 1):
+ keep_inds = results[j][:, 8] >= thresh
+ results[j] = results[j][keep_inds]
+ return results
+
+ def debug(self, debugger, images, dets, output, scale=1):
+ # detection = dets.detach().cpu().numpy().copy()
+ detection = dets.copy()
+ detection[:, :, :8] *= self.opt.down_ratio
+ for i in range(1):
+ img = images[i].detach().cpu().numpy().transpose(1, 2, 0)
+ img = ((img * self.std + self.mean) * 255).astype(np.uint8)
+ pred = debugger.gen_colormap(output['hm'][i].detach().cpu().numpy())
+ debugger.add_blend_img(img, pred, 'pred_hm_{:.1f}'.format(scale))
+ debugger.add_img(img, img_id='out_pred_{:.1f}'.format(scale))
+ # pdb.set_trace()
+ for k in range(len(dets[i])):
+ if detection[i, k, 8] > self.opt.center_thresh:
+ debugger.add_4ps_coco_bbox(
+ detection[i, k, :8],
+ detection[i, k, -1],
+ detection[i, k, 8],
+ img_id='out_pred_{:.1f}'.format(scale),
+ )
+
+ def show_results(self, debugger, image, results, Corners, image_name):
+ debugger.add_img(image, img_id='ctdet')
+ count = 0
+ for j in range(1, self.num_classes + 1):
+ for bbox in results[j]:
+ if bbox[8] > self.opt.scores_thresh:
+ count += 1
+ # print("bbox info:",j-1, bbox.tolist())
+ # print(j-1)
+ debugger.add_4ps_coco_bbox(
+ bbox, j - 1, bbox[8], show_txt=True, img_id='ctdet'
+ )
+ debugger.save_all_imgs(image_name, './outputs/')
diff --git a/pix2text/doc_xl_layout/detectors/detector_factory.py b/pix2text/doc_xl_layout/detectors/detector_factory.py
new file mode 100644
index 0000000000000000000000000000000000000000..30080aaf46e75e64defa848e1ff0811c524e3ffc
--- /dev/null
+++ b/pix2text/doc_xl_layout/detectors/detector_factory.py
@@ -0,0 +1,7 @@
+# coding: utf-8
+
+from .ctdet_subfield import CtdetDetector_Subfield
+
+detector_factory = {
+ 'ctdet_subfield': CtdetDetector_Subfield
+}
diff --git a/pix2text/doc_xl_layout/doc_xl_layout_parser.py b/pix2text/doc_xl_layout/doc_xl_layout_parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..62820d6935e070fe466e3b60363fc069bb169138
--- /dev/null
+++ b/pix2text/doc_xl_layout/doc_xl_layout_parser.py
@@ -0,0 +1,478 @@
+# coding: utf-8
+# Adapted from https://github.com/AlibabaResearch/AdvancedLiterateMachinery
+import json
+import os
+import shutil
+from collections import defaultdict
+from copy import deepcopy, copy
+from pathlib import Path
+import logging
+from typing import Union, List, Dict, Any, Optional
+
+import numpy as np
+from PIL import Image
+
+from .opts import opts
+from .huntie_subfield import Huntie_Subfield
+from .detectors.detector_factory import detector_factory
+from .wrapper import wrap_result
+from ..consts import MODEL_VERSION
+from ..layout_parser import LayoutParser, ElementType
+from ..utils import (
+ select_device,
+ read_img,
+ data_dir,
+ save_layout_img,
+ clipbox,
+ overlap,
+ box2list,
+ x_overlap,
+ merge_boxes,
+ prepare_model_files2,
+)
+
+logger = logging.getLogger(__name__)
+
+CATEGORIES = {
+ "title": 0,
+ "figure": 1,
+ "plain text": 2,
+ "header": 3,
+ "page number": 4,
+ "footnote": 5,
+ "footer": 6,
+ "table": 7,
+ "table caption": 8,
+ "figure caption": 9,
+ "equation": 10,
+ "full column": 11,
+ "sub column": 12,
+}
+CATEGORY_MAPPING = [''] * len(CATEGORIES)
+for cate, idx in CATEGORIES.items():
+ CATEGORY_MAPPING[idx] = cate
+
+
+class DocXLayoutOutput:
+ def __init__(self, layout_detection_info, subfield_detection_info, message=''):
+ self.layout_detection_info = layout_detection_info
+ self.subfield_detection_info = subfield_detection_info
+ self.message = message
+
+ def to_json(self):
+ return wrap_result(
+ self.layout_detection_info, self.subfield_detection_info, CATEGORY_MAPPING
+ )
+
+
+class DocXLayoutParser(LayoutParser):
+ ignored_types = {'footnote', 'footer', 'page number'}
+ type_mappings = {
+ 'title': ElementType.TITLE,
+ 'figure': ElementType.FIGURE,
+ 'plain text': ElementType.TEXT,
+ 'header': ElementType.TEXT,
+ 'table': ElementType.TABLE,
+ 'table caption': ElementType.TEXT,
+ 'figure caption': ElementType.TEXT,
+ 'equation': ElementType.FORMULA,
+ }
+ # types that are isolated and usually don't cross different columns. They should not be merged with other elements
+ is_isolated = {'header', 'table caption', 'figure caption', 'equation'}
+
+ def __init__(
+ self,
+ device: str = None,
+ model_fp: Optional[str] = None,
+ root: Union[str, Path] = data_dir(),
+ **kwargs,
+ ):
+ if model_fp is None:
+ model_fp = self._prepare_model_files(root, None)
+ new_params = {
+ 'task': 'ctdet_subfield',
+ 'arch': 'dlav0subfield_34',
+ 'input_res': 768,
+ 'num_classes': 13,
+ 'scores_thresh': kwargs.get('scores_thresh', 0.35),
+ 'load_model': str(model_fp),
+ 'debug': kwargs.get('debug', 0),
+ }
+
+ opt = opts().parse(new_params)
+ opt = opts().update_dataset_info_and_set_heads(opt, Huntie_Subfield)
+ opt.device = select_device(device)
+
+ Detector = detector_factory[opt.task]
+ detector = Detector(opt)
+ self.detector = detector
+ self.opt = opt
+ logger.debug("DocXLayoutParser parameters %s", self.opt)
+
+ @classmethod
+ def from_config(cls, configs: Optional[dict] = None, device: str = None, **kwargs):
+ configs = copy(configs or {})
+ device = select_device(device)
+ model_fp = configs.pop('model_fp', None)
+ root = configs.pop('root', data_dir())
+ configs.pop('device', None)
+
+ return cls(device=device, model_fp=model_fp, root=root, **configs)
+
+ def _prepare_model_files(self, root, model_info):
+ model_root_dir = Path(root).expanduser() / MODEL_VERSION
+ model_dir = model_root_dir / 'layout-parser'
+ model_fp = model_dir / 'DocXLayout_231012.pth'
+ if model_fp.exists():
+ return model_fp
+ model_fp = prepare_model_files2(
+ model_fp_or_dir=model_fp,
+ remote_repo="breezedeus/pix2text-layout",
+ file_or_dir="file",
+ )
+ return model_fp
+
+ def convert_eval_format(self, all_bboxes, opt):
+ layout_detection_items = []
+ subfield_detection_items = []
+ for cls_ind in all_bboxes:
+ for box in all_bboxes[cls_ind]:
+ if box[8] < opt.scores_thresh:
+ continue
+ pts = np.round(box).tolist()[:8]
+ score = box[8]
+ category_id = box[9]
+ # direction_id = box[10]
+ # secondary_id = box[11]
+ detection = {
+ "category_id": int(category_id),
+ # "secondary_id": int(secondary_id),
+ # "direction_id": int(direction_id),
+ "poly": pts,
+ "score": float("{:.2f}".format(score)),
+ }
+ if cls_ind in (12, 13):
+ subfield_detection_items.append(detection)
+ else:
+ layout_detection_items.append(detection)
+ return layout_detection_items, subfield_detection_items
+
+ def parse(
+ self,
+ img: Union[str, Path, Image.Image],
+ table_as_image: bool = False,
+ **kwargs,
+ ) -> (List[Dict[str, Any]], Dict[str, Any]):
+ """
+
+ Args:
+ img ():
+ table_as_image ():
+ **kwargs ():
+ * save_debug_res (str): if `save_debug_res` is set, the directory to save the debug results; default value is `None`, which means not to save
+ * expansion_margin (int): expansion margin
+
+ Returns:
+
+ """
+ if isinstance(img, Image.Image):
+ img0 = img.convert('RGB')
+ else:
+ img0 = read_img(img, return_type='Image')
+ img_width, img_height = img0.size
+ try:
+ # to np.array, RGB -> BGR
+ ret = self.detector.run(np.array(img0)[:, :, ::-1])
+ layout_detection_info, subfield_detection_info = self.convert_eval_format(
+ ret['results'], self.opt
+ )
+ out = DocXLayoutOutput(
+ layout_detection_info, subfield_detection_info, message='success'
+ )
+ except Exception as e:
+ logger.warning("DocXLayoutPredictor Error %s", repr(e))
+ out = DocXLayoutOutput([], [], message=repr(e))
+
+ layout_out = out.to_json()
+ debug_dir = None
+ if kwargs.get('save_debug_res', None):
+ debug_dir = Path(kwargs.get('save_debug_res'))
+ debug_dir.mkdir(exist_ok=True, parents=True)
+ if debug_dir is not None:
+ with open(debug_dir / 'layout_out.json', 'w', encoding='utf-8') as f:
+ json.dump(
+ layout_out, f, indent=2, ensure_ascii=False,
+ )
+ if layout_out:
+ layout_out = self._preprocess_outputs(img0, layout_out)
+ layout_out, column_meta = self._format_outputs(
+ img0, layout_out, table_as_image
+ )
+ else:
+ layout_out, column_meta = [], {}
+
+ layout_out = self._merge_overlapped_boxes(layout_out)
+
+ expansion_margin = kwargs.get('expansion_margin', 8)
+ layout_out = self._expand_boxes(
+ layout_out, expansion_margin, height=img_height, width=img_width
+ )
+
+ save_layout_fp = kwargs.get(
+ 'save_layout_res',
+ debug_dir / 'layout_res.jpg' if debug_dir is not None else None,
+ )
+ if save_layout_fp:
+ element_type_list = [t for t in ElementType]
+ save_layout_img(
+ img0,
+ element_type_list,
+ layout_out,
+ save_path=save_layout_fp,
+ key='position',
+ )
+
+ return layout_out, column_meta
+
+ def _preprocess_outputs(self, img0, outs):
+ width, height = img0.size
+
+ subfields = outs['subfields']
+ for column_info in subfields:
+ layout_out = column_info['layouts']
+ if len(layout_out) < 2:
+ continue
+ for idx, cur_box_info in enumerate(layout_out[:-1]):
+ next_box_info = layout_out[idx + 1]
+ cur_box_ymax = cur_box_info['pts'][-1]
+ next_box_ymin = next_box_info['pts'][1]
+ if (
+ cur_box_info['category'] == 'figure'
+ and next_box_info['category'] == 'figure caption'
+ and -6 < next_box_ymin - cur_box_ymax < 80
+ ):
+ new_xmin = min(cur_box_info['pts'][0], next_box_info['pts'][0])
+ # new_xmin = max(new_xmin, 0, col_pts[0])
+ new_xmax = max(cur_box_info['pts'][2], next_box_info['pts'][2])
+ # new_xmax = min(new_xmax, )
+ new_ymin = max(0, cur_box_info['pts'][1])
+ new_ymax = max(cur_box_ymax, next_box_ymin - 16)
+ new_box = [
+ new_xmin,
+ new_ymin,
+ new_xmax,
+ new_ymin,
+ new_xmax,
+ new_ymax,
+ new_xmin,
+ new_ymax,
+ ]
+ layout_out[idx]['pts'] = new_box
+ # FIXME: first figure caption, then figure
+
+ return outs
+
+ def _format_outputs(self, img0, out, table_as_image: bool):
+ width, height = img0.size
+
+ column_meta = defaultdict(dict)
+ final_out = []
+ subfields = out['subfields']
+ col_number = 0
+ for column_info in subfields:
+ if column_info['category'] == 'sub column':
+ cur_col_number = col_number
+ col_number += 1
+ elif column_info['category'] == 'full column': # == 'full column'
+ cur_col_number = -1
+ else: # '其他'
+ cur_col_number = -2
+ box = clipbox(np.array(column_info['pts']).reshape(4, 2), height, width)
+ column_meta[cur_col_number]['position'] = box
+ column_meta[cur_col_number]['score'] = column_info['confidence']
+ layout_out = column_info['layouts']
+ for box_info in layout_out:
+ image_type = box_info['category']
+ isolated = image_type in self.is_isolated
+ if image_type in self.ignored_types:
+ image_type = ElementType.IGNORED
+ else:
+ image_type = self.type_mappings.get(image_type, ElementType.UNKNOWN)
+ if table_as_image and image_type == ElementType.TABLE:
+ image_type = ElementType.FIGURE
+ box = clipbox(np.array(box_info['pts']).reshape(4, 2), height, width)
+ final_out.append(
+ {
+ 'type': image_type,
+ 'position': box,
+ 'score': box_info['confidence'],
+ 'col_number': cur_col_number,
+ 'isolated': isolated,
+ }
+ )
+
+ if -2 in column_meta and -1 in column_meta:
+ filtered_out = []
+ full_column_box = column_meta[-1]['position']
+ full_column_xmin, full_column_xmax = (
+ full_column_box[0, 0],
+ full_column_box[1, 0],
+ )
+ for box_info in final_out:
+ if box_info['col_number'] != -2:
+ filtered_out.append(box_info)
+ continue
+ cur_box = box_info['position']
+ cur_box_xmin, cur_box_xmax = cur_box[0, 0], cur_box[1, 0]
+ cur_box_ymin, cur_box_ymax = cur_box[0, 1], cur_box[2, 1]
+ if (
+ box_info['type'] == ElementType.TEXT
+ and (
+ cur_box_xmax < full_column_xmin
+ or cur_box_xmin > full_column_xmax
+ )
+ and cur_box_ymax - cur_box_ymin > 5 * (cur_box_xmax - cur_box_xmin)
+ ): # unnecessary block
+ box_info['type'] = ElementType.IGNORED
+ filtered_out.append(box_info)
+
+ final_out = filtered_out
+
+ # handle abnormal elements (col_number == -2)
+ if -2 in column_meta:
+ column_meta.pop(-2)
+ # guess which column the box belongs to
+ for _box_info in final_out:
+ if _box_info['col_number'] != -2:
+ continue
+ overlap_vals = []
+ for col_number, col_info in column_meta.items():
+ overlap_val = x_overlap(_box_info, col_info, key='position')
+ overlap_vals.append([col_number, overlap_val])
+ if overlap_vals:
+ overlap_vals.sort(key=lambda x: (x[1], x[0]), reverse=True)
+ match_col_number = overlap_vals[0][0]
+ _box_info['col_number'] = match_col_number
+ else:
+ _box_info['col_number'] = 0
+
+ return final_out, column_meta
+
+ @classmethod
+ def _merge_overlapped_boxes(cls, layout_out):
+ """
+ Detected bounding boxes may overlap; merge these overlapping boxes into a single one.
+ """
+ if len(layout_out) < 2:
+ return layout_out
+ layout_out = deepcopy(layout_out)
+
+ def _overlay_vertically(box1, box2):
+ if x_overlap(box1, box2, key=None) < 0.8:
+ return False
+ box1 = box2list(box1)
+ box2 = box2list(box2)
+ # 判断是否有交集
+ if box1[3] <= box2[1] or box2[3] <= box1[1]:
+ return False
+ # 计算交集的高度
+ y_min = max(box1[1], box2[1])
+ y_max = min(box1[3], box2[3])
+ return y_max - y_min > 10
+
+ for anchor_idx, anchor_box_info in enumerate(layout_out):
+ if anchor_box_info['type'] != ElementType.TEXT or anchor_box_info.get(
+ 'used', False
+ ):
+ continue
+ for cand_idx, cand_box_info in enumerate(layout_out):
+ if anchor_idx == cand_idx:
+ continue
+ if cand_box_info['type'] != ElementType.TEXT or cand_box_info.get(
+ 'used', False
+ ):
+ continue
+ if not _overlay_vertically(
+ anchor_box_info['position'], cand_box_info['position']
+ ):
+ continue
+ anchor_box_info['position'] = merge_boxes(
+ anchor_box_info['position'], cand_box_info['position']
+ )
+ cand_box_info['used'] = True
+
+ return [box_info for box_info in layout_out if not box_info.get('used', False)]
+
+ @classmethod
+ def _expand_boxes(cls, layout_out, expansion_margin, height, width):
+ """
+ Expand boxes with some margin to get better results
+ Args:
+ layout_out (): layout_out
+ expansion_margin (int): expansion margin
+ height (int): height of the image
+ width (int): width of the image
+
+ Returns: layout_out with expanded boxes
+
+ """
+
+ def _overlap_with_some_box(idx, anchor_box):
+ # anchor_box = layout_out[idx]
+ return any(
+ [
+ overlap(anchor_box, box_info['position'], key=None) > 0
+ for idx2, box_info in enumerate(layout_out)
+ if idx2 != idx
+ ]
+ )
+
+ for idx, box_info in enumerate(layout_out):
+ if box_info['type'] not in (
+ ElementType.TEXT,
+ ElementType.TITLE,
+ ElementType.FORMULA,
+ ):
+ continue
+ if _overlap_with_some_box(idx, box_info['position']):
+ continue
+
+ # expand xmin and xmax
+ new_box = box_info['position'].copy()
+ xmin, xmax = new_box[0, 0], new_box[1, 0]
+ xmin -= expansion_margin
+ xmax += expansion_margin
+ if xmin <= 8:
+ xmin = 0
+ if xmax + 8 >= width:
+ xmax = width
+ new_box[0, 0] = new_box[3, 0] = xmin
+ new_box = clipbox(new_box, height, width)
+ if not _overlap_with_some_box(idx, new_box):
+ layout_out[idx]['position'] = new_box
+ new_box = layout_out[idx]['position'].copy()
+ new_box[1, 0] = new_box[2, 0] = xmax
+ new_box = clipbox(new_box, height, width)
+ if not _overlap_with_some_box(idx, new_box):
+ layout_out[idx]['position'] = new_box
+
+ # expand ymin and ymax
+ new_box = layout_out[idx]['position'].copy()
+ ymin, ymax = new_box[0, 1], new_box[2, 1]
+ ymin -= expansion_margin
+ ymax += expansion_margin
+ if ymin <= 8:
+ ymin = 0
+ if ymax + 8 >= height:
+ ymax = height
+ new_box[0, 1] = new_box[1, 1] = ymin
+ new_box = clipbox(new_box, height, width)
+ if not _overlap_with_some_box(idx, new_box):
+ layout_out[idx]['position'] = new_box
+ new_box = layout_out[idx]['position'].copy()
+ new_box[2, 1] = new_box[3, 1] = ymax
+ new_box = clipbox(new_box, height, width)
+ if not _overlap_with_some_box(idx, new_box):
+ layout_out[idx]['position'] = new_box
+
+ return layout_out
diff --git a/pix2text/doc_xl_layout/external/__init__.py b/pix2text/doc_xl_layout/external/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pix2text/doc_xl_layout/external/shapelyNMS.py b/pix2text/doc_xl_layout/external/shapelyNMS.py
new file mode 100644
index 0000000000000000000000000000000000000000..4047f26d57e68d15ad1a1ee6379b4a80b37cd374
--- /dev/null
+++ b/pix2text/doc_xl_layout/external/shapelyNMS.py
@@ -0,0 +1,75 @@
+import numpy as np
+
+
+def pnms(dets, thresh):
+ if len(dets) < 2:
+ return dets
+ scores = dets[:, 8]
+ index_keep = []
+ keep = []
+ for i in range(len(dets)):
+ box = dets[i]
+ if box[8] < thresh:
+ continue
+ max_score_index = -1
+ ctx = (dets[i][0] + dets[i][2] + dets[i][4] + dets[i][6]) / 4
+ cty = (dets[i][1] + dets[i][3] + dets[i][5] + dets[i][7]) / 4
+ for j in range(len(dets)):
+ if i == j or dets[j][8] < thresh:
+ continue
+ x1, y1 = dets[j][0], dets[j][1]
+ x2, y2 = dets[j][2], dets[j][3]
+ x3, y3 = dets[j][4], dets[j][5]
+ x4, y4 = dets[j][6], dets[j][7]
+ a = (x2 - x1) * (cty - y1) - (y2 - y1) * (ctx - x1)
+ b = (x3 - x2) * (cty - y2) - (y3 - y2) * (ctx - x2)
+ c = (x4 - x3) * (cty - y3) - (y4 - y3) * (ctx - x3)
+ d = (x1 - x4) * (cty - y4) - (y1 - y4) * (ctx - x4)
+ if ((a > 0 and b > 0 and c > 0 and d > 0) or (a < 0 and b < 0 and c < 0 and d < 0)):
+ if dets[i][8] > dets[j][8] and max_score_index < 0:
+ max_score_index = i
+ elif dets[i][8] < dets[j][8]:
+ max_score_index = -2
+ break
+ if max_score_index > -1:
+ index_keep.append(max_score_index)
+ elif max_score_index == -1:
+ index_keep.append(i)
+ for i in range(0, len(index_keep)):
+ keep.append(dets[index_keep[i]])
+
+ return np.array(keep)
+
+ '''
+ pts = []
+ for i in range(dets.shape[0]):
+ pts.append([dets[i][0:2],dets[i][2:4],dets[i][4:6],dets[i][6:8]])
+
+ areas = np.zeros(scores.shape)
+ order = scores.argsort()[::-1]
+ inter_areas = np.zeros((scores.shape[0],scores.shape[0]))
+
+ for i in range(0,len(pts)):
+ poly = Polygon(pts[i])
+ areas[i] = poly.area
+
+ for j in range(i, len(pts)):
+ polyj = Polygon(pts[j])
+ try:
+ inS = poly.intersection(polyj)
+ except Exception as e:
+ print(pts[i],'\n',pts[j])
+ return dets
+ inter_areas[i][j] = inS.area
+ inter_areas[j][i] = inS.area
+
+ keep = []
+ while order.size > 0:
+ i = order[0]
+ keep.append(dets[i])
+ ovr = inter_areas[i][order[1:]] / (areas[i] + areas[order[1:]] - inter_areas[i][order[1:]])
+ inds = np.where(ovr <= thresh)[0]
+ order = order[inds + 1]
+
+ return keep
+ '''
diff --git a/pix2text/doc_xl_layout/huntie_subfield.py b/pix2text/doc_xl_layout/huntie_subfield.py
new file mode 100644
index 0000000000000000000000000000000000000000..b6908a1f3b004723b2f260e5975f65d2f866fb63
--- /dev/null
+++ b/pix2text/doc_xl_layout/huntie_subfield.py
@@ -0,0 +1,13 @@
+import numpy as np
+import torch.utils.data as data
+
+
+class Huntie_Subfield(data.Dataset):
+ num_classes = 13
+ num_secondary_classes = 3
+ default_resolution = [768, 768]
+ mean = np.array([0.40789654, 0.44719302, 0.47026115], dtype=np.float32).reshape(1, 1, 3)
+ std = np.array([0.28863828, 0.27408164, 0.27809835], dtype=np.float32).reshape(1, 1, 3)
+
+
+
diff --git a/pix2text/doc_xl_layout/opts.py b/pix2text/doc_xl_layout/opts.py
new file mode 100644
index 0000000000000000000000000000000000000000..80315e2dd688438fa57817e4048b063d44f6d6b9
--- /dev/null
+++ b/pix2text/doc_xl_layout/opts.py
@@ -0,0 +1,410 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import argparse
+import os
+
+
+class opts(object):
+ def __init__(self):
+ self.parser = argparse.ArgumentParser()
+ # basic experiment setting
+ self.parser.add_argument('task', default='ctdet',
+ help='ctdet | ddd | multi_pose | exdet | ctdet_subfield')
+ self.parser.add_argument('--dataset', default='huntie',
+ help='coco | kitti | coco_hp | pascal | huntie | structure')
+ self.parser.add_argument('--test', action='store_true')
+ self.parser.add_argument('--data_src', default="default", type=str,
+ help='The path of input data.')
+ self.parser.add_argument('--exp_id', default='default', type=str)
+ self.parser.add_argument('--vis_corner', type=int, default=0,
+ help='vis corner or not'
+ '0: do not vis corner'
+ '1: vis corner')
+ self.parser.add_argument('--convert_onnx', type=int, default=0,
+ help='0: donot convert'
+ '1: convert pytorch model to onnx')
+ self.parser.add_argument('--onnx_path', type=str, default="auto",
+ help='path of output onnx file.')
+ self.parser.add_argument('--debug', type=int, default=0,
+ help='level of visualization.'
+ '1: only show the final detection results'
+ '2: show the network output features'
+ '3: use matplot to display' # useful when lunching training with ipython notebook
+ '4: save all visualizations to disk')
+ self.parser.add_argument('--load_model', default='',
+ help='path to pretrained model')
+ self.parser.add_argument('--resume', action='store_true',
+ help='resume an experiment. '
+ 'Reloaded the optimizer parameter and '
+ 'set load_model to model_last.pth '
+ 'in the exp dir if load_model is empty.')
+
+ # system
+ self.parser.add_argument('--gpus', default='-1',
+ help='-1 for CPU, use comma for multiple gpus')
+ self.parser.add_argument('--num_workers', type=int, default=16,
+ help='dataloader threads. 0 for single-thread.')
+ self.parser.add_argument('--not_cuda_benchmark', action='store_true',
+ help='disable when the input size is not fixed.')
+ self.parser.add_argument('--seed', type=int, default=317,
+ help='random seed') # from CornerNet
+
+ # log
+ self.parser.add_argument('--print_iter', type=int, default=0,
+ help='disable progress bar and print to screen.')
+ self.parser.add_argument('--hide_data_time', action='store_true',
+ help='not display time during training.')
+ self.parser.add_argument('--save_all', action='store_true',
+ help='save model to disk every 5 epochs.')
+ self.parser.add_argument('--metric', default='loss',
+ help='main metric to save best model')
+ self.parser.add_argument('--vis_thresh', type=float, default=0.3,
+ help='visualization threshold.')
+ self.parser.add_argument('--nms_thresh', type=float, default=0.3,
+ help='nms threshold.')
+ self.parser.add_argument('--corner_thresh', type=float, default=0.3,
+ help='threshold for corner.')
+ self.parser.add_argument('--debugger_theme', default='white',
+ choices=['white', 'black'])
+
+ # model
+ self.parser.add_argument('--arch', default='dla_34',
+ help='model architecture. Currently tested'
+ 'res_18 | res_101 | resdcn_18 | resdcn_101 |'
+ 'dlav0_34 | dla_34 | hourglass')
+ self.parser.add_argument('--head_conv', type=int, default=-1,
+ help='conv layer channels for output head'
+ '0 for no conv layer'
+ '-1 for default setting: '
+ '64 for resnets and 256 for dla.')
+ self.parser.add_argument('--down_ratio', type=int, default=4,
+ help='output stride. Currently only supports 4.')
+
+ # input
+ self.parser.add_argument('--input_res', type=int, default=-1,
+ help='input height and width. -1 for default from '
+ 'dataset. Will be overriden by input_h | input_w')
+ self.parser.add_argument('--input_h', type=int, default=-1,
+ help='input height. -1 for default from dataset.')
+ self.parser.add_argument('--input_w', type=int, default=-1,
+ help='input width. -1 for default from dataset.')
+
+ # train
+ self.parser.add_argument('--lr', type=float, default=1.25e-4,
+ help='learning rate for batch size 32.')
+ self.parser.add_argument('--lr_step', type=str, default='80',
+ help='drop learning rate by 10.')
+ self.parser.add_argument('--NotFixList', type=str, default='',
+ help='not fix layer name.')
+ self.parser.add_argument('--num_epochs', type=int, default=90,
+ help='total training epochs.')
+ self.parser.add_argument('--batch_size', type=int, default=32,
+ help='batch size')
+ self.parser.add_argument('--master_batch_size', type=int, default=-1,
+ help='batch size on the master gpu.')
+ self.parser.add_argument('--num_iters', type=int, default=-1,
+ help='default: #samples / batch_size.')
+ self.parser.add_argument('--val_intervals', type=int, default=5,
+ help='number of epochs to run validation.')
+ self.parser.add_argument('--trainval', action='store_true',
+ help='include validation in training and test on test set')
+ self.parser.add_argument('--negative', action='store_true',
+ help='flip data augmentation.')
+ self.parser.add_argument('--adamW', action='store_true',
+ help='using adamW or adam.')
+
+ # test
+ self.parser.add_argument('--save_dir', default="default", type=str,
+ help='The path of output data.')
+ self.parser.add_argument('--flip_test', action='store_true',
+ help='flip data augmentation.')
+ self.parser.add_argument('--test_scales', type=str, default='1',
+ help='multi scale test augmentation.')
+ self.parser.add_argument('--nms', action='store_false',
+ help='run nms in testing.')
+ self.parser.add_argument('--K', type=int, default=100,
+ help='max number of output objects.')
+ self.parser.add_argument('--fix_res', action='store_true',
+ help='fix testing resolution or keep the original resolution')
+ self.parser.add_argument('--keep_res', action='store_true',
+ help='keep the original resolution during validation.')
+
+ # dataset
+ self.parser.add_argument('--not_rand_crop', action='store_true',
+ help='not use the random crop data augmentation from CornerNet.')
+ self.parser.add_argument('--shift', type=float, default=0.1,
+ help='when not using random crop apply shift augmentation.')
+ self.parser.add_argument('--scale', type=float, default=0.4,
+ help='when not using random crop apply scale augmentation.')
+ self.parser.add_argument('--rotate', type=float, default=0,
+ help='when not using random crop apply rotation augmentation.')
+ self.parser.add_argument('--flip', type=float, default=0.5,
+ help='probability of applying flip augmentation.')
+ self.parser.add_argument('--maskvisual', type=float, default=0.,
+ help='probability of masking image.')
+ self.parser.add_argument('--maskgrid', type=float, default=0.,
+ help='probability of masking grid, only available when visual is not masked.')
+ self.parser.add_argument('--no_color_aug', action='store_true',
+ help='not use the color augmenation from CornerNet')
+ self.parser.add_argument('--MK', default=500,
+ help='max corner number')
+ self.parser.add_argument('--rot', action='store_false',
+ help='rotate image')
+ self.parser.add_argument('--warp', action='store_false',
+ help='warp image')
+ self.parser.add_argument('--normal_padding', action='store_false',
+ help='normal_padding image')
+ self.parser.add_argument('--extra_channel', action='store_true',
+ help='concat edge channel to the input image')
+ self.parser.add_argument('--init_emb', type=str, default='',
+ help='embedding layer.')
+ self.parser.add_argument('--grid_type', type=str, default='char_point',
+ help='type of grid, candidates: char_point, char_box (CharGrid), line (WordGrid).')
+ self.parser.add_argument('--finetune_emb', action='store_true',
+ help='embedding finetune')
+ self.parser.add_argument('--dic', type=str, default='',
+ help='dic file for grid.')
+ self.parser.add_argument('--sample_limit', type=int, default=-1,
+ help='limit samples for training')
+
+ # multi_pose
+ self.parser.add_argument('--aug_rot', type=float, default=0,
+ help='probability of applying rotation augmentation.')
+ # ddd
+ self.parser.add_argument('--aug_ddd', type=float, default=0.5,
+ help='probability of applying crop augmentation.')
+ self.parser.add_argument('--rect_mask', action='store_true',
+ help='for ignored object, apply mask on the '
+ 'rectangular region or just center point.')
+ self.parser.add_argument('--kitti_split', default='3dop',
+ help='different validation split for kitti: '
+ '3dop | subcnn')
+
+ # loss
+ self.parser.add_argument('--mse_loss', action='store_true',
+ help='use mse loss or focal loss to train keypoint heatmaps.')
+ # ctdet
+ self.parser.add_argument('--num_classes', type=int, default=-1,
+ help='the number of main category. -1 means use default from dataset.')
+ self.parser.add_argument('--num_secondary_classes', type=int, default=-1,
+ help='the number of secondary category. -1 means use default from dataset.')
+ self.parser.add_argument('--reg_loss', default='l1',
+ help='regression loss: sl1 | l1 | l2')
+ self.parser.add_argument('--hm_weight', type=float, default=1,
+ help='loss weight for keypoint heatmaps.')
+ self.parser.add_argument('--cls_weight', type=float, default=1,
+ help='loss weight for keypoint heatmaps.')
+ self.parser.add_argument('--ftype_weight', type=float, default=1,
+ help='loss weight for keypoint heatmaps.')
+ self.parser.add_argument('--mk_weight', type=float, default=1,
+ help='loss weight for corner keypoint heatmaps.')
+ self.parser.add_argument('--off_weight', type=float, default=1,
+ help='loss weight for keypoint local offsets.')
+ self.parser.add_argument('--wh_weight', type=float, default=1,
+ help='loss weight for bounding box size.')
+ # multi_pose
+ self.parser.add_argument('--hp_weight', type=float, default=1,
+ help='loss weight for human pose offset.')
+ self.parser.add_argument('--hm_hp_weight', type=float, default=1,
+ help='loss weight for human keypoint heatmap.')
+ # ddd
+ self.parser.add_argument('--dep_weight', type=float, default=1,
+ help='loss weight for depth.')
+ self.parser.add_argument('--dim_weight', type=float, default=1,
+ help='loss weight for 3d bounding box size.')
+ self.parser.add_argument('--rot_weight', type=float, default=1,
+ help='loss weight for orientation.')
+ self.parser.add_argument('--peak_thresh', type=float, default=0.1)
+
+ # task
+ # ctdet
+ self.parser.add_argument('--norm_wh', action='store_true',
+ help='L1(\hat(y) / y, 1) or L1(\hat(y), y)')
+ self.parser.add_argument('--dense_wh', action='store_true',
+ help='apply weighted regression near center or '
+ 'just apply regression on center point.')
+ self.parser.add_argument('--cat_spec_wh', action='store_true',
+ help='category specific bounding box size.')
+ self.parser.add_argument('--not_reg_offset', action='store_true',
+ help='not regress local offset.')
+ # exdet
+ self.parser.add_argument('--agnostic_ex', action='store_true',
+ help='use category agnostic extreme points.')
+ self.parser.add_argument('--scores_thresh', type=float, default=0.3,
+ help='threshold for extreme point heatmap.')
+ self.parser.add_argument('--center_thresh', type=float, default=0.3,
+ help='threshold for centermap.')
+ self.parser.add_argument('--aggr_weight', type=float, default=0.0,
+ help='edge aggregation weight.')
+ # multi_pose
+ self.parser.add_argument('--dense_hp', action='store_true',
+ help='apply weighted pose regression near center '
+ 'or just apply regression on center point.')
+ self.parser.add_argument('--not_hm_hp', action='store_true',
+ help='not estimate human joint heatmap, '
+ 'directly use the joint offset from center.')
+ self.parser.add_argument('--not_reg_hp_offset', action='store_true',
+ help='not regress local offset for '
+ 'human joint heatmaps.')
+ self.parser.add_argument('--not_reg_bbox', action='store_true',
+ help='not regression bounding box size.')
+
+ # ground truth validation
+ self.parser.add_argument('--eval_oracle_hm', action='store_true',
+ help='use ground center heatmap.')
+ self.parser.add_argument('--eval_oracle_mk', action='store_true',
+ help='use ground corner heatmap.')
+ self.parser.add_argument('--eval_oracle_wh', action='store_true',
+ help='use ground truth bounding box size.')
+ self.parser.add_argument('--eval_oracle_offset', action='store_true',
+ help='use ground truth local heatmap offset.')
+ self.parser.add_argument('--eval_oracle_kps', action='store_true',
+ help='use ground truth human pose offset.')
+ self.parser.add_argument('--eval_oracle_hmhp', action='store_true',
+ help='use ground truth human joint heatmaps.')
+ self.parser.add_argument('--eval_oracle_hp_offset', action='store_true',
+ help='use ground truth human joint local offset.')
+ self.parser.add_argument('--eval_oracle_dep', action='store_true',
+ help='use ground truth depth.')
+
+ def parse(self, args=None):
+ if isinstance(args, dict):
+ task_name = args.get("task", "ctdet")
+ opt = self.parser.parse_args(args=[task_name])
+ opt.__dict__.update(args)
+ else:
+ opt = self.parser.parse_args(args=args)
+
+ # import json
+ # with open("task_config.json", "w") as f:
+ # json.dump(opt.__dict__, f, ensure_ascii=False, indent=4)
+
+ opt.gpus_str = opt.gpus
+ opt.gpus = [int(gpu) for gpu in opt.gpus.split(',')]
+ opt.gpus = [i for i in range(len(opt.gpus))] if opt.gpus[0] >= 0 else [-1]
+ opt.lr_step = [int(i) for i in opt.lr_step.split(',')]
+ opt.test_scales = [float(i) for i in opt.test_scales.split(',')]
+
+ opt.fix_res = not opt.keep_res
+ print('Fix size testing.' if opt.fix_res else 'Keep resolution testing.')
+ opt.reg_offset = not opt.not_reg_offset
+ opt.reg_bbox = not opt.not_reg_bbox
+ opt.hm_hp = not opt.not_hm_hp
+ opt.reg_hp_offset = (not opt.not_reg_hp_offset) and opt.hm_hp
+
+ if opt.head_conv == -1: # init default head_conv
+ opt.head_conv = 256 if 'dla' in opt.arch else 64
+ opt.pad = 0 # opt.pad = 127 if 'hourglass' in opt.arch else 31
+ opt.num_stacks = 2 if opt.arch == 'hourglass' else 1
+
+ if opt.trainval:
+ opt.val_intervals = 100000000
+
+ if opt.debug > 0:
+ opt.num_workers = 0
+ opt.batch_size = 1
+ opt.gpus = [opt.gpus[0]]
+ opt.master_batch_size = -1
+
+ if opt.master_batch_size == -1:
+ opt.master_batch_size = opt.batch_size // len(opt.gpus)
+ rest_batch_size = (opt.batch_size - opt.master_batch_size)
+ opt.chunk_sizes = [opt.master_batch_size]
+ for i in range(len(opt.gpus) - 1):
+ slave_chunk_size = rest_batch_size // (len(opt.gpus) - 1)
+ if i < rest_batch_size % (len(opt.gpus) - 1):
+ slave_chunk_size += 1
+ opt.chunk_sizes.append(slave_chunk_size)
+ print('training chunk_sizes:', opt.chunk_sizes)
+
+ opt.root_dir = os.path.join(os.path.dirname(__file__), '..', '..')
+ opt.data_dir = os.path.join(opt.root_dir, 'data') if opt.data_src == "default" else opt.data_src
+ opt.exp_dir = os.path.join(opt.root_dir, 'exp', opt.task)
+ # import pdb; pdb.set_trace()
+ opt.save_dir = os.path.join(opt.exp_dir, opt.exp_id) if opt.save_dir == "default" else os.path.join(opt.save_dir, opt.exp_id)
+ opt.debug_dir = os.path.join(opt.save_dir, 'debug')
+ print('The output will be saved to ', opt.save_dir)
+
+ if opt.resume and opt.load_model == '':
+ model_path = opt.save_dir[:-4] if opt.save_dir.endswith('TEST') \
+ else opt.save_dir
+ opt.load_model = os.path.join(model_path, 'model_last.pth')
+ return opt
+
+ def update_dataset_info_and_set_heads(self, opt, dataset):
+ input_h, input_w = dataset.default_resolution
+ opt.mean, opt.std = dataset.mean, dataset.std
+
+ if opt.num_classes == -1:
+ opt.num_classes = dataset.num_classes
+ if opt.num_secondary_classes == -1:
+ opt.num_secondary_classes = dataset.num_secondary_classes
+
+ # input_h(w): opt.input_h overrides opt.input_res overrides dataset default
+ input_h = opt.input_res if opt.input_res > 0 else input_h
+ input_w = opt.input_res if opt.input_res > 0 else input_w
+ opt.input_h = opt.input_h if opt.input_h > 0 else input_h
+ opt.input_w = opt.input_w if opt.input_w > 0 else input_w
+ opt.output_h = opt.input_h // opt.down_ratio
+ opt.output_w = opt.input_w // opt.down_ratio
+ opt.input_res = max(opt.input_h, opt.input_w)
+ opt.output_res = max(opt.output_h, opt.output_w)
+
+ if opt.task == 'exdet':
+ # assert opt.dataset in ['coco']
+ num_hm = 1 if opt.agnostic_ex else opt.num_classes
+ opt.heads = {'hm_t': num_hm, 'hm_l': num_hm,
+ 'hm_b': num_hm, 'hm_r': num_hm,
+ 'hm_c': opt.num_classes}
+ if opt.reg_offset:
+ opt.heads.update({'reg_t': 2, 'reg_l': 2, 'reg_b': 2, 'reg_r': 2})
+ elif opt.task == 'ddd':
+ # assert opt.dataset in ['gta', 'kitti', 'viper']
+ opt.heads = {'hm': opt.num_classes, 'dep': 1, 'rot': 8, 'dim': 3}
+ if opt.reg_bbox:
+ opt.heads.update(
+ {'wh': 2})
+ if opt.reg_offset:
+ opt.heads.update({'reg': 2})
+ elif opt.task == 'ctdet':
+ # assert opt.dataset in ['pascal', 'coco']
+ opt.heads = {'hm': opt.num_classes, 'cls': 4, 'ftype': opt.num_secondary_classes,
+ 'wh': 8 if not opt.cat_spec_wh else 8 * opt.num_classes}
+ if opt.reg_offset:
+ opt.heads.update({'reg': 2})
+ elif opt.task == 'ctdet_dualmodal':
+ # assert opt.dataset in ['pascal', 'coco']
+ opt.heads = {'hm': opt.num_classes, 'cls': 4, 'ftype': opt.num_secondary_classes,
+ 'wh': 8 if not opt.cat_spec_wh else 8 * opt.num_classes}
+ if opt.reg_offset:
+ opt.heads.update({'reg': 2})
+ elif opt.task == 'multi_pose':
+ # assert opt.dataset in ['coco_hp']
+ opt.flip_idx = dataset.flip_idx
+ opt.heads = {'hm': opt.num_classes, 'wh': 2, 'hps': 34}
+ if opt.reg_offset:
+ opt.heads.update({'reg': 2})
+ if opt.hm_hp:
+ opt.heads.update({'hm_hp': 17})
+ if opt.reg_hp_offset:
+ opt.heads.update({'hp_offset': 2})
+ elif opt.task == 'ctdet_subfield':
+ # assert opt.dataset in ['pascal', 'coco']
+ opt.heads = {'hm': opt.num_classes-2, 'cls': 4, 'ftype': opt.num_secondary_classes,
+ 'wh': 8 if not opt.cat_spec_wh else 8 * opt.num_classes, 'hm_sub': 2, 'wh_sub': 8 }
+ if opt.reg_offset:
+ opt.heads.update({'reg': 2})
+ opt.heads.update({'reg_sub': 2})
+ else:
+ assert 0, 'task not defined!'
+ print('heads', opt.heads)
+ return opt
+
+
+if __name__ == '__main__':
+ print("Testing config ... ")
+ config_dict = {"batch_size": 32, "dataset": "huntie"}
+ opt = opts().parse(args=config_dict)
+ print(opt.__dict__)
diff --git a/pix2text/doc_xl_layout/utils/__init__.py b/pix2text/doc_xl_layout/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/pix2text/doc_xl_layout/utils/ddd_utils.py b/pix2text/doc_xl_layout/utils/ddd_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..335254e1ed5a40d2f59f1854533a191c39a5dc0c
--- /dev/null
+++ b/pix2text/doc_xl_layout/utils/ddd_utils.py
@@ -0,0 +1,139 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import cv2
+import numpy as np
+
+
+def compute_box_3d(dim, location, rotation_y):
+ # dim: 3
+ # location: 3
+ # rotation_y: 1
+ # return: 8 x 3
+ c, s = np.cos(rotation_y), np.sin(rotation_y)
+ R = np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]], dtype=np.float32)
+ l, w, h = dim[2], dim[1], dim[0]
+ x_corners = [l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2]
+ y_corners = [0, 0, 0, 0, -h, -h, -h, -h]
+ z_corners = [w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2]
+
+ corners = np.array([x_corners, y_corners, z_corners], dtype=np.float32)
+ corners_3d = np.dot(R, corners)
+ corners_3d = corners_3d + np.array(location, dtype=np.float32).reshape(3, 1)
+ return corners_3d.transpose(1, 0)
+
+
+def project_to_image(pts_3d, P):
+ # pts_3d: n x 3
+ # P: 3 x 4
+ # return: n x 2
+ pts_3d_homo = np.concatenate(
+ [pts_3d, np.ones((pts_3d.shape[0], 1), dtype=np.float32)], axis=1)
+ pts_2d = np.dot(P, pts_3d_homo.transpose(1, 0)).transpose(1, 0)
+ pts_2d = pts_2d[:, :2] / pts_2d[:, 2:]
+ # import pdb; pdb.set_trace()
+ return pts_2d
+
+
+def compute_orientation_3d(dim, location, rotation_y):
+ # dim: 3
+ # location: 3
+ # rotation_y: 1
+ # return: 2 x 3
+ c, s = np.cos(rotation_y), np.sin(rotation_y)
+ R = np.array([[c, 0, s], [0, 1, 0], [-s, 0, c]], dtype=np.float32)
+ orientation_3d = np.array([[0, dim[2]], [0, 0], [0, 0]], dtype=np.float32)
+ orientation_3d = np.dot(R, orientation_3d)
+ orientation_3d = orientation_3d + \
+ np.array(location, dtype=np.float32).reshape(3, 1)
+ return orientation_3d.transpose(1, 0)
+
+
+def draw_box_3d(image, corners, c=(0, 0, 255)):
+ face_idx = [[0, 1, 5, 4],
+ [1, 2, 6, 5],
+ [2, 3, 7, 6],
+ [3, 0, 4, 7]]
+ for ind_f in range(3, -1, -1):
+ f = face_idx[ind_f]
+ for j in range(4):
+ cv2.line(image, (corners[f[j], 0], corners[f[j], 1]),
+ (corners[f[(j + 1) % 4], 0], corners[f[(j + 1) % 4], 1]), c, 2, lineType=cv2.LINE_AA)
+ if ind_f == 0:
+ cv2.line(image, (corners[f[0], 0], corners[f[0], 1]),
+ (corners[f[2], 0], corners[f[2], 1]), c, 1, lineType=cv2.LINE_AA)
+ cv2.line(image, (corners[f[1], 0], corners[f[1], 1]),
+ (corners[f[3], 0], corners[f[3], 1]), c, 1, lineType=cv2.LINE_AA)
+ return image
+
+
+def unproject_2d_to_3d(pt_2d, depth, P):
+ # pts_2d: 2
+ # depth: 1
+ # P: 3 x 4
+ # return: 3
+ z = depth - P[2, 3]
+ x = (pt_2d[0] * depth - P[0, 3] - P[0, 2] * z) / P[0, 0]
+ y = (pt_2d[1] * depth - P[1, 3] - P[1, 2] * z) / P[1, 1]
+ pt_3d = np.array([x, y, z], dtype=np.float32)
+ return pt_3d
+
+
+def alpha2rot_y(alpha, x, cx, fx):
+ """
+ Get rotation_y by alpha + theta - 180
+ alpha : Observation angle of object, ranging [-pi..pi]
+ x : Object center x to the camera center (x-W/2), in pixels
+ rotation_y : Rotation ry around Y-axis in camera coordinates [-pi..pi]
+ """
+ rot_y = alpha + np.arctan2(x - cx, fx)
+ if rot_y > np.pi:
+ rot_y -= 2 * np.pi
+ if rot_y < -np.pi:
+ rot_y += 2 * np.pi
+ return rot_y
+
+
+def rot_y2alpha(rot_y, x, cx, fx):
+ """
+ Get rotation_y by alpha + theta - 180
+ alpha : Observation angle of object, ranging [-pi..pi]
+ x : Object center x to the camera center (x-W/2), in pixels
+ rotation_y : Rotation ry around Y-axis in camera coordinates [-pi..pi]
+ """
+ alpha = rot_y - np.arctan2(x - cx, fx)
+ if alpha > np.pi:
+ alpha -= 2 * np.pi
+ if alpha < -np.pi:
+ alpha += 2 * np.pi
+ return alpha
+
+
+def ddd2locrot(center, alpha, dim, depth, calib):
+ # single image
+ locations = unproject_2d_to_3d(center, depth, calib)
+ locations[1] += dim[0] / 2
+ rotation_y = alpha2rot_y(alpha, center[0], calib[0, 2], calib[0, 0])
+ return locations, rotation_y
+
+
+def project_3d_bbox(location, dim, rotation_y, calib):
+ box_3d = compute_box_3d(dim, location, rotation_y)
+ box_2d = project_to_image(box_3d, calib)
+ return box_2d
+
+
+if __name__ == '__main__':
+ calib = np.array(
+ [[7.070493000000e+02, 0.000000000000e+00, 6.040814000000e+02, 4.575831000000e+01],
+ [0.000000000000e+00, 7.070493000000e+02, 1.805066000000e+02, -3.454157000000e-01],
+ [0.000000000000e+00, 0.000000000000e+00, 1.000000000000e+00, 4.981016000000e-03]],
+ dtype=np.float32)
+ alpha = -0.20
+ tl = np.array([712.40, 143.00], dtype=np.float32)
+ br = np.array([810.73, 307.92], dtype=np.float32)
+ ct = (tl + br) / 2
+ rotation_y = 0.01
+ print('alpha2rot_y', alpha2rot_y(alpha, ct[0], calib[0, 2], calib[0, 0]))
+ print('rotation_y', rotation_y)
diff --git a/pix2text/doc_xl_layout/utils/debugger.py b/pix2text/doc_xl_layout/utils/debugger.py
new file mode 100644
index 0000000000000000000000000000000000000000..2930ae959cae1d58654ac4c9c36ed1b0e62358f4
--- /dev/null
+++ b/pix2text/doc_xl_layout/utils/debugger.py
@@ -0,0 +1,606 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import cv2
+import numpy as np
+
+from .ddd_utils import compute_box_3d, project_to_image, draw_box_3d
+
+class Debugger(object):
+ def __init__(self, ipynb=False, theme='black',
+ num_classes=-1, dataset=None, down_ratio=4):
+ self.ipynb = ipynb
+ if not self.ipynb:
+ import matplotlib.pyplot as plt
+ self.plt = plt
+ self.imgs = {}
+ self.theme = theme
+ colors = [(color_list[_]).astype(np.uint8) \
+ for _ in range(len(color_list))]
+ self.colors = np.array(colors, dtype=np.uint8).reshape(len(colors), 1, 1, 3)
+ if self.theme == 'white':
+ self.colors = self.colors.reshape(-1)[::-1].reshape(len(colors), 1, 1, 3)
+ self.colors = np.clip(self.colors, 0., 0.6 * 255).astype(np.uint8)
+ self.dim_scale = 1
+ if dataset == 'coco_hp':
+ self.names = ['p']
+ self.num_class = 1
+ self.num_joints = 17
+ self.edges = [[0, 1], [0, 2], [1, 3], [2, 4],
+ [3, 5], [4, 6], [5, 6],
+ [5, 7], [7, 9], [6, 8], [8, 10],
+ [5, 11], [6, 12], [11, 12],
+ [11, 13], [13, 15], [12, 14], [14, 16]]
+ self.ec = [(255, 0, 0), (0, 0, 255), (255, 0, 0), (0, 0, 255),
+ (255, 0, 0), (0, 0, 255), (255, 0, 255),
+ (255, 0, 0), (255, 0, 0), (0, 0, 255), (0, 0, 255),
+ (255, 0, 0), (0, 0, 255), (255, 0, 255),
+ (255, 0, 0), (255, 0, 0), (0, 0, 255), (0, 0, 255)]
+ self.colors_hp = [(255, 0, 255), (255, 0, 0), (0, 0, 255),
+ (255, 0, 0), (0, 0, 255), (255, 0, 0), (0, 0, 255),
+ (255, 0, 0), (0, 0, 255), (255, 0, 0), (0, 0, 255),
+ (255, 0, 0), (0, 0, 255), (255, 0, 0), (0, 0, 255),
+ (255, 0, 0), (0, 0, 255)]
+ elif num_classes == 80 or dataset == 'coco':
+ self.names = coco_class_name
+ elif num_classes == 20 or dataset == 'pascal':
+ self.names = pascal_class_name
+ elif num_classes == 1 and dataset == 'table':
+ self.names = table_class_name
+ elif num_classes == 16 or dataset == 'huntie':
+ self.names = huntie_class_name
+ elif dataset == 'vehicle':
+ self.names = vehicle_class_name
+ elif num_classes == 2 or dataset == 'video':
+ self.names = video_class_name
+ elif dataset == 'gta':
+ self.names = gta_class_name
+ self.focal_length = 935.3074360871937
+ self.W = 1920
+ self.H = 1080
+ self.dim_scale = 3
+ elif dataset == 'viper':
+ self.names = gta_class_name
+ self.focal_length = 1158
+ self.W = 1920
+ self.H = 1080
+ self.dim_scale = 3
+ elif num_classes == 3 or dataset == 'kitti':
+ self.names = kitti_class_name
+ self.focal_length = 721.5377
+ self.W = 1242
+ self.H = 375
+ # num_classes = len(self.names)
+ self.down_ratio = down_ratio
+ # for bird view
+ self.world_size = 64
+ self.out_size = 384
+
+ def add_img(self, img, img_id='default', revert_color=False):
+ if revert_color:
+ img = 255 - img
+ self.imgs[img_id] = img.copy()
+
+ def add_mask(self, mask, bg, imgId='default', trans=0.8):
+ self.imgs[imgId] = (mask.reshape(
+ mask.shape[0], mask.shape[1], 1) * 255 * trans + \
+ bg * (1 - trans)).astype(np.uint8)
+
+ def show_img(self, pause=False, imgId='default'):
+ cv2.imshow('{}'.format(imgId), self.imgs[imgId])
+ if pause:
+ cv2.waitKey()
+
+ def add_blend_img(self, back, fore, img_id='blend', trans=0.7):
+ if self.theme == 'white':
+ fore = 255 - fore
+ if fore.shape[0] != back.shape[0] or fore.shape[0] != back.shape[1]:
+ fore = cv2.resize(fore, (back.shape[1], back.shape[0]))
+ if len(fore.shape) == 2:
+ fore = fore.reshape(fore.shape[0], fore.shape[1], 1)
+ self.imgs[img_id] = (back * (1. - trans) + fore * trans)
+ self.imgs[img_id][self.imgs[img_id] > 255] = 255
+ self.imgs[img_id][self.imgs[img_id] < 0] = 0
+ self.imgs[img_id] = self.imgs[img_id].astype(np.uint8).copy()
+
+ '''
+ # slow version
+ def gen_colormap(self, img, output_res=None):
+ # num_classes = len(self.colors)
+ img[img < 0] = 0
+ h, w = img.shape[1], img.shape[2]
+ if output_res is None:
+ output_res = (h * self.down_ratio, w * self.down_ratio)
+ color_map = np.zeros((output_res[0], output_res[1], 3), dtype=np.uint8)
+ for i in range(img.shape[0]):
+ resized = cv2.resize(img[i], (output_res[1], output_res[0]))
+ resized = resized.reshape(output_res[0], output_res[1], 1)
+ cl = self.colors[i] if not (self.theme == 'white') \
+ else 255 - self.colors[i]
+ color_map = np.maximum(color_map, (resized * cl).astype(np.uint8))
+ return color_map
+ '''
+
+ def gen_colormap(self, img, output_res=None):
+ img = img.copy()
+ c, h, w = img.shape[0], img.shape[1], img.shape[2]
+ if output_res is None:
+ output_res = (h * self.down_ratio, w * self.down_ratio)
+ img = img.transpose(1, 2, 0).reshape(h, w, c, 1).astype(np.float32)
+ colors = np.array(
+ self.colors, dtype=np.float32).reshape(-1, 3)[:c].reshape(1, 1, c, 3)
+ if self.theme == 'white':
+ colors = 255 - colors
+ color_map = (img * colors).max(axis=2).astype(np.uint8)
+ color_map = cv2.resize(color_map, (output_res[0], output_res[1]))
+ return color_map
+
+ '''
+ # slow
+ def gen_colormap_hp(self, img, output_res=None):
+ # num_classes = len(self.colors)
+ # img[img < 0] = 0
+ h, w = img.shape[1], img.shape[2]
+ if output_res is None:
+ output_res = (h * self.down_ratio, w * self.down_ratio)
+ color_map = np.zeros((output_res[0], output_res[1], 3), dtype=np.uint8)
+ for i in range(img.shape[0]):
+ resized = cv2.resize(img[i], (output_res[1], output_res[0]))
+ resized = resized.reshape(output_res[0], output_res[1], 1)
+ cl = self.colors_hp[i] if not (self.theme == 'white') else \
+ (255 - np.array(self.colors_hp[i]))
+ color_map = np.maximum(color_map, (resized * cl).astype(np.uint8))
+ return color_map
+ '''
+
+ def gen_colormap_hp(self, img, output_res=None):
+ c, h, w = img.shape[0], img.shape[1], img.shape[2]
+ if output_res is None:
+ output_res = (h * self.down_ratio, w * self.down_ratio)
+ img = img.transpose(1, 2, 0).reshape(h, w, c, 1).astype(np.float32)
+ colors = np.array(
+ self.colors_hp, dtype=np.float32).reshape(-1, 3)[:c].reshape(1, 1, c, 3)
+ if self.theme == 'white':
+ colors = 255 - colors
+ color_map = (img * colors).max(axis=2).astype(np.uint8)
+ color_map = cv2.resize(color_map, (output_res[0], output_res[1]))
+ return color_map
+
+ def add_rect(self, rect1, rect2, c, conf=1, img_id='default'):
+ cv2.rectangle(
+ self.imgs[img_id], (rect1[0], rect1[1]), (rect2[0], rect2[1]), c, 2)
+ if conf < 1:
+ cv2.circle(self.imgs[img_id], (rect1[0], rect1[1]), int(10 * conf), c, 1)
+ cv2.circle(self.imgs[img_id], (rect2[0], rect2[1]), int(10 * conf), c, 1)
+ cv2.circle(self.imgs[img_id], (rect1[0], rect2[1]), int(10 * conf), c, 1)
+ cv2.circle(self.imgs[img_id], (rect2[0], rect1[1]), int(10 * conf), c, 1)
+
+ def add_coco_bbox(self, bbox, cat, conf=1, show_txt=False, img_id='default'):
+ bbox = np.array(bbox, dtype=np.int32)
+ # cat = (int(cat) + 1) % 80
+ cat = int(cat)
+ # print('cat', cat, self.names[cat])
+ c = self.colors[cat][0][0].tolist()
+ if self.theme == 'white':
+ c = (255 - np.array(c)).tolist()
+ # txt = '{}{:.1f}'.format(self.names[cat], conf)
+ txt = '{}{:.1f}'.format(cat, conf)
+ font = cv2.FONT_HERSHEY_SIMPLEX
+ cat_size = cv2.getTextSize(txt, font, 0.5, 2)[0]
+ cv2.rectangle(
+ self.imgs[img_id], (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 0, 255), 1)
+ if show_txt:
+ cv2.rectangle(self.imgs[img_id],
+ (bbox[0], bbox[1] - cat_size[1] - 2),
+ (bbox[0] + cat_size[0], bbox[1] - 2), c, -1)
+ cv2.putText(self.imgs[img_id], txt, (bbox[0], bbox[1] - 2),
+ font, 0.5, (0, 0, 0), thickness=1, lineType=cv2.LINE_AA)
+
+ def add_4ps_coco_bbox(self, bbox, cat, conf=1, show_txt=False, img_id='default'):
+ bbox = np.array(bbox, dtype=np.int32)
+ # cat = (int(cat) + 1) % 80
+ cat = int(cat)
+ c = self.colors[cat][0][0].tolist()
+ if self.theme == 'white':
+ c = (255 - np.array(c)).tolist()
+ txt = '{}_{:.1f}_{}_{}'.format(str(cat), conf, bbox[-2], bbox[-1])
+ font = cv2.FONT_HERSHEY_SIMPLEX
+ cat_size = cv2.getTextSize(txt, font, 0.5, 2)[0]
+ cv2.line(self.imgs[img_id], (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 0, 255), 2)
+ cv2.line(self.imgs[img_id], (bbox[2], bbox[3]), (bbox[4], bbox[5]), (0, 255, 0), 2)
+ cv2.line(self.imgs[img_id], (bbox[4], bbox[5]), (bbox[6], bbox[7]), (255, 0, 0), 2)
+ cv2.line(self.imgs[img_id], (bbox[6], bbox[7]), (bbox[0], bbox[1]), (0, 255, 255), 2)
+ # cv2.rectangle(
+ # self.imgs[img_id], (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0,0,255), 1)
+ if show_txt:
+ # cv2.rectangle(self.imgs[img_id],
+ # (bbox[0], bbox[1] - cat_size[1] - 2),
+ # (bbox[0] + cat_size[0], bbox[1] - 2), c, -1)
+ cv2.putText(self.imgs[img_id], txt, (int((bbox[0] + bbox[6]) / 2), int((bbox[1] + bbox[7]) / 2)),
+ font, 1, (0, 0, 255), thickness=1, lineType=cv2.LINE_AA)
+
+ def add_coco_hp(self, points, img_id='default'):
+ points = np.array(points, dtype=np.int32).reshape(self.num_joints, 2)
+ for j in range(self.num_joints):
+ cv2.circle(self.imgs[img_id],
+ (points[j, 0], points[j, 1]), 3, self.colors_hp[j], -1)
+ for j, e in enumerate(self.edges):
+ if points[e].min() > 0:
+ cv2.line(self.imgs[img_id], (points[e[0], 0], points[e[0], 1]),
+ (points[e[1], 0], points[e[1], 1]), self.ec[j], 2,
+ lineType=cv2.LINE_AA)
+
+ def add_points(self, points, img_id='default'):
+ num_classes = len(points)
+ # assert num_classes == len(self.colors)
+ for i in range(num_classes):
+ for j in range(len(points[i])):
+ c = self.colors[i, 0, 0]
+ cv2.circle(self.imgs[img_id], (points[i][j][0] * self.down_ratio,
+ points[i][j][1] * self.down_ratio),
+ 5, (255, 255, 255), -1)
+ cv2.circle(self.imgs[img_id], (points[i][j][0] * self.down_ratio,
+ points[i][j][1] * self.down_ratio),
+ 3, (int(c[0]), int(c[1]), int(c[2])), -1)
+
+ def add_corner(self, corner, img_id='default'):
+ font = cv2.FONT_HERSHEY_SIMPLEX
+ cls = int(corner[2])
+ if cls == 0:
+ rgb = (0, 0, 255)
+ if cls == 1:
+ rgb = (0, 255, 0)
+ if cls == 2:
+ rgb = (255, 0, 0)
+ if cls == 3:
+ rgb = (0, 0, 0)
+ cv2.circle(self.imgs[img_id], (int(corner[0]), int(corner[1])), 3, (255, 0, 0), 2)
+ cv2.putText(self.imgs[img_id], str(cls), (int(corner[0]) - 5, int(corner[1]) - 5), font, 0.5, rgb, thickness=1,
+ lineType=cv2.LINE_AA)
+
+ def show_all_imgs(self, pause=False, time=0):
+ if not self.ipynb:
+ for i, v in self.imgs.items():
+ cv2.imshow('{}'.format(i), v)
+ if cv2.waitKey(0 if pause else 1) == 27:
+ import sys
+ sys.exit(0)
+ else:
+ self.ax = None
+ nImgs = len(self.imgs)
+ fig = self.plt.figure(figsize=(nImgs * 10, 10))
+ nCols = nImgs
+ nRows = nImgs // nCols
+ for i, (k, v) in enumerate(self.imgs.items()):
+ fig.add_subplot(1, nImgs, i + 1)
+ if len(v.shape) == 3:
+ self.plt.imshow(cv2.cvtColor(v, cv2.COLOR_BGR2RGB))
+ else:
+ self.plt.imshow(v)
+ self.plt.show()
+
+ def save_img(self, imgId='default', path='./cache/debug/'):
+ cv2.imwrite(path + '{}.png'.format(imgId), self.imgs[imgId])
+
+ def save_all_imgs(self, image_name, path='./cache/debug/', prefix='', genID=False):
+ if genID:
+ try:
+ idx = int(np.loadtxt(path + '/id.txt'))
+ except:
+ idx = 0
+ prefix = idx
+ np.savetxt(path + '/id.txt', np.ones(1) * (idx + 1), fmt='%d')
+ for i, v in self.imgs.items():
+ # pdb.set_trace()
+ # cv2.imwrite(path + '/{}{}.png'.format(prefix,i), v)
+ cv2.imwrite(path + '/%s' % image_name, v)
+ # print(path+'/%s'%image_name)
+
+ def remove_side(self, img_id, img):
+ if not (img_id in self.imgs):
+ return
+ ws = img.sum(axis=2).sum(axis=0)
+ l = 0
+ while ws[l] == 0 and l < len(ws):
+ l += 1
+ r = ws.shape[0] - 1
+ while ws[r] == 0 and r > 0:
+ r -= 1
+ hs = img.sum(axis=2).sum(axis=1)
+ t = 0
+ while hs[t] == 0 and t < len(hs):
+ t += 1
+ b = hs.shape[0] - 1
+ while hs[b] == 0 and b > 0:
+ b -= 1
+ self.imgs[img_id] = self.imgs[img_id][t:b + 1, l:r + 1].copy()
+
+ def project_3d_to_bird(self, pt):
+ pt[0] += self.world_size / 2
+ pt[1] = self.world_size - pt[1]
+ pt = pt * self.out_size / self.world_size
+ return pt.astype(np.int32)
+
+ def add_ct_detection(
+ self, img, dets, show_box=False, show_txt=True,
+ center_thresh=0.5, img_id='det'):
+ # dets: max_preds x 5
+ self.imgs[img_id] = img.copy()
+ if type(dets) == type({}):
+ for cat in dets:
+ for i in range(len(dets[cat])):
+ if dets[cat][i, 2] > center_thresh:
+ cl = (self.colors[cat, 0, 0]).tolist()
+ ct = dets[cat][i, :2].astype(np.int32)
+ if show_box:
+ w, h = dets[cat][i, -2], dets[cat][i, -1]
+ x, y = dets[cat][i, 0], dets[cat][i, 1]
+ bbox = np.array([x - w / 2, y - h / 2, x + w / 2, y + h / 2],
+ dtype=np.float32)
+ self.add_coco_bbox(
+ bbox, cat - 1, dets[cat][i, 2],
+ show_txt=show_txt, img_id=img_id)
+ else:
+ for i in range(len(dets)):
+ if dets[i, 2] > center_thresh:
+ # print('dets', dets[i])
+ cat = int(dets[i, -1])
+ cl = (self.colors[cat, 0, 0] if self.theme == 'black' else \
+ 255 - self.colors[cat, 0, 0]).tolist()
+ ct = dets[i, :2].astype(np.int32) * self.down_ratio
+ cv2.circle(self.imgs[img_id], (ct[0], ct[1]), 3, cl, -1)
+ if show_box:
+ w, h = dets[i, -3] * self.down_ratio, dets[i, -2] * self.down_ratio
+ x, y = dets[i, 0] * self.down_ratio, dets[i, 1] * self.down_ratio
+ bbox = np.array([x - w / 2, y - h / 2, x + w / 2, y + h / 2],
+ dtype=np.float32)
+ self.add_coco_bbox(bbox, dets[i, -1], dets[i, 2], img_id=img_id)
+
+ def add_3d_detection(
+ self, image_or_path, dets, calib, show_txt=False,
+ center_thresh=0.5, img_id='det'):
+ if isinstance(image_or_path, np.ndarray):
+ self.imgs[img_id] = image_or_path
+ else:
+ self.imgs[img_id] = cv2.imread(image_or_path)
+ for cat in dets:
+ for i in range(len(dets[cat])):
+ cl = (self.colors[cat - 1, 0, 0]).tolist()
+ if dets[cat][i, -1] > center_thresh:
+ dim = dets[cat][i, 5:8]
+ loc = dets[cat][i, 8:11]
+ rot_y = dets[cat][i, 11]
+ # loc[1] = loc[1] - dim[0] / 2 + dim[0] / 2 / self.dim_scale
+ # dim = dim / self.dim_scale
+ if loc[2] > 1:
+ box_3d = compute_box_3d(dim, loc, rot_y)
+ box_2d = project_to_image(box_3d, calib)
+ self.imgs[img_id] = draw_box_3d(self.imgs[img_id], box_2d, cl)
+
+ def compose_vis_add(
+ self, img_path, dets, calib,
+ center_thresh, pred, bev, img_id='out'):
+ self.imgs[img_id] = cv2.imread(img_path)
+ # h, w = self.imgs[img_id].shape[:2]
+ # pred = cv2.resize(pred, (h, w))
+ h, w = pred.shape[:2]
+ hs, ws = self.imgs[img_id].shape[0] / h, self.imgs[img_id].shape[1] / w
+ self.imgs[img_id] = cv2.resize(self.imgs[img_id], (w, h))
+ self.add_blend_img(self.imgs[img_id], pred, img_id)
+ for cat in dets:
+ for i in range(len(dets[cat])):
+ cl = (self.colors[cat - 1, 0, 0]).tolist()
+ if dets[cat][i, -1] > center_thresh:
+ dim = dets[cat][i, 5:8]
+ loc = dets[cat][i, 8:11]
+ rot_y = dets[cat][i, 11]
+ # loc[1] = loc[1] - dim[0] / 2 + dim[0] / 2 / self.dim_scale
+ # dim = dim / self.dim_scale
+ if loc[2] > 1:
+ box_3d = compute_box_3d(dim, loc, rot_y)
+ box_2d = project_to_image(box_3d, calib)
+ box_2d[:, 0] /= hs
+ box_2d[:, 1] /= ws
+ self.imgs[img_id] = draw_box_3d(self.imgs[img_id], box_2d, cl)
+ self.imgs[img_id] = np.concatenate(
+ [self.imgs[img_id], self.imgs[bev]], axis=1)
+
+ def add_2d_detection(
+ self, img, dets, show_box=False, show_txt=True,
+ center_thresh=0.5, img_id='det'):
+ self.imgs[img_id] = img
+ for cat in dets:
+ for i in range(len(dets[cat])):
+ cl = (self.colors[cat - 1, 0, 0]).tolist()
+ if dets[cat][i, -1] > center_thresh:
+ bbox = dets[cat][i, 1:5]
+ self.add_coco_bbox(
+ bbox, cat - 1, dets[cat][i, -1],
+ show_txt=show_txt, img_id=img_id)
+
+ def add_bird_view(self, dets, center_thresh=0.3, img_id='bird'):
+ bird_view = np.ones((self.out_size, self.out_size, 3), dtype=np.uint8) * 230
+ for cat in dets:
+ cl = (self.colors[cat - 1, 0, 0]).tolist()
+ lc = (250, 152, 12)
+ for i in range(len(dets[cat])):
+ if dets[cat][i, -1] > center_thresh:
+ dim = dets[cat][i, 5:8]
+ loc = dets[cat][i, 8:11]
+ rot_y = dets[cat][i, 11]
+ rect = compute_box_3d(dim, loc, rot_y)[:4, [0, 2]]
+ for k in range(4):
+ rect[k] = self.project_3d_to_bird(rect[k])
+ # cv2.circle(bird_view, (rect[k][0], rect[k][1]), 2, lc, -1)
+ cv2.polylines(
+ bird_view, [rect.reshape(-1, 1, 2).astype(np.int32)],
+ True, lc, 2, lineType=cv2.LINE_AA)
+ for e in [[0, 1]]:
+ t = 4 if e == [0, 1] else 1
+ cv2.line(bird_view, (rect[e[0]][0], rect[e[0]][1]),
+ (rect[e[1]][0], rect[e[1]][1]), lc, t,
+ lineType=cv2.LINE_AA)
+ self.imgs[img_id] = bird_view
+
+ def add_bird_views(self, dets_dt, dets_gt, center_thresh=0.3, img_id='bird'):
+ alpha = 0.5
+ bird_view = np.ones((self.out_size, self.out_size, 3), dtype=np.uint8) * 230
+ for ii, (dets, lc, cc) in enumerate(
+ [(dets_gt, (12, 49, 250), (0, 0, 255)),
+ (dets_dt, (250, 152, 12), (255, 0, 0))]):
+ # cc = np.array(lc, dtype=np.uint8).reshape(1, 1, 3)
+ for cat in dets:
+ cl = (self.colors[cat - 1, 0, 0]).tolist()
+ for i in range(len(dets[cat])):
+ if dets[cat][i, -1] > center_thresh:
+ dim = dets[cat][i, 5:8]
+ loc = dets[cat][i, 8:11]
+ rot_y = dets[cat][i, 11]
+ rect = compute_box_3d(dim, loc, rot_y)[:4, [0, 2]]
+ for k in range(4):
+ rect[k] = self.project_3d_to_bird(rect[k])
+ if ii == 0:
+ cv2.fillPoly(
+ bird_view, [rect.reshape(-1, 1, 2).astype(np.int32)],
+ lc, lineType=cv2.LINE_AA)
+ else:
+ cv2.polylines(
+ bird_view, [rect.reshape(-1, 1, 2).astype(np.int32)],
+ True, lc, 2, lineType=cv2.LINE_AA)
+ # for e in [[0, 1], [1, 2], [2, 3], [3, 0]]:
+ for e in [[0, 1]]:
+ t = 4 if e == [0, 1] else 1
+ cv2.line(bird_view, (rect[e[0]][0], rect[e[0]][1]),
+ (rect[e[1]][0], rect[e[1]][1]), lc, t,
+ lineType=cv2.LINE_AA)
+ self.imgs[img_id] = bird_view
+
+
+kitti_class_name = [
+ 'p', 'v', 'b'
+]
+
+gta_class_name = [
+ 'p', 'v'
+]
+
+pascal_class_name = ["aeroplane", "bicycle", "bird", "boat", "bottle", "bus",
+ "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike",
+ "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]
+
+coco_class_name = [
+ 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
+ 'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
+ 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',
+ 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',
+ 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',
+ 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',
+ 'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass',
+ 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',
+ 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',
+ 'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
+ 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
+ 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
+ 'scissors', 'teddy bear', 'hair drier', 'toothbrush'
+]
+
+table_class_name = ["box"]
+
+huntie_class_name = ['hcp', 'fjxcd', 'czcfp', 'defp', 'zzsfp',
+ 'qtfp', 'sfz_front', 'sfz_back', 'xsz_first', 'xsz_second',
+ 'bank_card', 'jsz_first', 'roll_ticket', 'czr', 'huzhu', 'FedEx',
+ 'birth_certification', 'blicence', 'car_invoice', 'estate', 'food_blicence',
+ 'food_plicence', "jsz_first", "passport_china", "permit_china",
+ "permit_china_miner", "house_cert", "book_blicense", "medical_license",
+ "medical_instrument_license"]
+
+video_class_name = ['phone_contract', 'phone_signature']
+
+vehicle_class_name = ["first", "second"]
+
+color_list = np.array(
+ [
+ 1.000, 1.000, 1.000,
+ 0.850, 0.325, 0.098,
+ 0.929, 0.694, 0.125,
+ 0.494, 0.184, 0.556,
+ 0.466, 0.674, 0.188,
+ 0.301, 0.745, 0.933,
+ 0.635, 0.078, 0.184,
+ 0.300, 0.300, 0.300,
+ 0.600, 0.600, 0.600,
+ 1.000, 0.000, 0.000,
+ 1.000, 0.500, 0.000,
+ 0.749, 0.749, 0.000,
+ 0.000, 1.000, 0.000,
+ 0.000, 0.000, 1.000,
+ 0.667, 0.000, 1.000,
+ 0.333, 0.333, 0.000,
+ 0.333, 0.667, 0.000,
+ 0.333, 1.000, 0.000,
+ 0.667, 0.333, 0.000,
+ 0.667, 0.667, 0.000,
+ 0.667, 1.000, 0.000,
+ 1.000, 0.333, 0.000,
+ 1.000, 0.667, 0.000,
+ 1.000, 1.000, 0.000,
+ 0.000, 0.333, 0.500,
+ 0.000, 0.667, 0.500,
+ 0.000, 1.000, 0.500,
+ 0.333, 0.000, 0.500,
+ 0.333, 0.333, 0.500,
+ 0.333, 0.667, 0.500,
+ 0.333, 1.000, 0.500,
+ 0.667, 0.000, 0.500,
+ 0.667, 0.333, 0.500,
+ 0.667, 0.667, 0.500,
+ 0.667, 1.000, 0.500,
+ 1.000, 0.000, 0.500,
+ 1.000, 0.333, 0.500,
+ 1.000, 0.667, 0.500,
+ 1.000, 1.000, 0.500,
+ 0.000, 0.333, 1.000,
+ 0.000, 0.667, 1.000,
+ 0.000, 1.000, 1.000,
+ 0.333, 0.000, 1.000,
+ 0.333, 0.333, 1.000,
+ 0.333, 0.667, 1.000,
+ 0.333, 1.000, 1.000,
+ 0.667, 0.000, 1.000,
+ 0.667, 0.333, 1.000,
+ 0.667, 0.667, 1.000,
+ 0.667, 1.000, 1.000,
+ 1.000, 0.000, 1.000,
+ 1.000, 0.333, 1.000,
+ 1.000, 0.667, 1.000,
+ 0.167, 0.000, 0.000,
+ 0.333, 0.000, 0.000,
+ 0.500, 0.000, 0.000,
+ 0.667, 0.000, 0.000,
+ 0.833, 0.000, 0.000,
+ 1.000, 0.000, 0.000,
+ 0.000, 0.167, 0.000,
+ 0.000, 0.333, 0.000,
+ 0.000, 0.500, 0.000,
+ 0.000, 0.667, 0.000,
+ 0.000, 0.833, 0.000,
+ 0.000, 1.000, 0.000,
+ 0.000, 0.000, 0.167,
+ 0.000, 0.000, 0.333,
+ 0.000, 0.000, 0.500,
+ 0.000, 0.000, 0.667,
+ 0.000, 0.000, 0.833,
+ 0.000, 0.000, 1.000,
+ 0.000, 0.000, 0.000,
+ 0.143, 0.143, 0.143,
+ 0.286, 0.286, 0.286,
+ 0.429, 0.429, 0.429,
+ 0.571, 0.571, 0.571,
+ 0.714, 0.714, 0.714,
+ 0.857, 0.857, 0.857,
+ 0.000, 0.447, 0.741,
+ 0.50, 0.5, 0
+ ]
+).astype(np.float32)
+color_list = color_list.reshape((-1, 3)) * 255
diff --git a/pix2text/doc_xl_layout/utils/evaluation_bk.py b/pix2text/doc_xl_layout/utils/evaluation_bk.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f9316ec0529cbae0874a6a63864d396289943a8
--- /dev/null
+++ b/pix2text/doc_xl_layout/utils/evaluation_bk.py
@@ -0,0 +1,437 @@
+import json
+import os
+import sys
+
+import cv2
+import numpy as np
+from shapely.geometry import Polygon
+from tabulate import tabulate
+import time
+
+def visual_badcase(image_name, pred_list, label_list, output_dir="visual_badcase", info=None, prefix=''):
+ """
+ """
+ image_name = image_name + '.jpg'
+ if not os.path.exists(output_dir):
+ os.makedirs(output_dir)
+
+ image_dir = os.path.abspath('../../data/huntie/test_images/')
+ image_path = os.path.join(image_dir, image_name)
+ img = cv2.imread(image_path)
+ if img is None:
+ print("--> Warning: skip, given image dir NOT exists: {}".format(image_path))
+ return None
+
+ font = cv2.FONT_HERSHEY_SIMPLEX
+ img = cv2.imread(image_path)
+ for label in label_list:
+ points, class_id = label[:8], label[8]
+ pts = np.array(points).reshape((1, -1, 2)).astype(np.int32)
+ cv2.polylines(img, pts, isClosed=True, color=(0, 255, 0), thickness=3)
+ cv2.putText(img, "gt:" + str(class_id), tuple(pts[0][0].tolist()), font, 1, (0, 255, 0), 2)
+
+ for label in pred_list:
+ points, class_id = label[:8], label[8]
+ pts = np.array(points).reshape((1, -1, 2)).astype(np.int32)
+ cv2.polylines(img, pts, isClosed=True, color=(255, 0, 0), thickness=3)
+ cv2.putText(img, "pred:" + str(class_id), tuple(pts[0][-1].tolist()), font, 1, (255, 0, 0), 2)
+
+ if info is not None:
+ cv2.putText(img, str(info), (40, 40), font, 1, (0, 0, 255), 2)
+ output_path = os.path.join(output_dir, prefix + os.path.basename(image_path))
+ print("--> info: visualizing badcase: {}".format(output_path))
+ cv2.imwrite(output_path, img)
+
+
+def load_gt_from_json(json_path):
+ """
+ """
+ with open(json_path) as f:
+ gt_info = json.load(f)
+ gt_image_list = gt_info["images"]
+ gt_anno_list = gt_info["annotations"]
+
+ id_to_image_info = {}
+ for image_item in gt_image_list:
+ id_to_image_info[image_item['id']] = {
+ "file_name": image_item['file_name'],
+ "group_name": image_item.get("group_name", "huntie")
+ }
+
+ group_info = {}
+ for annotation_item in gt_anno_list:
+ image_info = id_to_image_info[annotation_item['image_id']]
+ image_name, group_name = image_info["file_name"], image_info["group_name"]
+
+ if group_name not in group_info:
+ group_info[group_name] = {}
+ if image_name not in group_info[group_name]:
+ group_info[group_name][image_name] = []
+ anno_info = {
+ "category_id": annotation_item["category_id"],
+ "poly": annotation_item["poly"],
+ "secondary_id": annotation_item.get("secondary_id", -1),
+ "direction_id": annotation_item.get("direction_id", -1)
+ }
+ group_info[group_name][image_name].append(anno_info)
+
+ group_info_str = ", ".join(["{}[{}]".format(k, len(v)) for k, v in group_info.items()])
+ print("--> load {} groups: {}".format(len(group_info.keys()), group_info_str))
+ return group_info
+
+def save_res_to_file(table_head, table_body_sorted):
+ with open('val_out.txt', 'a') as fout:
+ fout.write(time.strftime('%Y-%m-%d-%H-%M') + '\n')
+ fout.write('\t'.join(table_head) + '\n')
+ for line in table_body_sorted:
+ new_line = []
+ for ele in line:
+ if isinstance(ele, int):
+ new_line.append('{:d}'.format(ele))
+ elif isinstance(ele, float):
+ new_line.append('{:.6f}'.format(ele))
+ elif isinstance(ele, str):
+ new_line.append(ele)
+ fout.write('\t'.join(new_line) + '\n')
+
+def calc_iou(label, detect):
+ label_box = []
+ detect_box = []
+
+ d_area = []
+ for i in range(0, len(detect)):
+ pred_poly = detect[i]["poly"]
+ box_det = []
+ for k in range(0, 4):
+ box_det.append([pred_poly[2 * k], pred_poly[2 * k + 1]])
+ detect_box.append(box_det)
+ try:
+ poly = Polygon(box_det)
+ d_area.append(poly.area)
+ except:
+ print('invalid detects', pred_poly)
+ exit(-1)
+
+ l_area = []
+ for i in range(0, len(label)):
+ gt_poly = label[i]["poly"]
+ box_gt = []
+ for k in range(4):
+ box_gt.append([gt_poly[2 * k], gt_poly[2 * k + 1]])
+ label_box.append(box_gt)
+ try:
+ poly = Polygon(box_gt)
+ l_area.append(poly.area)
+ except:
+ print('invalid detects', gt_poly)
+ exit(-1)
+
+ ol_areas = []
+ for i in range(0, len(detect_box)):
+ ol_areas.append([])
+ poly1 = Polygon(detect_box[i])
+ for j in range(0, len(label_box)):
+ poly2 = Polygon(label_box[j])
+ try:
+ ol_area = poly2.intersection(poly1).area
+ except:
+ print('invaild pair', detect_box[i], label_box[j])
+ ol_areas[i].append(0.0)
+ else:
+ ol_areas[i].append(ol_area)
+
+ d_ious = [0.0] * len(detect_box)
+ l_ious = [0.0] * len(label_box)
+ det2label_idx = [-1] * len(detect_box) # 每个检测框iou最大标注框的index
+ for i in range(0, len(detect_box)):
+ for j in range(0, len(label_box)):
+ if int(label[j]["category_id"]) == int(detect[i]["category_id"]):
+ # iou = min(ol_areas[i][j] / (d_area[i] + 1e-10), ol_areas[i][j] / (l_area[j] + 1e-10))
+ iou = ol_areas[i][j] / (d_area[i] + l_area[j] - ol_areas[i][j] + 1e-10)
+ else:
+ iou = 0
+ det2label_idx[i] = j if iou > d_ious[i] else det2label_idx[i]
+ d_ious[i] = max(d_ious[i], iou)
+ l_ious[j] = max(l_ious[j], iou)
+ return l_ious, d_ious, det2label_idx
+
+
+def eval(instance_info):
+ img_name, label_info = instance_info
+ label = label_info['gt']
+ detect = label_info['det']
+ l_ious, d_ious, det2label_idx = calc_iou(label, detect)
+ return [img_name, d_ious, l_ious, detect, label, det2label_idx]
+
+
+def static_with_class(rets, iou_thresh=0.7, is_verbose=True, map_info=None):
+ if is_verbose:
+ table_head = ['Class_id', 'Class_name', 'Pre_hit', 'Pre_num', 'GT_hit', 'GT_num', 'Precision', 'Recall', 'F-score', 'All_recalled', 'Img_num', 'Acc.']
+ else:
+ table_head = ['Class_id', 'Class_name', 'Precision', 'Recall', 'F-score']
+ table_body = []
+ class_dict = {}
+ all_dict = {} # 用以统计合计结果
+ all_dict['dm'] = 0
+ all_dict['dv'] = 0
+ all_dict['lm'] = 0
+ all_dict['lv'] = 0
+ all_dict['Img_num'] = 0
+ all_dict['All_recalled'] = 0
+
+ no_need_keys = ['group_name', 'poly', 'score' , 'category_id']
+ # import pdb; pdb.set_trace()
+ extra_keys = [_ for _ in rets[0][4][0].keys() if _ not in no_need_keys]
+ # extra_table_heads = [[_] for _ in rets[0][4][0].keys() if _ not in no_need_keys]
+ extra_table_heads = {}
+ extra_dict = {}
+ extra_table_body = {}
+ for key in extra_keys:
+ extra_table_heads[key] = [key, 'Name', 'Pre_hit', 'Pre_num', 'GT_hit', 'GT_num', 'Precision', 'Recall', 'F-score']
+ extra_dict[key] = {}
+ extra_table_body[key] = []
+ # _ += ['Pre_hit', 'Pre_num', 'GT_hit', 'GT_num', 'Precision', 'Recall', 'F-score']
+
+ # pdb.set_trace()
+ for i in range(len(rets)):
+ img_name, d_ious, l_ious, detects, labels, det2label_idx = rets[i]
+ item_lv, item_dv, item_dm, item_lm = 0, 0, 0, 0
+ current_dict = {}
+
+ for label in labels:
+ item_lv += 1
+ category_id = label["category_id"]
+ if category_id not in class_dict:
+ class_dict[category_id] = {}
+ class_dict[category_id]['dm'] = 0
+ class_dict[category_id]['dv'] = 0
+ class_dict[category_id]['lm'] = 0
+ class_dict[category_id]['lv'] = 0
+ class_dict[category_id]['Img_num'] = 0
+ class_dict[category_id]['All_recalled'] = 0
+ class_dict[category_id]['lv'] += 1
+
+ category_container = []
+ for label in labels:
+ if label['category_id'] not in category_container:
+ category_container.append(label['category_id'])
+ for category_id in category_container:
+ class_dict[category_id]['Img_num'] += 1
+ current_dict[category_id] = {'dm':0, 'dv':0, 'lm':0, 'lv':0, 'Img_num':0, 'All_recalled':0}
+ # 统计各额外key的id list和label、detect中检出的量
+ for key in extra_keys:
+ for label in labels:
+ if label[key] not in extra_dict[key] and label[key] != -1:
+ extra_dict[key][label[key]] = {'dm':0, 'dv':0, 'lm':0, 'lv':0}
+ for det in detects:
+ if det[key] not in extra_dict[key] and det[key] != -1:
+ extra_dict[key][det[key]] = {'dm':0, 'dv':0, 'lm':0, 'lv':0}
+ for label in labels:
+ if label[key] != -1:
+ extra_dict[key][label[key]]['lv'] += 1
+ for det in detects:
+ if det[key] != -1:
+ try:
+ extra_dict[key][det[key]]['dv'] += 1
+ except:
+ import pdb; pdb.set_trace()
+
+ for label in labels:
+ current_dict[label['category_id']]['lv'] += 1
+ for det in detects:
+ current_dict[label['category_id']]['dv'] += 1
+
+ for det in detects:
+ item_dv += 1
+ category_id = det["category_id"]
+ if category_id not in class_dict:
+ print("--> category_id not exists in gt: {}".format(category_id))
+ continue
+ class_dict[category_id]['dv'] += 1
+
+ for idx, iou in enumerate(d_ious):
+ if iou >= iou_thresh:
+ item_dm += 1
+ class_dict[detects[idx]["category_id"]]['dm'] += 1
+ current_dict[detects[idx]["category_id"]]['dm'] += 1
+
+ for key in extra_keys:
+ if labels[det2label_idx[idx]][key] != -1 and detects[idx][key] == labels[det2label_idx[idx]][key]:
+ extra_dict[key][detects[idx][key]]['dm'] += 1
+ extra_dict[key][detects[idx][key]]['lm'] += 1
+
+ for idx, iou in enumerate(l_ious):
+ if iou >= iou_thresh:
+ item_lm += 1
+ class_dict[labels[idx]["category_id"]]['lm'] += 1
+ current_dict[labels[idx]["category_id"]]['lm'] += 1
+
+
+
+ # 将recall append到结果list当中
+ item_r = item_lm / (item_lv + 1e-6)
+ # item_p = item_dm / (item_dv + 1e-6)
+ # item_f = 2 * item_p * item_r / (item_p + item_r + 1e-6)
+ # if (1 - item_r) < 1e-5:
+ # class_dict[category_id]['All_recalled'] += 1
+ rets[i].append(item_r)
+
+ # 计算各个box类别全召回率
+ for category_id in category_container:
+ id_recall = current_dict[category_id]['lm'] / (current_dict[category_id]['lv'] + 1e-6)
+ if (1 - id_recall) < 1e-5:
+ class_dict[category_id]['All_recalled'] += 1
+
+ # 计算所有类别总计的全召回率
+ # import pdb; pdb.set_trace()
+ all_dict['dv'] += item_dv
+ all_dict['lv'] += item_lv
+ all_dict['dm'] += item_dm
+ all_dict['lm'] += item_lm
+ all_dict['Img_num'] += 1
+ if (1 - item_r) < 1e-5:
+ all_dict['All_recalled'] += 1
+
+ # if img_name == 'train10w_val2w_69008cd9828a455fb1bf751a95ad8921.jpg':
+ # import pdb; pdb.set_trace()
+ # if item_r
+ # if item_f < 0.97 and is_save_badcase:
+ # prefix = '_'.join(map(str, sorted(list(badcase_class_set)))) + '_'
+ # item_info = "IOU{}, {}, {}, {}".format(iou_thresh, item_r, item_p, item_f)
+ # visual_badcase(img_name, detects, labels, output_dir="visual_badcase", info=item_info, prefix=prefix)
+
+ dm, dv, lm, lv, total, recalled = 0, 0, 0, 0, 0, 0
+ map_info = {} if map_info is None else map_info
+ for key in class_dict.keys():
+ dm += class_dict[key]['dm']
+ dv += class_dict[key]['dv']
+ lm += class_dict[key]['lm']
+ lv += class_dict[key]['lv']
+ recalled += class_dict[category_id]['All_recalled']
+ total += class_dict[key]['Img_num']
+ p = class_dict[key]['dm'] / (class_dict[key]['dv'] + 1e-6)
+ r = class_dict[key]['lm'] / (class_dict[key]['lv'] + 1e-6)
+ fscore = 2 * p * r / (p + r + 1e-6)
+ acc = class_dict[key]['All_recalled'] / (class_dict[key]['Img_num'] + 1e-6)
+ if is_verbose:
+ table_body.append((key, map_info.get("primary_map", {}).get(str(key), str(key)), class_dict[key]['dm'],
+ class_dict[key]['dv'], class_dict[key]['lm'], class_dict[key]['lv'], p, r, fscore,
+ class_dict[category_id]['All_recalled'], class_dict[key]['Img_num'], acc))
+ else:
+ table_body.append((key, map_info.get(str(key), str(key)), p, r, fscore))
+
+ p = dm / (dv + 1e-6)
+ r = lm / (lv + 1e-6)
+ f = 2 * p * r / (p + r + 1e-6)
+ acc = recalled / (total + 1e-6)
+ table_body_sorted = sorted(table_body, key=lambda x: int((x[0])))
+ if is_verbose:
+ table_body_sorted.append(('IOU_{}'.format(iou_thresh), 'average', dm, dv, lm, lv, p, r, f,
+ all_dict['All_recalled'], all_dict['Img_num'], (all_dict['All_recalled']/all_dict['Img_num']+1e-6)))
+ else:
+ table_body_sorted.append(('IOU_{}'.format(iou_thresh), 'average', p, r, f))
+ # import pdb; pdb.set_trace()
+ save_res_to_file(table_head, table_body_sorted)
+ print(tabulate(table_body_sorted, headers=table_head, tablefmt='pipe'))
+ # ---------------print(extra_keys)
+ for _key in extra_dict.keys():
+ dm, dv, lm, lv = 0, 0, 0, 0
+ for key in extra_dict[_key].keys():
+ dm += extra_dict[_key][key]['dm']
+ dv += extra_dict[_key][key]['dv']
+ lm += extra_dict[_key][key]['lm']
+ lv += extra_dict[_key][key]['lv']
+ # 找当前key对应的map_info key的name
+ map_name = ''
+ for candidate_name in map_info.keys():
+ if candidate_name.split('_')[0] == _key.split('_')[0]:
+ map_name = candidate_name
+
+ precision = extra_dict[_key][key]['dm'] / (extra_dict[_key][key]['dv'] + 1e-6)
+ recall = extra_dict[_key][key]['lm'] / (extra_dict[_key][key]['lv'] + 1e-6)
+ fscore = 2 * precision * recall / (precision + recall + 1e-6)
+ if map_name == '': # 没有在map_info中找到对应类表
+ extra_table_body[_key].append((key, '', extra_dict[_key][key]['dm'], extra_dict[_key][key]['dv'],
+ extra_dict[_key][key]['lm'], extra_dict[_key][key]['lv'],
+ precision, recall, fscore))
+ else:
+ extra_table_body[_key].append((key, map_info.get(map_name, {}).get(str(key), str(key)), extra_dict[_key][key]['dm'], extra_dict[_key][key]['dv'],
+ extra_dict[_key][key]['lm'], extra_dict[_key][key]['lv'],
+ precision, recall, fscore))
+ extra_table_body[_key] = sorted(extra_table_body[_key], key=lambda x: int((x[0])))
+ p = dm / (dv + 1e-6)
+ r = lm / (lv + 1e-6)
+ f = 2 * p * r / (p + r + 1e-6)
+ extra_table_body[_key].append((key, 'average', dm, dv, lm, lv, p, r, f))
+ # import pdb; pdb.set_trace()
+ for _key in extra_keys:
+ save_res_to_file(extra_table_heads[_key], extra_table_body[_key])
+ print(tabulate(extra_table_body[_key], headers=extra_table_heads[_key], tablefmt='pipe'))
+
+ return [table_head] + table_body_sorted
+
+
+def multiproc(func, task_list, proc_num=30, retv=True, progress_bar=False):
+ from multiprocessing import Pool
+ pool = Pool(proc_num)
+
+ rets = []
+ if progress_bar:
+ import tqdm
+ with tqdm.tqdm(total=len(task_list)) as t:
+ for ret in pool.imap(func, task_list):
+ rets.append(ret)
+ t.update(1)
+ else:
+ for ret in pool.imap(func, task_list):
+ rets.append(ret)
+
+ pool.close()
+ pool.join()
+
+ if retv:
+ return rets
+
+
+def eval_and_show(label_dict, detect_dict, output_dir, iou_thresh=0.7, map_info=None):
+ """
+ """
+ evaluation_group_info = {}
+ for group_name, gt_info in label_dict.items():
+ group_pair_list = []
+ for file_name, value_list in gt_info.items():
+ if file_name not in detect_dict:
+ # print("--> missing pred:", file_name)
+ continue
+ group_pair_list.append([file_name, {'gt': gt_info[file_name], 'det': detect_dict[file_name]}])
+ evaluation_group_info[group_name] = group_pair_list
+
+ res_info_all = {}
+ for group_name, group_pair_list in evaluation_group_info.items():
+ print(" ------- group name: {} -----------".format(group_name))
+ rets = multiproc(eval, group_pair_list, proc_num=16)
+ # import pdb; pdb.set_trace()
+ group_name_map_info = map_info.get(group_name, None) if map_info is not None else None
+ res_info = static_with_class(rets, iou_thresh=iou_thresh, map_info=group_name_map_info)
+ res_info_all[group_name] = res_info
+
+ evaluation_res_info_path = os.path.join(output_dir, "results_val.json")
+ with open(evaluation_res_info_path, "w") as f:
+ json.dump(res_info_all, f, ensure_ascii=False, indent=4)
+ print("--> info: evaluation result is saved at {}".format(evaluation_res_info_path))
+ return rets
+
+if __name__ == "__main__":
+
+ if len(sys.argv) != 5:
+ print("Usage: python {} gt_json_path pred_json_path output_dir iou_thresh".format(__file__))
+ exit(-1)
+ else:
+ print('--> info: {}'.format(sys.argv))
+ gt_json_path, pred_json_path, output_dir, iou_thresh = sys.argv[1], sys.argv[2], sys.argv[3], float(sys.argv[4])
+
+ label_dict = load_gt_from_json(gt_json_path)
+ with open(pred_json_path, "r") as f:
+ detect_dict = json.load(f)
+ res_info = eval_and_show(label_dict, detect_dict, output_dir, iou_thresh=iou_thresh, map_info=None)
+
diff --git a/pix2text/doc_xl_layout/utils/image.py b/pix2text/doc_xl_layout/utils/image.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ea882def710899d7f4b5eb0ea4a8f5409d6bc43
--- /dev/null
+++ b/pix2text/doc_xl_layout/utils/image.py
@@ -0,0 +1,242 @@
+# ------------------------------------------------------------------------------
+# Copyright (c) Microsoft
+# Licensed under the MIT License.
+# Written by Bin Xiao (Bin.Xiao@microsoft.com)
+# Modified by Xingyi Zhou
+# ------------------------------------------------------------------------------
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import random
+
+import cv2
+import numpy as np
+
+
+def flip(img):
+ return img[:, :, ::-1].copy()
+
+
+def transform_preds(coords, center, scale, output_size):
+ target_coords = np.zeros(coords.shape)
+ trans = get_affine_transform(center, scale, 0, output_size, inv=1)
+ for p in range(coords.shape[0]):
+ target_coords[p, 0:2] = affine_transform(coords[p, 0:2], trans)
+ return target_coords
+
+
+def get_affine_transform(center,
+ scale,
+ rot,
+ output_size,
+ shift=np.array([0, 0], dtype=np.float32),
+ inv=0):
+ if not isinstance(scale, np.ndarray) and not isinstance(scale, list):
+ scale = np.array([scale, scale], dtype=np.float32)
+
+ scale_tmp = scale
+ src_w = scale_tmp[0]
+ dst_w = output_size[0]
+ dst_h = output_size[1]
+
+ rot_rad = np.pi * rot / 180
+ src_dir = get_dir([0, src_w * -0.5], rot_rad)
+ dst_dir = np.array([0, dst_w * -0.5], np.float32)
+
+ src = np.zeros((3, 2), dtype=np.float32)
+ dst = np.zeros((3, 2), dtype=np.float32)
+ src[0, :] = center + scale_tmp * shift
+ src[1, :] = center + src_dir + scale_tmp * shift
+ dst[0, :] = [dst_w * 0.5, dst_h * 0.5]
+ dst[1, :] = np.array([dst_w * 0.5, dst_h * 0.5], np.float32) + dst_dir
+
+ src[2:, :] = get_3rd_point(src[0, :], src[1, :])
+ dst[2:, :] = get_3rd_point(dst[0, :], dst[1, :])
+
+ if inv:
+ trans = cv2.getAffineTransform(np.float32(dst), np.float32(src))
+ else:
+ trans = cv2.getAffineTransform(np.float32(src), np.float32(dst))
+
+ return trans
+
+
+def affine_transform(pt, t):
+ new_pt = np.array([pt[0], pt[1], 1.], dtype=np.float32).T
+ new_pt = np.dot(t, new_pt)
+ return new_pt[:2]
+
+
+def get_3rd_point(a, b):
+ direct = a - b
+ return b + np.array([-direct[1], direct[0]], dtype=np.float32)
+
+
+def get_dir(src_point, rot_rad):
+ sn, cs = np.sin(rot_rad), np.cos(rot_rad)
+
+ src_result = [0, 0]
+ src_result[0] = src_point[0] * cs - src_point[1] * sn
+ src_result[1] = src_point[0] * sn + src_point[1] * cs
+
+ return src_result
+
+
+def crop(img, center, scale, output_size, rot=0):
+ trans = get_affine_transform(center, scale, rot, output_size)
+
+ dst_img = cv2.warpAffine(img,
+ trans,
+ (int(output_size[0]), int(output_size[1])),
+ flags=cv2.INTER_LINEAR)
+
+ return dst_img
+
+
+def gaussian_radius(det_size, min_overlap=0.7):
+ height, width = det_size
+
+ a1 = 1
+ b1 = (height + width)
+ c1 = width * height * (1 - min_overlap) / (1 + min_overlap)
+ sq1 = np.sqrt(b1 ** 2 - 4 * a1 * c1)
+ r1 = (b1 + sq1) / 2
+
+ a2 = 4
+ b2 = 2 * (height + width)
+ c2 = (1 - min_overlap) * width * height
+ sq2 = np.sqrt(b2 ** 2 - 4 * a2 * c2)
+ r2 = (b2 + sq2) / 2
+
+ a3 = 4 * min_overlap
+ b3 = -2 * min_overlap * (height + width)
+ c3 = (min_overlap - 1) * width * height
+ sq3 = np.sqrt(b3 ** 2 - 4 * a3 * c3)
+ r3 = (b3 + sq3) / 2
+ return min(r1, r2, r3)
+
+
+def gaussian2D(shape, sigma=1):
+ m, n = [(ss - 1.) / 2. for ss in shape]
+ y, x = np.ogrid[-m:m + 1, -n:n + 1]
+
+ h = np.exp(-(x * x + y * y) / (2 * sigma * sigma))
+ h[h < np.finfo(h.dtype).eps * h.max()] = 0
+ return h
+
+
+def draw_umich_gaussian(heatmap, center, radius, k=1):
+ diameter = 2 * radius + 1
+ gaussian = gaussian2D((diameter, diameter), sigma=diameter / 6)
+
+ x, y = int(center[0]), int(center[1])
+
+ height, width = heatmap.shape[0:2]
+
+ left, right = min(x, radius), min(width - x, radius + 1)
+ top, bottom = min(y, radius), min(height - y, radius + 1)
+
+ masked_heatmap = heatmap[y - top:y + bottom, x - left:x + right]
+ masked_gaussian = gaussian[radius - top:radius + bottom, radius - left:radius + right]
+ if min(masked_gaussian.shape) > 0 and min(masked_heatmap.shape) > 0: # TODO debug
+ np.maximum(masked_heatmap, masked_gaussian * k, out=masked_heatmap)
+ return heatmap
+
+
+def draw_dense_reg(regmap, heatmap, center, value, radius, is_offset=False):
+ diameter = 2 * radius + 1
+ gaussian = gaussian2D((diameter, diameter), sigma=diameter / 6)
+ value = np.array(value, dtype=np.float32).reshape(-1, 1, 1)
+ dim = value.shape[0]
+ reg = np.ones((dim, diameter * 2 + 1, diameter * 2 + 1), dtype=np.float32) * value
+ if is_offset and dim == 2:
+ delta = np.arange(diameter * 2 + 1) - radius
+ reg[0] = reg[0] - delta.reshape(1, -1)
+ reg[1] = reg[1] - delta.reshape(-1, 1)
+
+ x, y = int(center[0]), int(center[1])
+
+ height, width = heatmap.shape[0:2]
+
+ left, right = min(x, radius), min(width - x, radius + 1)
+ top, bottom = min(y, radius), min(height - y, radius + 1)
+
+ masked_heatmap = heatmap[y - top:y + bottom, x - left:x + right]
+ masked_regmap = regmap[:, y - top:y + bottom, x - left:x + right]
+ masked_gaussian = gaussian[radius - top:radius + bottom,
+ radius - left:radius + right]
+ masked_reg = reg[:, radius - top:radius + bottom,
+ radius - left:radius + right]
+ if min(masked_gaussian.shape) > 0 and min(masked_heatmap.shape) > 0: # TODO debug
+ idx = (masked_gaussian >= masked_heatmap).reshape(
+ 1, masked_gaussian.shape[0], masked_gaussian.shape[1])
+ masked_regmap = (1 - idx) * masked_regmap + idx * masked_reg
+ regmap[:, y - top:y + bottom, x - left:x + right] = masked_regmap
+ return regmap
+
+
+def draw_msra_gaussian(heatmap, center, sigma):
+ tmp_size = sigma * 3
+ mu_x = int(center[0] + 0.5)
+ mu_y = int(center[1] + 0.5)
+ w, h = heatmap.shape[0], heatmap.shape[1]
+ ul = [int(mu_x - tmp_size), int(mu_y - tmp_size)]
+ br = [int(mu_x + tmp_size + 1), int(mu_y + tmp_size + 1)]
+ if ul[0] >= h or ul[1] >= w or br[0] < 0 or br[1] < 0:
+ return heatmap
+ size = 2 * tmp_size + 1
+ x = np.arange(0, size, 1, np.float32)
+ y = x[:, np.newaxis]
+ x0 = y0 = size // 2
+ g = np.exp(- ((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))
+ g_x = max(0, -ul[0]), min(br[0], h) - ul[0]
+ g_y = max(0, -ul[1]), min(br[1], w) - ul[1]
+ img_x = max(0, ul[0]), min(br[0], h)
+ img_y = max(0, ul[1]), min(br[1], w)
+ heatmap[img_y[0]:img_y[1], img_x[0]:img_x[1]] = np.maximum(
+ heatmap[img_y[0]:img_y[1], img_x[0]:img_x[1]],
+ g[g_y[0]:g_y[1], g_x[0]:g_x[1]])
+ return heatmap
+
+
+def grayscale(image):
+ return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+
+def lighting_(data_rng, image, alphastd, eigval, eigvec):
+ alpha = data_rng.normal(scale=alphastd, size=(3,))
+ image += np.dot(eigvec, eigval * alpha)
+
+
+def blend_(alpha, image1, image2):
+ image1 *= alpha
+ image2 *= (1 - alpha)
+ image1 += image2
+
+
+def saturation_(data_rng, image, gs, gs_mean, var):
+ alpha = 1. + data_rng.uniform(low=-var, high=var)
+ blend_(alpha, image, gs[:, :, None])
+
+
+def brightness_(data_rng, image, gs, gs_mean, var):
+ alpha = 1. + data_rng.uniform(low=-var, high=var)
+ image *= alpha
+
+
+def contrast_(data_rng, image, gs, gs_mean, var):
+ alpha = 1. + data_rng.uniform(low=-var, high=var)
+ blend_(alpha, image, gs_mean)
+
+
+def color_aug(data_rng, image, eig_val, eig_vec):
+ functions = [brightness_, contrast_, saturation_]
+ random.shuffle(functions)
+
+ gs = grayscale(image)
+ gs_mean = gs.mean()
+ for f in functions:
+ f(data_rng, image, gs, gs_mean, 0.4)
+ lighting_(data_rng, image, 0.1, eig_val, eig_vec)
diff --git a/pix2text/doc_xl_layout/utils/post_process.py b/pix2text/doc_xl_layout/utils/post_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa6025cfe13bdcbf94461aab923bb9ebc4e1963d
--- /dev/null
+++ b/pix2text/doc_xl_layout/utils/post_process.py
@@ -0,0 +1,143 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import numpy as np
+
+from .ddd_utils import ddd2locrot
+from .image import transform_preds
+
+
+def get_pred_depth(depth):
+ return depth
+
+
+def get_alpha(rot):
+ # output: (B, 8) [bin1_cls[0], bin1_cls[1], bin1_sin, bin1_cos,
+ # bin2_cls[0], bin2_cls[1], bin2_sin, bin2_cos]
+ # return rot[:, 0]
+ idx = rot[:, 1] > rot[:, 5]
+ alpha1 = np.arctan(rot[:, 2] / rot[:, 3]) + (-0.5 * np.pi)
+ alpha2 = np.arctan(rot[:, 6] / rot[:, 7]) + (0.5 * np.pi)
+ return alpha1 * idx + alpha2 * (1 - idx)
+
+
+def ddd_post_process_2d(dets, c, s, opt):
+ # dets: batch x max_dets x dim
+ # return 1-based class det list
+ ret = []
+ include_wh = dets.shape[2] > 16
+ for i in range(dets.shape[0]):
+ top_preds = {}
+ dets[i, :, :2] = transform_preds(
+ dets[i, :, 0:2], c[i], s[i], (opt.output_w, opt.output_h))
+ classes = dets[i, :, -1]
+ for j in range(opt.num_classes):
+ inds = (classes == j)
+ top_preds[j + 1] = np.concatenate([
+ dets[i, inds, :3].astype(np.float32),
+ get_alpha(dets[i, inds, 3:11])[:, np.newaxis].astype(np.float32),
+ get_pred_depth(dets[i, inds, 11:12]).astype(np.float32),
+ dets[i, inds, 12:15].astype(np.float32)], axis=1)
+ if include_wh:
+ top_preds[j + 1] = np.concatenate([
+ top_preds[j + 1],
+ transform_preds(
+ dets[i, inds, 15:17], c[i], s[i], (opt.output_w, opt.output_h))
+ .astype(np.float32)], axis=1)
+ ret.append(top_preds)
+ return ret
+
+
+def ddd_post_process_3d(dets, calibs):
+ # dets: batch x max_dets x dim
+ # return 1-based class det list
+ ret = []
+ for i in range(len(dets)):
+ preds = {}
+ for cls_ind in dets[i].keys():
+ preds[cls_ind] = []
+ for j in range(len(dets[i][cls_ind])):
+ center = dets[i][cls_ind][j][:2]
+ score = dets[i][cls_ind][j][2]
+ alpha = dets[i][cls_ind][j][3]
+ depth = dets[i][cls_ind][j][4]
+ dimensions = dets[i][cls_ind][j][5:8]
+ wh = dets[i][cls_ind][j][8:10]
+ locations, rotation_y = ddd2locrot(
+ center, alpha, dimensions, depth, calibs[0])
+ bbox = [center[0] - wh[0] / 2, center[1] - wh[1] / 2,
+ center[0] + wh[0] / 2, center[1] + wh[1] / 2]
+ pred = [alpha] + bbox + dimensions.tolist() + \
+ locations.tolist() + [rotation_y, score]
+ preds[cls_ind].append(pred)
+ preds[cls_ind] = np.array(preds[cls_ind], dtype=np.float32)
+ ret.append(preds)
+ return ret
+
+
+def ddd_post_process(dets, c, s, calibs, opt):
+ # dets: batch x max_dets x dim
+ # return 1-based class det list
+ dets = ddd_post_process_2d(dets, c, s, opt)
+ dets = ddd_post_process_3d(dets, calibs)
+ return dets
+
+
+def ctdet_4ps_post_process(dets, c, s, h, w, num_classes):
+ # dets: batch x max_dets x dim
+ # return 1-based class det dict
+ ret = []
+ for i in range(dets.shape[0]):
+ top_preds = {}
+ dets[i, :, 0:2] = transform_preds(dets[i, :, 0:2], c[i], s[i], (w, h))
+ dets[i, :, 2:4] = transform_preds(dets[i, :, 2:4], c[i], s[i], (w, h))
+ dets[i, :, 4:6] = transform_preds(dets[i, :, 4:6], c[i], s[i], (w, h))
+ dets[i, :, 6:8] = transform_preds(dets[i, :, 6:8], c[i], s[i], (w, h))
+ classes = dets[i, :, 9]
+ for j in range(num_classes):
+ inds = (classes == j)
+ top_preds[j + 1] = np.concatenate([
+ dets[i, inds, :8].astype(np.float32),
+ dets[i, inds, 8:].astype(np.float32)], axis=1).tolist()
+ ret.append(top_preds)
+ return ret
+
+
+def ctdet_post_process(dets, c, s, h, w, num_classes):
+ # dets: batch x max_dets x dim
+ # return 1-based class det dict
+ ret = []
+ for i in range(dets.shape[0]):
+ top_preds = {}
+ dets[i, :, :2] = transform_preds(
+ dets[i, :, 0:2], c[i], s[i], (w, h))
+ dets[i, :, 2:4] = transform_preds(
+ dets[i, :, 2:4], c[i], s[i], (w, h))
+ classes = dets[i, :, -1]
+ for j in range(num_classes):
+ inds = (classes == j)
+ top_preds[j + 1] = np.concatenate([
+ dets[i, inds, :4].astype(np.float32),
+ dets[i, inds, 4:5].astype(np.float32)], axis=1).tolist()
+ ret.append(top_preds)
+ return ret
+
+
+def ctdet_corner_post_process(corner, c, s, h, w, num_classes):
+ corner[:, :2] = transform_preds(corner[:, 0:2], c[0], s[0], (w, h))
+ return corner
+
+
+def multi_pose_post_process(dets, c, s, h, w):
+ # dets: batch x max_dets x 40
+ # return list of 39 in image coord
+ ret = []
+ for i in range(dets.shape[0]):
+ bbox = transform_preds(dets[i, :, :4].reshape(-1, 2), c[i], s[i], (w, h))
+ pts = transform_preds(dets[i, :, 5:39].reshape(-1, 2), c[i], s[i], (w, h))
+ top_preds = np.concatenate(
+ [bbox.reshape(-1, 4), dets[i, :, 4:5],
+ pts.reshape(-1, 34)], axis=1).astype(np.float32).tolist()
+ ret.append({np.ones(1, dtype=np.int32)[0]: top_preds})
+ return ret
diff --git a/pix2text/doc_xl_layout/utils/utils.py b/pix2text/doc_xl_layout/utils/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..3af045a9c6786cd092c0f911555b1254c8aa27a7
--- /dev/null
+++ b/pix2text/doc_xl_layout/utils/utils.py
@@ -0,0 +1,23 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+
+class AverageMeter(object):
+ """Computes and stores the average and current value"""
+
+ def __init__(self):
+ self.reset()
+
+ def reset(self):
+ self.val = 0
+ self.avg = 0
+ self.sum = 0
+ self.count = 0
+
+ def update(self, val, n=1):
+ self.val = val
+ self.sum += val * n
+ self.count += n
+ if self.count > 0:
+ self.avg = self.sum / self.count
diff --git a/pix2text/doc_xl_layout/wrapper.py b/pix2text/doc_xl_layout/wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ddc6248cb5d42af472b63267452dcd2147498d3
--- /dev/null
+++ b/pix2text/doc_xl_layout/wrapper.py
@@ -0,0 +1,285 @@
+import math
+from shapely.geometry import Polygon
+from functools import cmp_to_key
+
+
+def calc_main_angle(pts_list):
+ if len(pts_list) == 0:
+ return 0
+ good_angles, other_angles = [], []
+ for pts in pts_list:
+ d_x_1, d_y_1 = pts[2] - pts[0], pts[3] - pts[1]
+ d_x_2, d_y_2 = pts[4] - pts[2], pts[5] - pts[3]
+
+ width = math.sqrt(d_x_1 ** 2 + d_y_1 ** 2)
+ height = math.sqrt(d_x_2 ** 2 + d_y_2 ** 2)
+ angle = math.atan2(d_y_1, d_x_1)
+
+ if width > height * 3:
+ good_angles.append(angle)
+ else:
+ other_angles.append(angle)
+
+ if len(good_angles) > 0:
+ good_angles.sort()
+ return good_angles[len(good_angles) // 2]
+ else:
+ other_angles.sort()
+ return other_angles[len(other_angles) // 2]
+
+
+def calc_x_type(a, b):
+ x_type = 0
+ minx_a, maxx_a = a[0], a[0] + a[2]
+ minx_b, maxx_b = b[0], b[0] + b[2]
+
+ start_left = 0
+ if minx_a < minx_b:
+ start_left = 1
+ elif minx_a > minx_b:
+ start_left = -1
+ end_right = 0
+ if maxx_a > maxx_b:
+ end_right = 1
+ elif maxx_a < maxx_b:
+ end_right = -1
+
+ if maxx_a < minx_b + 1e-4 and maxx_a < maxx_b - 1e-4:
+ x_type = 1 # left
+ elif minx_a > maxx_b - 1e-4 and minx_a > minx_b + 1e-4:
+ x_type = 2 # right
+ elif start_left == 1 and end_right == -1:
+ x_type = 3 # near left
+ elif start_left == -1 and end_right == 1:
+ x_type = 4 # near right
+ elif start_left >= 0 and end_right >= 0:
+ x_type = 5 # contain
+ elif start_left <= 0 and end_right <= 0:
+ x_type = 6 # inside
+ else:
+ x_type = 0
+
+ return x_type
+
+
+def calc_y_type(a, b):
+ y_type = 0
+ miny_a, maxy_a = a[1], a[1] + a[3]
+ miny_b, maxy_b = b[1], b[1] + b[3]
+
+ start_up = 0
+ if miny_a < miny_b:
+ start_up = 1
+ elif miny_a > miny_b:
+ start_up = -1
+ end_down = 0
+ if maxy_a > maxy_b:
+ end_down = 1
+ elif maxy_a < maxy_b:
+ end_down = -1
+
+ if maxy_a < miny_b + 1e-4 and maxy_a < maxy_b - 1e-4:
+ y_type = 1 # up
+ elif miny_a > maxy_b - 1e-4 and miny_a > miny_b + 1e-4:
+ y_type = 2 # down
+ elif start_up == 1 and end_down == -1:
+ y_type = 3 # near up
+ elif start_up == -1 and end_down == 1:
+ y_type = 4 # near down
+ elif start_up >= 0 and end_down >= 0:
+ y_type = 5 # contain
+ elif start_up <= 0 and end_down <= 0:
+ y_type = 6 # inside
+ else:
+ y_type = 0
+
+ return y_type
+
+
+def sort_pts(blocks):
+ main_angle = calc_main_angle([blk['pts'] for blk in blocks])
+ main_sin, main_cos = math.sin(main_angle), math.cos(main_angle)
+
+ def pts2rect(pts):
+ xs, ys = [], []
+ for k in range(0, len(pts), 2):
+ x0 = pts[k] * main_cos + pts[k + 1] * main_sin
+ y0 = pts[k + 1] * main_cos - pts[k] * main_sin
+ xs.append(x0)
+ ys.append(y0)
+ minx, maxx, miny, maxy = min(xs), max(xs), min(ys), max(ys)
+ rect = [minx, miny, maxx - minx, maxy - miny]
+ # print('===', pts, '->', rect)
+ return rect
+
+ def cmp_pts_udlr(a, b, thres=0.5):
+ rect_a, rect_b = pts2rect(a['pts']), pts2rect(b['pts'])
+ minx_a, miny_a, maxx_a, maxy_a = (
+ rect_a[0],
+ rect_a[1],
+ rect_a[0] + rect_a[2],
+ rect_a[1] + rect_a[3],
+ )
+ minx_b, miny_b, maxx_b, maxy_b = (
+ rect_b[0],
+ rect_b[1],
+ rect_b[0] + rect_b[2],
+ rect_b[1] + rect_b[3],
+ )
+
+ x_type, y_type = calc_x_type(rect_a, rect_b), calc_y_type(rect_a, rect_b)
+
+ y_near_rate = 0.0
+ if y_type == 3:
+ y_near_rate = (maxy_a - miny_b) / min(maxy_a - miny_a, maxy_b - miny_b)
+ elif y_type == 4:
+ y_near_rate = (maxy_b - miny_a) / min(maxy_a - miny_a, maxy_b - miny_b)
+
+ # print(rect_a, rect_b, x_type, y_type, y_near_rate)
+ # exit(0)
+
+ if y_type == 1:
+ return -1
+ elif y_type == 2:
+ return 1
+ elif y_type == 3:
+ if x_type in [2, 4]:
+ if y_near_rate < thres:
+ return -1
+ else:
+ return 1
+ else:
+ return -1
+ elif y_type == 4:
+ if x_type in [1, 3]:
+ if y_near_rate < thres:
+ return 1
+ else:
+ return -1
+ else:
+ return 1
+ else:
+ if x_type == 1 or x_type == 3:
+ return -1
+ elif x_type == 2 or x_type == 4:
+ return 1
+ else:
+ center_y_diff = abs(0.5 * (miny_a + maxy_a) - 0.5 * (miny_b + maxy_b))
+ max_h = max(maxy_a - miny_a, maxy_b - miny_b)
+ if center_y_diff / max_h < 0.1:
+ if (minx_a + maxx_a) < (minx_b + maxx_b):
+ return -1
+ elif (minx_a + maxx_a) > (minx_b + maxx_b):
+ return 1
+ else:
+ return 0
+ else:
+ if (miny_a + maxy_a) < (miny_b + maxy_b):
+ return -1
+ elif (miny_a + maxy_a) > (miny_b + maxy_b):
+ return 1
+ else:
+ return 0
+
+ # print(blocks)
+ # print(cmp_pts_udlr(blocks[0], blocks[1]))
+ blocks.sort(key=cmp_to_key(cmp_pts_udlr))
+ # print(blocks)
+ # exit(0)
+
+
+def pts2poly(pts):
+ new_pts = [(pts[k], pts[k + 1]) for k in range(0, len(pts), 2)]
+ return Polygon(new_pts)
+
+
+def pts_intersection_rate(src, tgt):
+ src_poly, tgt_poly = pts2poly(src), pts2poly(tgt)
+ src_area = src_poly.area
+ inter_area = src_poly.intersection(tgt_poly).area
+ return inter_area / src_area
+
+
+def wrap_result(layout_detection_info, subfield_detection_info, category_map):
+ if layout_detection_info is None or subfield_detection_info is None:
+ return {}
+ # layout_detection_info = result["layout_dets"]
+ # subfield_detection_info = result["subfield_dets"]
+
+ info = {'subfields': []}
+ for itm in subfield_detection_info:
+ subfield = {
+ 'category': category_map[itm['category_id']],
+ 'pts': itm['poly'],
+ 'confidence': itm['score'],
+ 'layouts': [],
+ }
+ info['subfields'].append(subfield)
+ sort_pts(info['subfields'])
+
+ if len(info['subfields']) > 0:
+ other_subfield = {
+ 'category': '其他',
+ 'pts': [0, 0, 0, 0, 0, 0, 0, 0],
+ 'confidence': 0,
+ 'layouts': [],
+ }
+ for itm in layout_detection_info:
+ layout = {
+ 'category': category_map[itm['category_id']],
+ 'pts': itm['poly'],
+ 'confidence': itm['score'],
+ }
+ best_rate, best_idx = 0.0, -1
+ for k in range(len(info['subfields'])):
+ inter_rate = pts_intersection_rate(
+ layout['pts'], info['subfields'][k]['pts']
+ )
+ if inter_rate > best_rate:
+ best_rate = inter_rate
+ best_idx = k
+ if best_idx >= 0 and best_rate > 0.1:
+ info['subfields'][best_idx]['layouts'].append(layout)
+ else:
+ other_subfield['layouts'].append(layout)
+ if len(other_subfield['layouts']) > 0:
+ info['subfields'].append(other_subfield)
+ else:
+ subfield = {
+ 'category': '其他',
+ 'pts': [0, 0, 0, 0, 0, 0, 0, 0],
+ 'confidence': 0,
+ 'layouts': [],
+ }
+ info['subfields'].append(subfield)
+ for itm in layout_detection_info:
+ layout = {
+ 'category': category_map[itm['category_id']],
+ 'pts': itm['poly'],
+ 'confidence': itm['score'],
+ }
+ info['subfields'][0]['layouts'].append(layout)
+
+ for subfield in info['subfields']:
+ sort_pts(subfield['layouts'])
+
+ new_subfields = []
+ for subfield in info['subfields']:
+ if subfield['category'] != '其他':
+ new_subfields.append(subfield)
+ else:
+ for layout in subfield['layouts']:
+ layout_subfield = {
+ 'category': layout['category'],
+ 'pts': layout['pts'],
+ 'confidence': layout['confidence'],
+ 'layouts': [layout],
+ }
+ new_subfields.append(layout_subfield)
+ sort_pts(new_subfields)
+ info['layouts'] = []
+ for subfield in new_subfields:
+ for layout in subfield['layouts']:
+ info['layouts'].append(layout)
+
+ return info
diff --git a/pix2text/doc_yolo_layout_parser.py b/pix2text/doc_yolo_layout_parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea7fcd725d381325d8fc72f911c645f9aef1334d
--- /dev/null
+++ b/pix2text/doc_yolo_layout_parser.py
@@ -0,0 +1,419 @@
+# coding: utf-8
+# use DocLayout-YOLO model for layout analysis: https://github.com/opendatalab/DocLayout-YOLO
+import json
+import os
+import logging
+import shutil
+from collections import defaultdict
+from copy import deepcopy, copy
+from pathlib import Path
+from typing import Union, Optional
+
+from PIL import Image
+import numpy as np
+import torch
+import torchvision
+
+from .consts import MODEL_VERSION
+from .layout_parser import ElementType
+from .utils import (
+ list2box,
+ clipbox,
+ box2list,
+ read_img,
+ save_layout_img,
+ data_dir,
+ select_device,
+ y_overlap,
+ prepare_model_files2,
+)
+from . import DocXLayoutParser
+
+from doclayout_yolo import YOLOv10
+
+logger = logging.getLogger(__name__)
+
+CURRENT_DIR = os.path.dirname(__file__)
+
+
+class DocYoloLayoutParser(object):
+ ignored_types = {"abandon", "table_footnote"}
+ # names: {0: 'title', 1: 'plain text', 2: 'abandon', 3: 'figure', 4: 'figure_caption', 5: 'table', 6: 'table_caption', 7: 'table_footnote', 8: 'isolate_formula', 9: 'formula_caption'}
+ type_mappings = {
+ "title": ElementType.TITLE,
+ "figure": ElementType.FIGURE,
+ "plain text": ElementType.TEXT,
+ "table": ElementType.TABLE,
+ "table_caption": ElementType.TEXT,
+ "figure_caption": ElementType.TEXT,
+ "isolate_formula": ElementType.FORMULA,
+ "inline formula": ElementType.FORMULA,
+ "formula_caption": ElementType.PLAIN_TEXT,
+ "ocr text": ElementType.TEXT,
+ }
+ # types that are isolated and usually don't cross different columns. They should not be merged with other elements
+ is_isolated = {"table_caption", "figure_caption", "isolate_formula"}
+
+ def __init__(
+ self,
+ device: str = None,
+ model_fp: Optional[str] = None,
+ root: Union[str, Path] = data_dir(),
+ **kwargs,
+ ):
+ if model_fp is None:
+ model_fp = self._prepare_model_files(root)
+ device = select_device(device)
+ # device = 'cpu' if device == 'mps' else device
+ self.device = device
+ self.mapping = {
+ 0: "title",
+ 1: "plain text",
+ 2: "abandon",
+ 3: "figure",
+ 4: "figure_caption",
+ 5: "table",
+ 6: "table_caption",
+ 7: "table_footnote",
+ 8: "isolate_formula",
+ 9: "formula_caption",
+ }
+ logger.info("Use DocLayout-YOLO model for Layout Analysis: {}".format(model_fp))
+ self.predictor = YOLOv10(model_fp)
+
+ def _prepare_model_files(self, root):
+ model_root_dir = Path(root).expanduser() / MODEL_VERSION
+ model_dir = model_root_dir / "layout-docyolo"
+ model_fp = model_dir / "doclayout_yolo_docstructbench_imgsz1024.pt"
+ if model_fp.exists():
+ return model_fp
+ model_fp = prepare_model_files2(
+ model_fp_or_dir=model_fp,
+ remote_repo="breezedeus/pix2text-layout-docyolo",
+ file_or_dir="file",
+ )
+ return model_fp
+
+ @classmethod
+ def from_config(cls, configs: Optional[dict] = None, device: str = None, **kwargs):
+ configs = copy(configs or {})
+ device = select_device(device)
+ model_fp = configs.pop("model_fp", None)
+ root = configs.pop("root", data_dir())
+ configs.pop("device", None)
+
+ return cls(device=device, model_fp=model_fp, root=root, **configs)
+
+ def parse(
+ self,
+ img: Union[str, Path, Image.Image],
+ table_as_image: bool = False,
+ *,
+ imgsz: int = 1024, # Prediction image size
+ conf: float = 0.2, # Confidence threshold
+ iou_threshold: float = 0.45, # NMS IoU threshold
+ **kwargs,
+ ):
+ """
+
+ Args:
+ img ():
+ table_as_image ():
+ imgsz (int): Prediction image size
+ conf (float): Confidence threshold
+ iou_threshold (float): NMS IoU threshold
+ **kwargs ():
+ * save_debug_res (str): if `save_debug_res` is set, the directory to save the debug results; default value is `None`, which means not to save
+ * expansion_margin (int): expansion margin
+
+ Returns:
+
+ """
+ if isinstance(img, Image.Image):
+ img0 = img.convert("RGB")
+ else:
+ img0 = read_img(img, return_type="Image")
+ img_width, img_height = img0.size
+ det_res = self.predictor.predict(
+ img0, # Image to predict
+ imgsz=imgsz, # Prediction image size
+ conf=conf, # Confidence threshold
+ )[0]
+ scores = det_res.__dict__["boxes"].conf
+ boxes = det_res.__dict__["boxes"].xyxy
+ _classes = det_res.__dict__["boxes"].cls
+
+ indices = torchvision.ops.nms(
+ boxes=torch.Tensor(boxes),
+ scores=torch.Tensor(scores),
+ iou_threshold=iou_threshold,
+ )
+ boxes, scores, _classes = boxes[indices], scores[indices], _classes[indices]
+ # dtype to int
+ _classes = _classes.int().tolist()
+
+ page_layout_result = []
+ for box, score, _cls in zip(boxes, scores, _classes):
+ page_layout_result.append(
+ {
+ "type": self.mapping[_cls],
+ "position": list2box(*box.tolist()),
+ "score": float(score),
+ }
+ )
+
+ ignored_layout_result = [
+ item for item in page_layout_result if item["type"] in self.ignored_types
+ ]
+ for x in ignored_layout_result:
+ x["col_number"] = -1
+ ignored_layout_out, _ = self._format_outputs(
+ img_width, img_height, ignored_layout_result, table_as_image
+ )
+ if page_layout_result:
+ # 目前 MFR 对带 tag 的公式识别效果不太好，所以暂时不合并
+ # page_layout_result = self._merge_isolated_formula_and_caption(page_layout_result)
+
+ # 去掉 ignored 类型
+ _page_layout_result = [
+ item
+ for item in page_layout_result
+ if item["type"] not in self.ignored_types
+ ]
+ layout_out = fetch_column_info(_page_layout_result, img_width, img_height)
+ layout_out, column_meta = self._format_outputs(
+ img_width, img_height, layout_out, table_as_image
+ )
+ else:
+ layout_out, column_meta = [], {}
+
+ debug_dir = None
+ if kwargs.get("save_debug_res", None):
+ debug_dir = Path(kwargs.get("save_debug_res"))
+ debug_dir.mkdir(exist_ok=True, parents=True)
+ if debug_dir is not None:
+ with open(debug_dir / "layout_out.json", "w", encoding="utf-8") as f:
+ json_out = deepcopy(layout_out)
+ for item in json_out:
+ item["position"] = item["position"].tolist()
+ item["type"] = item["type"].name
+ json.dump(
+ json_out,
+ f,
+ indent=2,
+ ensure_ascii=False,
+ )
+ # layout_out = DocXLayoutParser._merge_overlapped_boxes(layout_out)
+
+ expansion_margin = kwargs.get("expansion_margin", 8)
+ layout_out = DocXLayoutParser._expand_boxes(
+ layout_out, expansion_margin, height=img_height, width=img_width
+ )
+
+ save_layout_fp = kwargs.get(
+ "save_layout_res",
+ debug_dir / "layout_res.jpg" if debug_dir is not None else None,
+ )
+
+ layout_out.extend(ignored_layout_out)
+
+ if save_layout_fp:
+ element_type_list = [t for t in ElementType]
+ save_layout_img(
+ img0,
+ element_type_list,
+ layout_out,
+ save_path=save_layout_fp,
+ key="position",
+ )
+
+ return layout_out, column_meta
+
+ def _merge_isolated_formula_and_caption(self, page_layout_result):
+ # 合并孤立的公式和公式标题
+ # 对于每个公式标题，找到与它在同一行且在其左侧距离最近的孤立公式，并把它们合并
+ isolated_formula = [
+ item for item in page_layout_result if item["type"] == "isolate_formula"
+ ]
+ formula_caption = [
+ item for item in page_layout_result if item["type"] == "formula_caption"
+ ]
+ remaining_elements = [
+ item
+ for item in page_layout_result
+ if item["type"] not in ["isolate_formula", "formula_caption"]
+ ]
+ for caption in formula_caption:
+ caption_xmin, caption_ymin, caption_xmax, caption_ymax = box2list(
+ caption["position"]
+ )
+ min_dist = float("inf")
+ nearest_formula = None
+ for formula in isolated_formula:
+ formula_xmin, formula_ymin, formula_xmax, formula_ymax = box2list(
+ formula["position"]
+ )
+ if y_overlap(caption, formula, key="position") >= 0.7:
+ dist = caption_xmin - formula_xmax
+ if 0 <= dist < min_dist:
+ min_dist = dist
+ nearest_formula = formula
+ if nearest_formula is not None:
+ new_formula = deepcopy(nearest_formula)
+ formula_xmin, formula_ymin, formula_xmax, formula_ymax = box2list(
+ new_formula["position"]
+ )
+ new_formula["position"] = list2box(
+ min(caption_xmin, formula_xmin),
+ min(caption_ymin, formula_ymin),
+ max(caption_xmax, formula_xmax),
+ max(caption_ymax, formula_ymax),
+ )
+ remaining_elements.append(new_formula)
+ isolated_formula.remove(nearest_formula)
+ else: # not found
+ remaining_elements.append(caption)
+ return remaining_elements + isolated_formula
+
+ def _format_outputs(self, width, height, layout_out, table_as_image: bool):
+ # 获取每一列的信息
+ column_numbers = set([item["col_number"] for item in layout_out])
+ column_meta = defaultdict(dict)
+ for col_idx in column_numbers:
+ cur_col_res = [item for item in layout_out if item["col_number"] == col_idx]
+ mean_score = np.mean([item["score"] for item in cur_col_res])
+ xmin, ymin, xmax, ymax = box2list(cur_col_res[0]["position"])
+ for item in cur_col_res[1:]:
+ cur_xmin, cur_ymin, cur_xmax, cur_ymax = box2list(item["position"])
+ xmin = min(xmin, cur_xmin)
+ ymin = min(ymin, cur_ymin)
+ xmax = max(xmax, cur_xmax)
+ ymax = max(ymax, cur_ymax)
+ column_meta[col_idx]["position"] = clipbox(
+ list2box(xmin, ymin, xmax, ymax), height, width
+ )
+ column_meta[col_idx]["score"] = mean_score
+
+ final_out = []
+ for box_info in layout_out:
+ image_type = box_info["type"]
+ isolated = image_type in self.is_isolated
+ if image_type in self.ignored_types:
+ image_type = ElementType.IGNORED
+ else:
+ image_type = self.type_mappings.get(image_type, ElementType.UNKNOWN)
+ if table_as_image and image_type == ElementType.TABLE:
+ image_type = ElementType.FIGURE
+ final_out.append(
+ {
+ "type": image_type,
+ "position": clipbox(box_info["position"], height, width),
+ "score": box_info["score"],
+ "col_number": box_info["col_number"],
+ "isolated": isolated,
+ }
+ )
+
+ return final_out, column_meta
+
+
+def cal_column_width(layout_res, img_width, img_height):
+ widths = [item["position"][1][0] - item["position"][0][0] for item in layout_res]
+ if len(widths) <= 2:
+ return min(widths + [img_width])
+
+ # 计算所有box的宽度和相对面积
+ boxes_info = []
+ for item in layout_res:
+ x0, y0 = item["position"][0]
+ x1, y1 = item["position"][2]
+ width = x1 - x0
+ height = y1 - y0
+ area = width * height
+ boxes_info.append({"width": width, "area": area, "y0": y0, "height": height})
+
+ # 按面积排序，获取最大的几个box
+ boxes_info.sort(key=lambda x: x["area"], reverse=True)
+
+ # 使用面积权重计算加权平均宽度
+ total_weight = 0
+ weighted_width_sum = 0
+
+ # 只考虑面积最大的前30%的boxes
+ top_boxes = boxes_info[: max(2, int(len(boxes_info) * 0.3))]
+
+ for box in top_boxes:
+ # 使用面积作为权重
+ weight = box["area"]
+ # 给予页面下半部分的box更高权重（因为通常是正文区域）
+ if box["y0"] > img_height * 0.5:
+ weight *= 1.5
+ weighted_width_sum += box["width"] * weight
+ total_weight += weight
+
+ estimated_width = (
+ weighted_width_sum / total_weight if total_weight > 0 else img_width
+ )
+
+ # 设置合理的界限
+ min_width = img_width * 0.3 # 列宽不应该太窄
+ max_width = img_width * 0.95 # 留一些页边距
+
+ return min(max(estimated_width, min_width), max_width)
+
+
+def locate_full_column(layout_res, col_width, img_width):
+ # 找出跨列的模块
+ for item in layout_res:
+ cur_width = item["position"][1][0] - item["position"][0][0]
+ if cur_width > col_width * 1.5 or cur_width > img_width * 0.7:
+ item["category"] = "full column"
+ item["col_number"] = 0
+ else:
+ item["category"] = "sub column"
+ item["col_number"] = -1
+ return layout_res
+
+
+def fetch_column_info(layout_res, img_width, img_height):
+ # 获取所有模块的横坐标范围
+ layout_res.sort(key=lambda x: x["position"][0][0])
+
+ col_width = cal_column_width(layout_res, img_width, img_height)
+ layout_res = locate_full_column(layout_res, col_width, img_width)
+ col_width = max(
+ [
+ item["position"][1][0] - item["position"][0][0]
+ for item in layout_res
+ if item["category"] == "sub column"
+ ],
+ default=col_width,
+ )
+
+ # 分配模块到列中
+ col_left = img_width
+ cur_col = 1
+ for idx, info in enumerate(layout_res):
+ if info["category"] == "full column":
+ continue
+ xmin, xmax = info["position"][0][0], info["position"][1][0]
+ if col_left == img_width:
+ col_left = xmin
+ if xmin < col_left + col_width * 0.99 and xmax <= xmin + col_width * 1.02:
+ info["col_number"] = cur_col
+ col_left = min(col_left, xmin)
+ else:
+ cur_col += 1
+ col_left = xmin
+ info["col_number"] = cur_col
+ logger.debug(f"Column number: {cur_col}, with column width: {col_width}")
+
+ if cur_col == 1:
+ # 只有一列，直接返回
+ for item in layout_res:
+ item["col_number"] = 1
+
+ layout_res.sort(
+ key=lambda x: (x["col_number"], x["position"][0][1], x["position"][0][0])
+ )
+ return layout_res
diff --git a/pix2text/formula_detector.py b/pix2text/formula_detector.py
new file mode 100644
index 0000000000000000000000000000000000000000..13140fa37d0aed1962d9ece3ed4d85abbd828123
--- /dev/null
+++ b/pix2text/formula_detector.py
@@ -0,0 +1,82 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+from typing import Optional, Union, Tuple
+from pathlib import Path
+import logging
+
+from cnstd.yolo_detector import YoloDetector
+
+from .consts import AVAILABLE_MODELS
+from .utils import data_dir, prepare_model_files
+
+logger = logging.getLogger(__name__)
+
+
+BACKEND_TO_EXTENSION_MAPPING = {
+ 'pytorch': 'pt',
+ 'onnx': 'onnx',
+ 'coreml': 'mlpackage',
+ 'torchscript': 'torchscript',
+}
+
+
+class MathFormulaDetector(YoloDetector):
+ def __init__(
+ self,
+ *,
+ model_name: str = 'mfd-1.5',
+ model_backend: str = 'onnx',
+ device: Optional[str] = None,
+ model_path: Optional[Union[str, Path]] = None,
+ root: Union[str, Path] = data_dir(),
+ static_resized_shape: Optional[Union[int, Tuple[int, int]]] = None,
+ **kwargs,
+ ):
+ """
+ Math Formula Detector based on YOLO.
+
+ Args:
+ model_name (str): model name, default is 'mfd-1.5'.
+ model_backend (str): model backend, default is 'onnx'.
+ device (optional str): device to use, default is None.
+ model_path (optional str): model path, default is None.
+ root (optional str): root directory to save model files, default is data_dir().
+ static_resized_shape (optional int or tuple): static resized shape, default is None.
+ When it is not None, the input image will be resized to this shape before detection,
+ ignoring the input parameter `resized_shape` if .detect() is called.
+ Some format of models may require a fixed input size, such as CoreML.
+ **kwargs (): other parameters.
+ """
+ if model_path is None:
+ model_info = AVAILABLE_MODELS.get_info(model_name, model_backend)
+ model_path = prepare_model_files(root, model_info)
+ extension = BACKEND_TO_EXTENSION_MAPPING.get(model_backend, model_backend)
+ cand_paths = find_files(model_path, f'.{extension}')
+ if not cand_paths:
+ raise FileNotFoundError(f'can not find available file in {model_path}')
+ model_path = cand_paths[0]
+ logger.info(f'Use model path for MFD: {model_path}')
+
+ super().__init__(
+ model_path=model_path,
+ device=device,
+ static_resized_shape=static_resized_shape,
+ **kwargs,
+ )
+
+
+def find_files(directory, extension):
+ # 创建Path对象
+ dir_path = Path(directory)
+
+ pattern = f"*mfd*{extension}"
+
+ outs = []
+ # 使用rglob方法递归查找匹配的文件
+ for file_path in dir_path.rglob(pattern):
+ # 检查文件名是否不以点开头（除了文件扩展名）
+ if not file_path.name.startswith('.') or file_path.suffix == extension:
+ outs.append(file_path)
+
+ return outs
diff --git a/pix2text/latex_ocr.py b/pix2text/latex_ocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f77f1a7a0703f4ce6abd1515310d0e83f5e7e15
--- /dev/null
+++ b/pix2text/latex_ocr.py
@@ -0,0 +1,447 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+import os
+import shutil
+import string
+from typing import Optional, Union, List, Dict, Any
+import logging
+from pathlib import Path
+import re
+
+import torch
+import tqdm
+from optimum.onnxruntime import ORTModelForVision2Seq
+from transformers import (
+ TrOCRProcessor,
+ VisionEncoderDecoderModel,
+)
+
+from PIL import Image
+from cnocr.utils import get_default_ort_providers
+from transformers.generation import (
+ GenerateEncoderDecoderOutput,
+ GenerateBeamEncoderDecoderOutput,
+)
+
+from .consts import MODEL_VERSION, AVAILABLE_MODELS
+from .utils import data_dir, select_device, prepare_imgs, prepare_model_files2
+
+logger = logging.getLogger(__name__)
+
+
+class LatexOCR(object):
+ """Get a prediction of a math formula image in the easiest way"""
+
+ def __init__(
+ self,
+ *,
+ model_name: str = 'mfr-1.5',
+ model_backend: str = 'onnx',
+ device: str = None,
+ context: str = None, # deprecated, use `device` instead
+ model_dir: Optional[Union[str, Path]] = None,
+ root: Union[str, Path] = data_dir(),
+ more_processor_configs: Optional[Dict[str, Any]] = None,
+ more_model_configs: Optional[Dict[str, Any]] = None,
+ **kwargs,
+ ):
+ """Initialize a LatexOCR model.
+
+ Args:
+ model_name (str, optional): The name of the model. Defaults to 'mfr-1.5'.
+ model_backend (str, optional): The model backend, either 'onnx' or 'pytorch'. Defaults to 'onnx'.
+ device (str, optional): What device to use for computation, supports `['cpu', 'cuda', 'gpu']`; defaults to None, which selects the device automatically.
+ context (str, optional): Deprecated, use `device` instead. What device to use for computation, supports `['cpu', 'cuda', 'gpu']`; defaults to None, which selects the device automatically.
+ model_dir (Optional[Union[str, Path]], optional): The model file directory. Defaults to None.
+ root (Union[str, Path], optional): The model root directory. Defaults to data_dir().
+ more_processor_configs (Optional[Dict[str, Any]], optional): Additional processor configurations. Defaults to None.
+ more_model_configs (Optional[Dict[str, Any]], optional): Additional model configurations. Defaults to None.
+
+ - provider (`str`, defaults to `None`, which means to select one provider automatically):
+ ONNX Runtime provider to use for loading the model. See https://onnxruntime.ai/docs/execution-providers/ for
+ possible providers.
+ - session_options (`Optional[onnxruntime.SessionOptions]`, defaults to `None`),:
+ ONNX Runtime session options to use for loading the model.
+ - provider_options (`Optional[Dict[str, Any]]`, defaults to `None`):
+ Provider option dictionaries corresponding to the provider used. See available options
+ for each provider: https://onnxruntime.ai/docs/api/c/group___global.html .
+ - ...: see more information here: optimum.onnxruntime.modeling_ort.ORTModel.from_pretrained()
+ **kwargs: Additional arguments, currently not used.
+ """
+
+ if context is not None:
+ logger.warning(f'`context` is deprecated, please use `device` instead')
+ if device is None and context is not None:
+ device = context
+ self.device = select_device(device)
+
+ model_info = AVAILABLE_MODELS.get_info(model_name, model_backend)
+
+ if model_dir is None:
+ model_dir = self._prepare_model_files(root, model_backend, model_info)
+ logger.info(f'Use model dir for LatexOCR: {model_dir}')
+
+ more_model_configs = more_model_configs or {}
+ if model_backend == 'onnx' and 'provider' not in more_model_configs:
+ available_providers = get_default_ort_providers()
+ if not available_providers:
+ raise RuntimeError(
+ 'No available providers for ONNX Runtime, please install onnxruntime-gpu or onnxruntime.'
+ )
+ more_model_configs['provider'] = available_providers[0]
+ self.model, self.processor = self._init_model(
+ model_backend,
+ model_dir,
+ more_processor_config=more_processor_configs,
+ more_model_config=more_model_configs,
+ )
+ logger.info(
+ f'Loaded Pix2Text MFR model {model_name} to: backend-{model_backend}, device-{self.device}'
+ )
+
+ def _prepare_model_files(self, root, model_backend, model_info):
+ model_root_dir = Path(root) / MODEL_VERSION
+ model_dir = model_root_dir / model_info['local_model_id']
+ if model_dir.is_dir() and list(model_dir.glob('**/[!.]*')):
+ return str(model_dir)
+ assert 'hf_model_id' in model_info
+ model_dir = prepare_model_files2(
+ model_fp_or_dir=model_dir,
+ remote_repo=model_info["hf_model_id"],
+ file_or_dir="dir",
+ )
+ return model_dir
+
+ def _init_model(
+ self,
+ model_backend,
+ model_dir,
+ more_processor_config=None,
+ more_model_config=None,
+ ):
+ more_processor_config = more_processor_config or {}
+ more_model_config = more_model_config or {}
+ processor = TrOCRProcessor.from_pretrained(model_dir, **more_processor_config)
+ if model_backend == 'pytorch':
+ model = VisionEncoderDecoderModel.from_pretrained(
+ model_dir, **more_model_config
+ )
+ model.to(self.device)
+ model.eval()
+ else:
+ if 'use_cache' not in more_model_config:
+ more_model_config['use_cache'] = False
+ if (
+ 'provider' in more_model_config
+ and more_model_config['provider'] == 'CUDAExecutionProvider'
+ ):
+ more_model_config["use_io_binding"] = more_model_config['use_cache']
+ model = ORTModelForVision2Seq.from_pretrained(
+ model_dir, **more_model_config
+ )
+ model.to(self.device)
+ return model, processor
+
+ def __call__(self, *args, **kwargs) -> Union[str, List[str]]:
+ return self.recognize(*args, **kwargs)
+
+ def recognize(
+ self,
+ imgs: Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]],
+ batch_size: int = 1,
+ use_post_process: bool = True,
+ rec_config: Optional[dict] = None,
+ **kwargs,
+ ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+ """
+ Recognize Math Formula images to LaTeX Expressions
+ Args:
+ imgs (Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]): The image or list of images
+ batch_size (int): The batch size
+ use_post_process (bool): Whether to use post process. Defaults to True
+ rec_config (Optional[dict]): The generation config
+ **kwargs (): Other arguments. Not used for now
+
+ Returns: The LaTeX Result or list of LaTeX Results; each result is a dict with `text` and `score` fields.
+
+ """
+ is_single_image = False
+ if isinstance(imgs, (str, Path, Image.Image)):
+ imgs = [imgs]
+ is_single_image = True
+
+ input_imgs = prepare_imgs(imgs)
+
+ # inference batch by batch
+ results = []
+ for i in tqdm.tqdm(range(0, len(input_imgs), batch_size)):
+ part_imgs = input_imgs[i : i + batch_size]
+ results.extend(self._one_batch(part_imgs, rec_config, **kwargs))
+
+ if use_post_process:
+ for info in results:
+ info['text'] = self.post_process(info['text'])
+
+ if is_single_image:
+ return results[0]
+ return results
+
+ def _one_batch(self, img_list, rec_config, **kwargs):
+ rec_config = rec_config or {}
+ pixel_values = self.processor(images=img_list, return_tensors="pt").pixel_values
+ outs = self.model.generate(
+ pixel_values.to(self.device),
+ return_dict_in_generate=True,
+ output_scores=True,
+ **rec_config,
+ )
+ mean_probs = self._cal_scores(outs)
+
+ generated_text = self.processor.batch_decode(
+ outs.sequences, skip_special_tokens=True
+ )
+ assert len(img_list) == len(generated_text) == len(mean_probs)
+
+ final_out = []
+ for text, prob in zip(generated_text, mean_probs):
+ final_out.append({'text': text, 'score': prob})
+ return final_out
+
+ def _cal_scores(self, outs):
+ if isinstance(outs, GenerateBeamEncoderDecoderOutput):
+ mean_probs = outs.sequences_scores.exp().tolist()
+ elif isinstance(outs, GenerateEncoderDecoderOutput):
+ logits = torch.stack(outs.scores, dim=1)
+ scores = torch.softmax(logits, dim=-1).max(dim=2).values
+
+ mean_probs = []
+ for idx, example in enumerate(scores):
+ cur_length = int(
+ (outs.sequences[idx] != self.processor.tokenizer.pad_token_id).sum()
+ )
+ assert cur_length > 1
+ # 获得几何平均值。注意：example中的第一个元素对应sequence中的第二个元素
+ mean_probs.append(
+ float((example[: cur_length - 1] + 1e-8).log().mean().exp())
+ )
+ else:
+ raise Exception(f'unprocessed output type: {type(outs)}')
+
+ return mean_probs
+
+ def post_process(self, text):
+ text = remove_redundant_script(text)
+ text = remove_trailing_whitespace(text)
+ text = replace_illegal_symbols(text)
+ for _ in range(10):
+ new_text = remove_empty_text(text)
+ if new_text == text:
+ break
+ text = new_text
+
+ text = fix_latex(text)
+ text = remove_unnecessary_spaces(text)
+ return text.strip()
+
+
+def remove_redundant_script(text):
+ # change '^ { abc }' to 'abc'
+ pattern = r'^\^\s*{\s*(.*?)\s*}'
+ result = re.sub(pattern, r'\1', text)
+ # change '_ { abc }' to 'abc'
+ pattern = r'^_\s*{\s*(.*?)\s*}'
+ result = re.sub(pattern, r'\1', result)
+ return result.strip()
+
+
+def replace_illegal_symbols(text):
+ illegal_to_legals = [
+ (r'\\\.', r'\\ .'), # \. -> \ .
+ (r'\\=', r'\\ ='), # \= -> \ =
+ (r'\\-', r'\\ -'), # \- -> \ -
+ (r'\\~', r'\\ ~'), # \~ -> \ ~
+ ]
+ for illegal, legal in illegal_to_legals:
+ text = re.sub(illegal, legal, text)
+ return text
+
+
+def remove_empty_text(latex_expression):
+ # change 'abc ^' to 'abc'
+ patterns = [
+ r'\\hat\s*{\s*}', # 匹配 \hat{}
+ r'\^\s*{\s*}', # 匹配 ^{}
+ r'_\s*{\s*}', # 匹配 _{}
+ r'\\text\s*{\s*}', # 匹配 \text{}
+ r'\\tilde\s*{\s*}', # 匹配 \tilde{}
+ r'\\bar\s*{\s*}', # 匹配 \bar{}
+ r'\\vec\s*{\s*}', # 匹配 \vec{}
+ r'\\acute\s*{\s*}', # 匹配 \acute{}
+ r'\\grave\s*{\s*}', # 匹配 \grave{}
+ r'\\breve\s*{\s*}', # 匹配 \breve{}
+ r'\\overline\s*{\s*}', # 匹配 \overline{}
+ r'\\dot\s*{\s*}', # 匹配 \dot{}
+ r'\\ddot\s*{\s*}', # 匹配 \ddot{}
+ r'\\widehat\s*{\s*}', # 匹配 \widehat{}
+ r'\\widetilde\s*{\s*}', # 匹配 \widetilde{}
+ ]
+
+ # 使用 sub 函数进行替换
+ for pattern in patterns:
+ latex_expression = re.sub(pattern, '', latex_expression)
+ return latex_expression.strip()
+
+
+latex_whitespace_symbols = [
+ r'\\ +', # 空格
+ r'\\quad\s*', # 1em 宽度的空白
+ r'\\qquad\s*', # 2em 宽度的空白
+ r'\\,\s*', # 窄空格
+ r'\\:\s*', # 中等空格
+ r'\\;\s*', # 大空格
+ r'\\enspace\s*', # 1em 空白
+ r'\\thinspace\s*', # 1/6em 空白
+ r'\\!\s*', # 感叹号
+]
+
+
+def remove_trailing_whitespace(latex_str):
+ # 定义匹配末尾空白符号的正则表达式模式
+ trailing_whitespace_pattern = r'(?:' + '|'.join(latex_whitespace_symbols) + r')+$'
+
+ # 使用 sub 函数进行替换
+ return re.sub(trailing_whitespace_pattern, '', latex_str).strip()
+
+
+def remove_unnecessary_spaces(latex_str):
+ # Preserve space between a command and a following uppercase letter
+ latex_str = re.sub(r'\\([a-zA-Z]+) (?=[a-zA-Z])', r'\\\1 ', latex_str)
+
+ # Remove spaces after commands not followed by an uppercase letter, carefully not affecting commands that require space
+ latex_str = re.sub(r'\\([a-zA-Z]+)\s+(?![a-zA-Z])', r'\\\1', latex_str)
+
+ # Remove spaces around curly braces, preserving internal spaces
+ latex_str = re.sub(r'(\{)\s+', r'\1', latex_str)
+ latex_str = re.sub(r'\s+(\})', r'\1', latex_str)
+
+ # Specifically target and remove spaces around mathematical operators, including +, -, =, and similar operators
+ latex_str = re.sub(r'(?<=[^\\])\s*([+\-=])\s*', r'\1', latex_str)
+
+ # Remove spaces around "^" and "_" for subscripts and superscripts
+ latex_str = re.sub(r'\s*(\^|\_)\s*', r'\1', latex_str)
+
+ return latex_str
+
+
+def find_all_left_or_right(latex, left_or_right='left'):
+ left_bracket_infos = []
+ prefix_len = len(left_or_right) + 1
+ # 匹配出latex中所有的 '\left' 后面跟着的第一个非空格字符，定位它们所在的位置
+ for m in re.finditer(rf'\\{left_or_right}\s*\S', latex):
+ start, end = m.span()
+ if latex[end - 1] in string.ascii_letters:
+ continue
+ # 如果最后一个字符为 "\"，则往前继续匹配，直到匹配到一个非字母的字符
+ # 如 "\left \big("
+ while latex[end - 1] in ('\\', ' '):
+ end += 1
+ while end < len(latex) and latex[end].isalpha():
+ end += 1
+ ori_str = latex[start + prefix_len : end].strip()
+ # FIXME: ori_str中可能出现多个 '\left'，此时需要分隔开
+
+ left_bracket_infos.append({'str': ori_str, 'start': start, 'end': end})
+ left_bracket_infos.sort(key=lambda x: x['start'])
+ return left_bracket_infos
+
+
+def match_left_right(left_str, right_str):
+ """匹配左右括号，如匹配 `\left(` 和 `\right)`。"""
+ left_str = left_str.strip().replace(' ', '')[len('left') + 1 :]
+ right_str = right_str.strip().replace(' ', '')[len('right') + 1 :]
+ # 去掉开头的相同部分
+ while left_str and right_str and left_str[0] == right_str[0]:
+ left_str = left_str[1:]
+ right_str = right_str[1:]
+
+ match_pairs = [
+ ('', ''),
+ ('(', ')'),
+ ('\{', '.'), # 大括号那种
+ ('⟮', '⟯'),
+ ('[', ']'),
+ ('⟨', '⟩'),
+ ('{', '}'),
+ ('⌈', '⌉'),
+ ('┌', '┐'),
+ ('⌊', '⌋'),
+ ('└', '┘'),
+ ('⎰', '⎱'),
+ ('lt', 'gt'),
+ ('lang', 'rang'),
+ (r'langle', r'rangle'),
+ (r'lbrace', r'rbrace'),
+ ('lBrace', 'rBrace'),
+ (r'lbracket', r'rbracket'),
+ (r'lceil', r'rceil'),
+ ('lcorner', 'rcorner'),
+ (r'lfloor', r'rfloor'),
+ (r'lgroup', r'rgroup'),
+ (r'lmoustache', r'rmoustache'),
+ (r'lparen', r'rparen'),
+ (r'lvert', r'rvert'),
+ (r'lVert', r'rVert'),
+ ]
+ return (left_str, right_str) in match_pairs
+
+
+def fix_latex(latex: str) -> str:
+ """对识别结果做进一步处理和修正。"""
+ # # 把latex中的中文括号全部替换成英文括号
+ # latex = latex.replace('（', '(').replace('）', ')')
+ # # 把latex中的中文逗号全部替换成英文逗号
+ # latex = latex.replace('，', ',')
+
+ left_bracket_infos = find_all_left_or_right(latex, left_or_right='left')
+ right_bracket_infos = find_all_left_or_right(latex, left_or_right='right')
+ # left 和 right 找配对，left找位置比它靠前且最靠近他的right配对
+ for left_bracket_info in left_bracket_infos:
+ for right_bracket_info in right_bracket_infos:
+ if (
+ not right_bracket_info.get('matched', False)
+ and right_bracket_info['start'] > left_bracket_info['start']
+ and match_left_right(
+ right_bracket_info['str'], left_bracket_info['str']
+ )
+ ):
+ left_bracket_info['matched'] = True
+ right_bracket_info['matched'] = True
+ break
+
+ for left_bracket_info in left_bracket_infos:
+ # 把没有匹配的 '\left'替换为等长度的空格
+ left_len = len('left') + 1
+ if not left_bracket_info.get('matched', False):
+ start_idx = left_bracket_info['start']
+ end_idx = start_idx + left_len
+ latex = (
+ latex[: left_bracket_info['start']]
+ + ' ' * (end_idx - start_idx)
+ + latex[end_idx:]
+ )
+ for right_bracket_info in right_bracket_infos:
+ # 把没有匹配的 '\right'替换为等长度的空格
+ right_len = len('right') + 1
+ if not right_bracket_info.get('matched', False):
+ start_idx = right_bracket_info['start']
+ end_idx = start_idx + right_len
+ latex = (
+ latex[: right_bracket_info['start']]
+ + ' ' * (end_idx - start_idx)
+ + latex[end_idx:]
+ )
+
+ # 把 latex 中的连续空格替换为一个空格
+ latex = re.sub(r'\s+', ' ', latex)
+ return latex.strip()
diff --git a/pix2text/layout_parser.py b/pix2text/layout_parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b48f0b88da8d4b024e69e8dd9fbbe78a0ef0d76
--- /dev/null
+++ b/pix2text/layout_parser.py
@@ -0,0 +1,130 @@
+# coding: utf-8
+from enum import Enum
+from pathlib import Path
+from typing import Union, Optional, List, Dict, Any
+
+from PIL import Image
+from cnstd import LayoutAnalyzer
+from cnstd.yolov7.consts import CATEGORY_DICT
+
+from .utils import read_img, save_layout_img, select_device
+
+
+class ElementType(Enum):
+ ABANDONED = -2 # 可以指定有些区域不做识别，如 Image 与 Image caption 中间地带
+ IGNORED = -1
+ UNKNOWN = 0
+ TEXT = 1
+ TITLE = 2
+ FIGURE = 3
+ TABLE = 4
+ FORMULA = 5
+ PLAIN_TEXT = 11 # 与 TEXT 类似，但是绝对不包含公式
+
+ def __repr__(self) -> str:
+ return self.name
+
+ def __str__(self) -> str:
+ return self.name
+
+class LayoutParser(object):
+ def __init__(
+ self,
+ model_type: str = 'yolov7_tiny', # 当前仅支持 `yolov7_tiny`
+ model_backend: str = 'pytorch', # 当前仅支持 `pytorch`
+ device: str = None,
+ **kwargs
+ ):
+ device = select_device(device)
+ device = device if device != 'mps' else 'cpu'
+ self.layout_model = LayoutAnalyzer(
+ model_name='layout',
+ model_type=model_type,
+ model_backend=model_backend,
+ device=device,
+ **kwargs,
+ )
+ self.ignored_types = {'_background_', 'Footer', 'Reference'}
+ self.type_mappings = {
+ 'Header': ElementType.TEXT,
+ 'Text': ElementType.TEXT,
+ 'Title': ElementType.TITLE,
+ 'Figure': ElementType.FIGURE,
+ 'Figure caption': ElementType.TEXT,
+ 'Table': ElementType.TABLE,
+ 'Table caption': ElementType.TEXT,
+ 'Reference': ElementType.TEXT,
+ 'Equation': ElementType.FORMULA,
+ }
+
+ @classmethod
+ def from_config(cls, configs: Optional[dict] = None, device: str = None, **kwargs):
+ configs = configs or {}
+ device = select_device(device)
+ configs['device'] = device if device != 'mps' else 'cpu'
+
+ return cls(
+ model_type=configs.get('model_type', 'yolov7_tiny'),
+ model_backend=configs.get('model_backend', 'pytorch'),
+ device=device,
+ **kwargs,
+ )
+
+ def __call__(self, *args, **kwargs):
+ return self.parse(*args, **kwargs)
+
+ def parse(
+ self,
+ img: Union[str, Path, Image.Image],
+ resized_shape: int = 608,
+ table_as_image: bool = False,
+ **kwargs
+ ) -> (List[Dict[str, Any]], Dict[str, Any]):
+ """
+
+ Args:
+ img ():
+ resized_shape ():
+ table_as_image ():
+ **kwargs ():
+
+ Returns: parsed results & column meta information;
+ the parsed results is a list of dict with keys: 'type', 'position', 'score':
+ * type: ElementType
+ * position: np.ndarray, with shape of (4, 2)
+ * score: float
+ the column meta is a dict, with column number as its keys.
+
+ """
+ if isinstance(img, Image.Image):
+ img0 = img.convert('RGB')
+ else:
+ img0 = read_img(img, return_type='Image')
+ layout_out = self.layout_model(img0.copy(), resized_shape=resized_shape)
+
+ if kwargs.get('save_layout_res'):
+ save_layout_img(
+ img0,
+ CATEGORY_DICT['layout'],
+ layout_out,
+ kwargs.get('save_layout_res'),
+ key='box',
+ )
+
+ final_out = []
+ for box_info in layout_out:
+ image_type = box_info['type']
+ if image_type in self.ignored_types:
+ continue
+ image_type = self.type_mappings.get(image_type, image_type)
+ if table_as_image and image_type == ElementType.TABLE:
+ image_type = ElementType.FIGURE
+ final_out.append(
+ {
+ 'type': image_type,
+ 'position': box_info['box'],
+ 'score': box_info['score'],
+ }
+ )
+
+ return final_out, {}
diff --git a/pix2text/ocr_engine.py b/pix2text/ocr_engine.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbdb27e0b3c30ad8a0822b1b9a532d5f3d2dd46b
--- /dev/null
+++ b/pix2text/ocr_engine.py
@@ -0,0 +1,204 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+import string
+from typing import Sequence, List, Optional
+
+import numpy as np
+import cv2
+
+from .utils import custom_deepcopy
+
+
+def clip(x, min_value, max_value):
+ return min(max(x, min_value), max_value)
+
+
+class TextOcrEngine:
+ """Text OCR Engine Wrapper"""
+
+ name = 'unknown'
+
+ def __init__(self, languages: Sequence[str], ocr_engine):
+ self.languages = languages
+ self.ocr_engine = ocr_engine
+
+ def detect_only(self, img: np.ndarray, **kwargs):
+ """
+ Only detect the texts from the input image.
+ Args:
+ img (np.ndarray): RGB image with shape: (height, width, 3)
+ kwargs: more configs
+
+ Returns:
+ Dict[str, List[dict]]: The dictionary contains the following keys:
+ * 'detected_texts': list, each element stores the information of a detected box, recorded in a dictionary, including the following values:
+ 'position': The rectangular box corresponding to the detected text; np.ndarray, shape: (4, 2), representing the coordinates (x, y) of the 4 points of the box;
+
+ Example:
+ {'detected_texts':
+ [{'position': array([[416, 77],
+ [486, 13],
+ [800, 325],
+ [730, 390]], dtype=int32),
+ },
+ ...
+ ]
+ }
+ """
+ pass
+
+ def recognize_only(self, img: np.ndarray, **kwargs):
+ """
+ Only recognize the texts for cropped images, which are from bboxes detected by detect_only.
+ Args:
+ img (): RGB image with shape [height, width] or [height, width, channel].
+ channel should be 1 (gray image) or 3 (RGB formatted color image). scaled in [0, 255];
+ kwargs: more configs
+
+ Returns:
+ dict, with keys:
+ - 'text' (str): The recognized text
+ - 'score' (float): The score of the recognition result (confidence level), ranging from `[0, 1]`; the higher the score, the more reliable it is
+
+ Example:
+ ```
+ {'score': 0.8812797665596008,
+ 'text': 'Current Line'}
+ ```
+ """
+ pass
+
+ def ocr(self, img: np.ndarray, rec_config: Optional[dict] = None, **kwargs):
+ """
+ Detect texts first, and then recognize the texts for detected bbox patches.
+ Args:
+ img (np.ndarray): RGB image with shape [height, width] or [height, width, channel].
+ channel should be 1 (gray image) or 3 (RGB formatted color image). scaled in [0, 255];
+ rec_config (Optional[dict]): The config for recognition
+ kwargs: more configs
+
+ Returns:
+ list of detected texts, which element is a dict, with keys:
+ - 'text' (str): The recognized text
+ - 'score' (float): The score of the recognition result (confidence level), ranging from `[0, 1]`; the higher the score, the more reliable it is
+ - 'position' (np.ndarray): 4 x 2 array, representing the coordinates (x, y) of the 4 points of the box
+
+ Example:
+ ```
+ [{'score': 0.88,
+ 'text': 'Line 1',
+ 'position': array([[146, 22],
+ [179, 22],
+ [179, 60],
+ [146, 60]], dtype=int32)
+ },
+ {'score': 0.78,
+ 'text': 'Line 2'
+ 'position': array([[641, 115],
+ [1180, 115],
+ [1180, 244],
+ [641, 244]], dtype=int32)
+ }]
+ ```
+ """
+
+ pass
+
+
+class CnOCREngine(TextOcrEngine):
+ name = 'cnocr'
+
+ def detect_only(self, img: np.ndarray, **kwargs):
+ outs = self.ocr_engine.det_model.detect(img, **kwargs)
+ for out in outs['detected_texts']:
+ out['position'] = out.pop('box')
+ return outs
+
+ def recognize_only(self, img: np.ndarray, **kwargs):
+ try:
+ return self.ocr_engine.ocr_for_single_line(img)
+ except:
+ return {'text': '', 'score': 0.0}
+
+ def ocr(self, img: np.ndarray, rec_config: Optional[dict] = None, **kwargs) -> str:
+ rec_config = rec_config or {}
+ outs = self.ocr_engine.ocr(img, **rec_config)
+ return outs
+
+
+class EasyOCREngine(TextOcrEngine):
+ name = 'easyocr'
+
+ def detect_only(self, img: np.ndarray, **kwargs):
+ if 'resized_shape' in kwargs:
+ kwargs.pop('resized_shape')
+ img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+ height, width = img.shape[:2]
+ horizontal_list, free_list = self.ocr_engine.detect(img, **kwargs)
+ horizontal_list, free_list = horizontal_list[0], free_list[0]
+ bboxes = []
+ for x1x2_y1y2 in horizontal_list:
+ xmin, xmax, ymin, ymax = x1x2_y1y2
+ xmin = clip(xmin, 0, width)
+ xmax = clip(xmax, 0, width)
+ ymin = clip(ymin, 0, height)
+ ymax = clip(ymax, 0, height)
+ box = np.array([[xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]])
+ bboxes.append({'position': box})
+ for bbox in free_list:
+ if bbox:
+ bboxes.append({'position': np.array(bbox)})
+ return {'detected_texts': bboxes}
+
+ def recognize_only(self, img: np.ndarray, **kwargs) -> dict:
+ out = {'text': '', 'score': 0.0}
+ try:
+ img = cv2.cvtColor(img, cv2.COLOR_RGBA2GRAY)
+ result = self.ocr_engine.recognize(img, **kwargs)
+ if result:
+ out = {'text': result[0][1], 'score': result[0][2]}
+ except:
+ pass
+ return out
+
+ def ocr(
+ self, img: np.ndarray, rec_config: Optional[dict] = None, **kwargs
+ ) -> List[dict]:
+ rec_config = rec_config or {}
+ img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+ results = self.ocr_engine.readtext(img, **rec_config)
+ outs = []
+ for result in results:
+ outs.append(
+ {'text': result[1], 'score': result[2], 'position': np.array(result[0])}
+ )
+ return outs
+
+
+def prepare_ocr_engine(languages: Sequence[str], ocr_engine_config):
+ ocr_engine_config = custom_deepcopy(ocr_engine_config) if ocr_engine_config else {}
+ if len(set(languages).difference({'en', 'ch_sim'})) == 0:
+ from cnocr import CnOcr
+
+ # if 'ch_sim' not in languages and 'cand_alphabet' not in ocr_engine_config: # only recognize english characters
+ # ocr_engine_config['cand_alphabet'] = list(string.printable) + ['']
+ if tuple(languages) == ('en',): # only recognize english characters
+ if 'det_model_name' not in ocr_engine_config:
+ ocr_engine_config['det_model_name'] = 'en_PP-OCRv3_det'
+ if 'rec_model_name' not in ocr_engine_config:
+ ocr_engine_config['rec_model_name'] = 'en_PP-OCRv3'
+ ocr_engine = CnOcr(**ocr_engine_config)
+ engine_wrapper = CnOCREngine(languages, ocr_engine)
+ else:
+ try:
+ from easyocr import Reader
+ except:
+ raise ImportError('Please install easyocr first: pip install easyocr')
+ gpu = False
+ if 'context' in ocr_engine_config:
+ context = ocr_engine_config.pop('context').lower()
+ gpu = 'gpu' in context or 'cuda' in context
+ ocr_engine = Reader(lang_list=list(languages), gpu=gpu, **ocr_engine_config)
+ engine_wrapper = EasyOCREngine(languages, ocr_engine)
+ return engine_wrapper
diff --git a/pix2text/page_elements.py b/pix2text/page_elements.py
new file mode 100644
index 0000000000000000000000000000000000000000..5e1c3dbc1ec4b63b331e951cba2b77f10f0f24a9
--- /dev/null
+++ b/pix2text/page_elements.py
@@ -0,0 +1,405 @@
+# coding: utf-8
+import dataclasses
+from copy import deepcopy
+from pathlib import Path
+import re
+from typing import Sequence, Any, Union, Optional
+
+from PIL import Image
+
+from .table_ocr import visualize_cells
+from .utils import merge_line_texts, smart_join, y_overlap, list2box
+from .layout_parser import ElementType
+
+FORMULA_TAG = '^[（\(]\d+(\.\d+)*[）\)]$'
+
+
+@dataclasses.dataclass
+class Element(object):
+ id: str
+ box: Sequence
+ text: Optional[str]
+ meta: Any
+ type: ElementType
+ total_img: Image.Image
+ isolated: bool = False
+ col_number: int = -1
+ score: float = 1.0
+ spellchecker = None
+ kwargs: dict = dataclasses.field(default_factory=dict)
+
+ def __init__(
+ self,
+ *,
+ id: str,
+ box: Sequence,
+ isolated: bool,
+ col_number: int,
+ meta: Any,
+ type: ElementType,
+ total_img: Image.Image,
+ score: float,
+ text: Optional[str] = None,
+ spellchecker=None,
+ configs: Optional[dict] = None,
+ ):
+ self.total_img = total_img
+ self.id = id
+ self.box = box
+ self.isolated = isolated
+ self.col_number = col_number
+ self.meta = meta
+ self.type = type
+ self.score = score
+ self.spellchecker = spellchecker
+ self.kwargs = configs or {}
+
+ if self.meta is not None and text is None:
+ self.text = self._meta_to_text()
+ else:
+ self.text = text
+
+ if self.isolated:
+ self.text = self.text + '\n'
+
+ def to_dict(self):
+ return dataclasses.asdict(self)
+
+ def _meta_to_text(self) -> str:
+ if self.type in (ElementType.TEXT, ElementType.TITLE):
+ embed_sep = self.kwargs.get('embed_sep', (' $', '$ '))
+ isolated_sep = self.kwargs.get('isolated_sep', ('$$\n', '\n$$'))
+ line_sep = self.kwargs.get('line_sep', '\n')
+ auto_line_break = self.kwargs.get('auto_line_break', True)
+ if self.type == ElementType.TITLE:
+ for box_info in self.meta:
+ if box_info.get('type', 'text') == 'isolated':
+ box_info['type'] = 'embedding'
+ outs = merge_line_texts(
+ self.meta,
+ auto_line_break,
+ line_sep,
+ embed_sep,
+ isolated_sep,
+ self.spellchecker,
+ )
+ if self.type == ElementType.TITLE:
+ outs = smart_join(outs.split('\n'), self.spellchecker)
+ elif self.type == ElementType.FORMULA:
+ if isinstance(self.meta, dict):
+ outs = self.meta['text']
+ elif isinstance(self.meta, list):
+ outs = [one['text'] for one in self.meta]
+ elif self.type == ElementType.TABLE:
+ outs = '\n'.join(self.meta.get('markdown', []))
+ else:
+ outs = ''
+
+ return outs
+
+ def __repr__(self) -> str:
+ return f"Element({self.to_dict()})"
+
+ def __str__(self) -> str:
+ return self.__repr__()
+
+ def __lt__(self, other) -> bool:
+ """
+ Adapted from https://github.com/SVJLucas/Scanipy/blob/main/scanipy/elements/element.py.
+ Less than operator for Element objects.
+
+ Args:
+ other (Element): Another Element object.
+
+ Returns:
+ bool: True if this Element is "less than" the other, False otherwise.
+
+ Raises:
+ TypeError: If 'other' is not an instance or subclass of Element.
+ """
+
+ if not isinstance(other, Element):
+ raise TypeError("other must be an instance or subclass of Element")
+
+ return self._column_before(other) or (
+ self._same_column(other) and (self.box[1] < other.box[1])
+ )
+
+ def _column_before(self, other) -> bool:
+ """
+ Adapted from https://github.com/SVJLucas/Scanipy/blob/main/scanipy/elements/element.py.
+ Check if this Element is in a column before the other Element.
+
+ Args:
+ other (Element): Another Element object.
+
+ Returns:
+ bool: True if in a column before, False otherwise.
+ """
+
+ if not isinstance(other, Element):
+ raise TypeError("other must be an instance or subclass of Element")
+
+ return self.col_number < other.col_number
+ # max_width = max(box_width(self.box), box_width(other.box))
+ # return self.box[0] < other.box[0] - max_width / 2
+
+ def _same_column(self, other) -> bool:
+ """
+ Check if this Element is in the same column as the other Element.
+
+ Args:
+ other (Element): Another Element object.
+
+ Returns:
+ bool: True if in the same column, False otherwise.
+ """
+
+ if not isinstance(other, Element):
+ raise TypeError("other must be an instance or subclass of ElementOutput")
+
+ return self.col_number == other.col_number
+ # max_width = max(box_width(self.box), box_width(other.box))
+ # return abs(self.box[0] - other.box[0]) < max_width / 2
+
+
+def box_width(box):
+ return box[2] - box[0]
+
+
+class Page(object):
+ number: int
+ id: str
+ elements: Sequence[Element]
+ config: dict
+ spellchecker = None
+
+ def __init__(
+ self,
+ *,
+ number: int,
+ elements: Sequence[Element],
+ id: Optional[str] = None,
+ spellchecker=None,
+ config=None,
+ ):
+ self.number = number
+ self.id = id or str(number)
+ self.elements = elements
+ self.spellchecker = spellchecker
+ self.config = config or {}
+
+ def __repr__(self) -> str:
+ return f"Page(id={self.id}, number={self.number}, elements={self.elements})"
+
+ def to_markdown(
+ self,
+ out_dir: Union[str, Path],
+ root_url: Optional[str] = None,
+ markdown_fn: Optional[str] = 'output.md',
+ ) -> str:
+ """
+ Convert the Page to markdown.
+ Args:
+ out_dir (Union[str, Path]): The output directory.
+ root_url (Optional[str]): The root url for the saved images in the markdown files.
+ markdown_fn (Optional[str]): The markdown file name. Default is 'output.md'.
+
+ Returns: The markdown string.
+
+ """
+ out_dir = Path(out_dir)
+ out_dir.mkdir(exist_ok=True, parents=True)
+ self.elements = self._merge_isolated_formula_and_tag(self.elements)
+ self.elements.sort()
+ if not self.elements:
+ return ''
+ md_out = self._ele_to_markdown(self.elements[0], root_url, out_dir)
+ for idx, element in enumerate(self.elements[1:]):
+ prev_element = self.elements[idx]
+ cur_txt = self._ele_to_markdown(element, root_url, out_dir)
+ if (
+ prev_element.col_number + 1 == element.col_number
+ and prev_element.type == element.type
+ and prev_element.type in (ElementType.TEXT, ElementType.TITLE)
+ and md_out
+ and md_out[-1] != '\n'
+ and cur_txt
+ and cur_txt[0] != '\n'
+ ):
+ # column continuation
+ md_out = smart_join([md_out, cur_txt], self.spellchecker)
+ else:
+ md_out += '\n\n' + cur_txt
+
+ line_sep = '\n'
+ md_out = re.sub(
+ rf'{line_sep}{{2,}}', f'{line_sep}{line_sep}', md_out
+ ) # 把2个以上的连续 '\n' 替换为 '\n\n'
+ if markdown_fn:
+ with open(out_dir / markdown_fn, 'w', encoding='utf-8') as f:
+ f.write(md_out)
+ return md_out
+
+ def _ele_to_markdown(
+ self, element: Element, root_url: Optional[str], out_dir: Union[str, Path]
+ ):
+ type = element.type
+ text = element.text
+ if type in (ElementType.TEXT, ElementType.TABLE):
+ if type == ElementType.TABLE:
+ visualize_cells(
+ element.total_img.crop(element.box),
+ element.meta['cells'][0],
+ out_dir / f'{element.id}.png',
+ )
+ return text
+ elif type == ElementType.TITLE:
+ return f'## {text}'
+ elif type == ElementType.FORMULA:
+ isolated_sep = self.config.get('isolated_sep', ('$$\n', '\n$$'))
+ return isolated_sep[0] + text.strip() + isolated_sep[1]
+ elif type == ElementType.FIGURE:
+ out_figure_dir = out_dir / 'figures'
+ out_figure_dir.mkdir(exist_ok=True, parents=True)
+ out_path = out_figure_dir / f'{element.id}-{type.name}.jpg'
+ element.total_img.crop(element.box).save(str(out_path))
+
+ _url = self._map_path_to_url(root_url, out_path, out_dir)
+ return f''
+ return ''
+
+ def _map_path_to_url(self, root_url: Optional[str], path: Path, out_dir: Path):
+ rel_url = path.relative_to(out_dir)
+ if root_url is not None:
+ return f'{root_url}/{rel_url}'
+ return str(rel_url)
+
+ @classmethod
+ def _merge_isolated_formula_and_tag(cls, elements):
+ # 合并孤立的公式和公式标题
+ # 对于每个公式标题，找到与它在同一行且在其左侧距离最近的孤立公式，并把它们合并
+ isolated_formula = [
+ item
+ for item in elements
+ if item.type == ElementType.FORMULA and item.isolated
+ ]
+ formula_caption = [
+ item
+ for item in elements
+ if item.type == ElementType.TEXT and re.match(FORMULA_TAG, item.text)
+ ]
+ ele_ids = set([item.id for item in isolated_formula + formula_caption])
+ remaining_elements = [item for item in elements if item.id not in ele_ids]
+ for caption in formula_caption:
+ caption_xmin, caption_ymin, caption_xmax, caption_ymax = caption.box
+ min_dist = float('inf')
+ nearest_formula = None
+ for formula in isolated_formula:
+ formula_xmin, formula_ymin, formula_xmax, formula_ymax = formula.box
+ if (
+ caption.col_number == formula.col_number
+ and y_overlap(
+ list2box(*caption.box), list2box(*formula.box), key=None
+ )
+ >= 0.8
+ ):
+ dist = caption_xmin - formula_xmax
+ if 0 <= dist < min_dist:
+ min_dist = dist
+ nearest_formula = formula
+ if nearest_formula is not None:
+ new_formula = deepcopy(nearest_formula)
+ formula_xmin, formula_ymin, formula_xmax, formula_ymax = new_formula.box
+ new_formula.box = [
+ min(caption_xmin, formula_xmin),
+ min(caption_ymin, formula_ymin),
+ max(caption_xmax, formula_xmax),
+ max(caption_ymax, formula_ymax),
+ ]
+ new_text = new_formula.text.strip() + ' \\tag{{{}}}'.format(
+ caption.text[1:-1]
+ )
+ new_formula.text = new_text
+ if new_formula.meta and isinstance(new_formula.meta, dict):
+ new_formula.meta['text'] = new_text
+ remaining_elements.append(new_formula)
+ isolated_formula.remove(nearest_formula)
+ else: # not found
+ remaining_elements.append(caption)
+ return remaining_elements + isolated_formula
+
+
+class Document(object):
+ number: int
+ id: str
+ pages: Sequence[Page]
+ config: dict
+ spellchecker = None
+
+ def __init__(
+ self,
+ *,
+ number: int,
+ pages: Sequence[Page],
+ id: Optional[str] = None,
+ spellchecker=None,
+ config=None,
+ ):
+ self.number = number
+ self.id = id or str(number)
+ self.pages = pages
+ self.spellchecker = spellchecker
+ self.config = config or {}
+
+ def __repr__(self) -> str:
+ return f"Document(id={self.id}, number={self.number}, pages={self.pages})"
+
+ def to_markdown(
+ self,
+ out_dir: Union[str, Path],
+ root_url: Optional[str] = None,
+ markdown_fn: Optional[str] = 'output.md',
+ ) -> str:
+ """
+ Convert the Document to markdown.
+ Args:
+ out_dir (Union[str, Path]): The output directory.
+ root_url (Optional[str]): The root url for the saved images in the markdown files.
+ markdown_fn (Optional[str]): The markdown file name. Default is 'output.md'.
+
+ Returns: The markdown string.
+
+ """
+ out_dir = Path(out_dir)
+ out_dir.mkdir(exist_ok=True, parents=True)
+ self.pages.sort(key=lambda page: page.number)
+ if not self.pages:
+ return ''
+ md_out = self.pages[0].to_markdown(out_dir, root_url=root_url, markdown_fn=None)
+ for idx, page in enumerate(self.pages[1:]):
+ prev_page = self.pages[idx]
+ cur_txt = page.to_markdown(out_dir, root_url=root_url, markdown_fn=None)
+ if (
+ md_out
+ and prev_page.elements
+ and prev_page.elements[-1].type in (ElementType.TEXT, ElementType.TITLE)
+ and page.elements
+ and page.elements[0].type in (ElementType.TEXT, ElementType.TITLE)
+ and md_out[-1] != '\n'
+ and cur_txt
+ and cur_txt[0] != '\n'
+ ):
+ # column continuation
+ md_out = smart_join([md_out, cur_txt], self.spellchecker)
+ else:
+ md_out += '\n\n' + cur_txt
+
+ line_sep = '\n'
+ md_out = re.sub(
+ rf'{line_sep}{{2,}}', f'{line_sep}{line_sep}', md_out
+ ) # 把2个以上的连续 '\n' 替换为 '\n\n'
+ if markdown_fn:
+ with open(out_dir / markdown_fn, 'w', encoding='utf-8') as f:
+ f.write(md_out)
+ return md_out
diff --git a/pix2text/pix_to_text.py b/pix2text/pix_to_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cd995022d7056124cedd50e25fc12b2d774d9d7
--- /dev/null
+++ b/pix2text/pix_to_text.py
@@ -0,0 +1,697 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+import logging
+import io
+import os
+from copy import deepcopy
+from functools import cmp_to_key
+from pathlib import Path
+from typing import Dict, Any, Optional, Union, List, Literal
+
+import numpy as np
+from PIL import Image
+import fitz # PyMuPDF
+
+from .utils import (
+ select_device,
+ box2list,
+ read_img,
+ add_img_margin,
+ get_background_color,
+ x_overlap,
+ list2box,
+ merge_line_texts,
+)
+from .layout_parser import LayoutParser, ElementType
+# from .layoutlmv3 import LayoutLMv3LayoutParser
+from .text_formula_ocr import TextFormulaOCR
+from .table_ocr import TableOCR
+from .page_elements import Element, Page, Document
+
+logger = logging.getLogger(__name__)
+
+
+def prepare_layout_engine(layout_config: Optional[Dict[str, Any]], device: str = None) -> LayoutParser:
+ layout_config = layout_config or {}
+ kls = layout_config.pop('model_type', 'DocYoloLayoutParser')
+ if kls == 'DocXLayoutParser':
+ from .doc_xl_layout import DocXLayoutParser
+
+ layout_engine = DocXLayoutParser.from_config(layout_config, device=device)
+ # elif kls == 'LayoutLMv3LayoutParser':
+ # layout_engine = LayoutLMv3LayoutParser.from_config(layout_config, device=device)
+ elif kls == 'DocYoloLayoutParser':
+ from .doc_yolo_layout_parser import DocYoloLayoutParser
+
+ layout_engine = DocYoloLayoutParser.from_config(layout_config, device=device)
+ else:
+ raise ValueError(f'Unsupported layout parser: {kls}')
+ return layout_engine
+
+
+def prepare_text_formula_ocr_engine(
+ text_formula_config, enable_formula: bool, device: str, **kwargs
+):
+ text_formula_config = text_formula_config or {}
+ kls = text_formula_config.pop('model_type', 'TextFormulaOCR')
+ if kls == 'TextFormulaOCR':
+ text_formula_ocr = TextFormulaOCR.from_config(
+ text_formula_config, enable_formula=enable_formula, device=device, **kwargs
+ )
+ elif kls == 'VlmTextFormulaOCR':
+ from .text_formula_ocr import VlmTextFormulaOCR
+
+ assert "model_name" in text_formula_config, "VlmTextFormulaOCR requires model_name"
+ assert "api_key" in text_formula_config, "VlmTextFormulaOCR requires api_key"
+ text_formula_ocr = VlmTextFormulaOCR.from_config(
+ model_name=text_formula_config["model_name"],
+ api_key=text_formula_config["api_key"],
+ **kwargs,
+ )
+ else:
+ raise ValueError(f'Unsupported text formula OCR: {kls}')
+ return text_formula_ocr
+
+
+def prepare_table_ocr_engine(
+ table_config,
+ device: str,
+ text_formula_ocr: Optional[TextFormulaOCR] = None,
+ **kwargs,
+):
+ table_config = table_config or {}
+ kls = table_config.pop('model_type', 'TableOCR')
+ if kls == 'TableOCR':
+ if text_formula_ocr is None:
+ raise ValueError("text_formula_ocr must be provided for table OCR engine preparation.")
+
+ table_ocr = TableOCR.from_config(
+ text_formula_ocr.text_ocr,
+ text_formula_ocr.spellchecker,
+ table_config,
+ device=device,
+ )
+ elif kls == 'VlmTableOCR':
+ from .vlm_table_ocr import VlmTableOCR
+
+ assert "model_name" in table_config, "VlmTableOCR requires model_name"
+ assert "api_key" in table_config, "VlmTableOCR requires api_key"
+ table_ocr = VlmTableOCR.from_config(
+ model_name=table_config["model_name"],
+ api_key=table_config["api_key"],
+ **kwargs,
+ )
+ else:
+ raise ValueError(f'Unsupported table OCR: {kls}')
+ return table_ocr
+
+
+class Pix2Text(object):
+ # MODEL_FILE_PREFIX = 'pix2text-v{}'.format(MODEL_VERSION)
+
+ def __init__(
+ self,
+ *,
+ layout_parser: Optional[LayoutParser] = None,
+ text_formula_ocr: Optional[TextFormulaOCR] = None,
+ table_ocr: Optional[TableOCR] = None,
+ enable_formula: bool = True,
+ **kwargs,
+ ):
+ """
+ Initialize the Pix2Text object.
+ Args:
+ layout_parser (LayoutParser): The layout parser object; default value is `None`, which means to create a default one
+ text_formula_ocr (TextFormulaOCR): The text and formula OCR object; default value is `None`, which means to create a default one
+ table_ocr (TableOCR): The table OCR object; default value is `None`, which means not to recognize tables
+ enable_formula (bool): Whether to enable formula recognition; default value is `True`
+ **kwargs (dict): Other arguments, currently not used
+ """
+ if layout_parser is None:
+ device = select_device(None)
+ layout_parser = prepare_layout_engine({}, device=device)
+ if text_formula_ocr is None:
+ device = select_device(None)
+ text_formula_ocr = TextFormulaOCR.from_config(
+ None, enable_formula=enable_formula, device=device
+ )
+ self.layout_parser = layout_parser
+ self.text_formula_ocr = text_formula_ocr
+ self.table_ocr = table_ocr
+ self.enable_formula = enable_formula
+
+ @classmethod
+ def from_config(
+ cls,
+ total_configs: Optional[dict] = None,
+ enable_formula: bool = True,
+ enable_table: bool = True,
+ device: str = None,
+ **kwargs,
+ ):
+ """
+ Create a Pix2Text object from the configuration.
+ Args:
+ total_configs (dict): The total configuration; default value is `None`, which means to use the default configuration.
+ If not None, it should contain the following keys:
+
+ * `layout`: The layout parser configuration
+ * `text_formula`: The TextFormulaOCR configuration
+ * `table`: The table OCR configuration
+ enable_formula (bool): Whether to enable formula recognition; default value is `True`
+ enable_table (bool): Whether to enable table recognition; default value is `True`
+ device (str): The device to run the model; optional values are 'cpu', 'gpu' or 'cuda';
+ default value is `None`, which means to select the device automatically
+ **kwargs (dict): Other arguments
+
+ Returns: a Pix2Text object
+
+ """
+ total_configs = total_configs or {}
+ layout_config = total_configs.get('layout', None)
+ text_formula_config = total_configs.get('text_formula', None)
+ table_config = total_configs.get('table', None)
+
+ layout_parser = prepare_layout_engine(layout_config, device=device)
+ text_formula_ocr = prepare_text_formula_ocr_engine(
+ text_formula_config, enable_formula, device, **kwargs
+ )
+ if enable_table:
+ table_ocr = prepare_table_ocr_engine(
+ table_config,
+ device=device,
+ text_formula_ocr=text_formula_ocr,
+ **kwargs,
+ )
+ else:
+ table_ocr = None
+
+ return cls(
+ layout_parser=layout_parser,
+ text_formula_ocr=text_formula_ocr,
+ table_ocr=table_ocr,
+ enable_formula=enable_formula,
+ **kwargs,
+ )
+
+ def __call__(self, img: Union[str, Path, Image.Image], **kwargs) -> Page:
+ return self.recognize_page(img, page_id='0', **kwargs)
+
+ def recognize(
+ self,
+ img: Union[str, Path, Image.Image],
+ file_type: Literal[
+ 'pdf', 'page', 'text_formula', 'formula', 'text'
+ ] = 'text_formula',
+ **kwargs,
+ ) -> Union[Document, Page, str, List[str], List[Any], List[List[Any]]]:
+ """
+ Recognize the content of the image or pdf file according to the specified type.
+ It will call the corresponding recognition function `.recognize_{img_type}()` according to the `img_type`.
+ Args:
+ img (Union[str, Path, Image.Image]): The image/pdf file path or `Image.Image` object
+ file_type (str): Supported file types: 'pdf', 'page', 'text_formula', 'formula', 'text'
+ **kwargs (dict): Arguments for the corresponding recognition function
+
+ Returns: recognized results
+
+ """
+ rec_func = getattr(self, f'recognize_{file_type}', None)
+ if rec_func is None:
+ raise ValueError(f'Unsupported file type: {file_type}')
+ return rec_func(img, **kwargs)
+
+ def recognize_pdf(
+ self,
+ pdf_fp: Union[str, Path],
+ pdf_number: int = 0,
+ pdf_id: Optional[str] = None,
+ page_numbers: Optional[List[int]] = None,
+ **kwargs,
+ ) -> Document:
+ """
+ recognize a pdf file
+ Args:
+ pdf_fp (Union[str, Path]): pdf file path
+ pdf_number (int): pdf number
+ pdf_id (str): pdf id
+ page_numbers (List[int]): page numbers to recognize; default is `None`, which means to recognize all pages.
+ Numbers started from 0 (the first page).
+ kwargs (dict): Optional keyword arguments. The same as `recognize_page`
+
+ Returns: a Document object. Use `doc.to_markdown('output-dir')` to get the markdown output of the recognized document.
+
+ """
+ pdf_id = pdf_id or str(pdf_number)
+
+ doc = fitz.open(pdf_fp, filetype='pdf')
+ if page_numbers is None:
+ page_numbers = list(range(len(doc)))
+ outs = []
+ for page_num in range(len(doc)):
+ if page_num not in page_numbers:
+ continue
+ page = doc.load_page(page_num)
+ # convert to image
+ pix = page.get_pixmap(dpi=300)
+ # convert the pixmap to bytes
+ img_data = pix.tobytes(output='jpg', jpg_quality=200)
+ # Create a PIL Image from the raw image data
+ image = Image.open(io.BytesIO(img_data)).convert('RGB')
+ page_id = str(page_num)
+ page_kwargs = deepcopy(kwargs)
+ if kwargs.get('save_debug_res'):
+ page_kwargs['save_debug_res'] = os.path.join(
+ kwargs['save_debug_res'], f'{pdf_id}-{page_id}'
+ )
+ outs.append(
+ self.recognize_page(
+ image, page_number=page_num, page_id=page_id, **page_kwargs
+ )
+ )
+ return Document(
+ number=pdf_number,
+ id=pdf_id,
+ pages=outs,
+ spellchecker=self.text_formula_ocr.spellchecker,
+ config=kwargs,
+ )
+
+ def recognize_page(
+ self,
+ img: Union[str, Path, Image.Image],
+ page_number: int = 0,
+ page_id: Optional[str] = None,
+ **kwargs,
+ ) -> Page:
+ """
+ Analyze the layout of the image, and then recognize the information contained in each section.
+
+ Args:
+ img (str or Image.Image): an image path, or `Image.Image` loaded by `Image.open()`
+ page_number (str): page number; default value is `0`
+ page_id (str): page id; default value is `None`, which means to use the `str(page_number)`
+ kwargs ():
+ * resized_shape (int): Resize the image width to this size for processing; default value is `768`
+ * mfr_batch_size (int): batch size for MFR; When running on GPU, this value is suggested to be set to greater than 1; default value is `1`
+ * embed_sep (tuple): Prefix and suffix for embedding latex; only effective when `return_text` is `True`; default value is `(' $', '$ ')`
+ * isolated_sep (tuple): Prefix and suffix for isolated latex; only effective when `return_text` is `True`; default value is two-dollar signs
+ * line_sep (str): The separator between lines of text; only effective when `return_text` is `True`; default value is a line break
+ * auto_line_break (bool): Automatically line break the recognized text; only effective when `return_text` is `True`; default value is `True`
+ * det_text_bbox_max_width_expand_ratio (float): Expand the width of the detected text bbox. This value represents the maximum expansion ratio above and below relative to the original bbox height; default value is `0.3`
+ * det_text_bbox_max_height_expand_ratio (float): Expand the height of the detected text bbox. This value represents the maximum expansion ratio above and below relative to the original bbox height; default value is `0.2`
+ * embed_ratio_threshold (float): The overlap threshold for embed formulas and text lines; default value is `0.6`.
+ When the overlap between an embed formula and a text line is greater than or equal to this threshold,
+ the embed formula and the text line are considered to be on the same line;
+ otherwise, they are considered to be on different lines.
+ * table_as_image (bool): If `True`, the table will be recognized as an image (don't parse the table content as text) ; default value is `False`
+ * title_contain_formula (bool): If `True`, the title of the page will be recognized as a mixed image (text and formula). If `False`, it will be recognized as a text; default value is `False`
+ * text_contain_formula (bool): If `True`, the text of the page will be recognized as a mixed image (text and formula). If `False`, it will be recognized as a text; default value is `True`
+ * formula_rec_kwargs (dict): generation arguments passed to formula recognizer `latex_ocr`; default value is `{}`
+ * save_debug_res (str): if `save_debug_res` is set, the directory to save the debug results; default value is `None`, which means not to save
+
+ Returns: a Page object. Use `page.to_markdown('output-dir')` to get the markdown output of the recognized page.
+ """
+ if isinstance(img, Image.Image):
+ img0 = img.convert('RGB')
+ else:
+ img0 = read_img(img, return_type='Image')
+
+ page_id = page_id or str(page_number)
+ kwargs['embed_sep'] = kwargs.get('embed_sep', (' $', '$ '))
+ kwargs['isolated_sep'] = kwargs.get('isolated_sep', ('$$\n', '\n$$'))
+ kwargs['line_sep'] = kwargs.get('line_sep', '\n')
+ kwargs['auto_line_break'] = kwargs.get('auto_line_break', True)
+ kwargs['title_contain_formula'] = kwargs.get('title_contain_formula', False)
+ kwargs['text_contain_formula'] = kwargs.get('text_contain_formula', True)
+ resized_shape = kwargs.get('resized_shape', 768)
+ kwargs['resized_shape'] = resized_shape
+ layout_kwargs = deepcopy(kwargs)
+ layout_kwargs['resized_shape'] = resized_shape
+ layout_kwargs['table_as_image'] = kwargs.get('table_as_image', False)
+ if self.table_ocr is None:
+ layout_kwargs['table_as_image'] = True
+ layout_out, column_meta = self.layout_parser.parse(
+ img0.copy(), **layout_kwargs,
+ )
+
+ debug_dir = None
+ if kwargs.get('save_debug_res', None):
+ debug_dir = Path(kwargs.get('save_debug_res'))
+ debug_dir.mkdir(exist_ok=True, parents=True)
+
+ outs = []
+ for _id, box_info in enumerate(layout_out):
+ image_type = box_info['type']
+ if image_type == ElementType.IGNORED:
+ continue
+ box = box2list(box_info['position'])
+ crop_patch = img0.crop(box)
+ crop_width, _ = crop_patch.size
+ score = 1.0
+ if not self.enable_formula and image_type == ElementType.FORMULA:
+ image_type = ElementType.TEXT
+ if image_type in (ElementType.TEXT, ElementType.TITLE, ElementType.PLAIN_TEXT):
+ _resized_shape = resized_shape
+ while crop_width > 1.5 * _resized_shape and _resized_shape < 2048:
+ _resized_shape = min(int(1.5 * _resized_shape), 2048)
+ padding_patch = add_img_margin(
+ crop_patch, left_right_margin=30, top_bottom_margin=30
+ )
+ text_formula_kwargs = deepcopy(kwargs)
+ text_formula_kwargs['resized_shape'] = _resized_shape
+ text_formula_kwargs['save_analysis_res'] = (
+ debug_dir / f'{_id}-{image_type.name}.png' if debug_dir else None
+ )
+ if image_type == ElementType.TITLE:
+ text_formula_kwargs['contain_formula'] = kwargs[
+ 'title_contain_formula'
+ ]
+ elif image_type == ElementType.TEXT:
+ text_formula_kwargs['contain_formula'] = kwargs[
+ 'text_contain_formula'
+ ]
+ elif image_type == ElementType.PLAIN_TEXT:
+ text_formula_kwargs['contain_formula'] = False
+ image_type = ElementType.TEXT
+
+ text_formula_kwargs['return_text'] = False
+ _out = self.text_formula_ocr.recognize(
+ padding_patch, **text_formula_kwargs,
+ )
+ text, meta = None, _out
+ score = float(np.mean([x['score'] for x in _out]))
+ elif image_type == ElementType.TABLE:
+ xmin, ymin, xmax, ymax = box
+ img_width, img_height = img0.size
+ table_expansion_margin = 10
+ xmin, ymin = (
+ max(0, xmin - table_expansion_margin),
+ max(0, ymin - table_expansion_margin),
+ )
+ xmax, ymax = (
+ min(img_width, xmax + table_expansion_margin),
+ min(img_height, ymax + table_expansion_margin),
+ )
+ box = (xmin, ymin, xmax, ymax)
+ crop_patch = img0.crop(box)
+ save_analysis_res = (
+ debug_dir / f'{_id}-{image_type.name}.png' if debug_dir else None
+ )
+ table_kwargs = deepcopy(kwargs)
+ table_kwargs['save_analysis_res'] = save_analysis_res
+ _out = self.table_ocr.recognize(
+ crop_patch,
+ out_cells=True,
+ out_markdown=True,
+ out_html=True,
+ **table_kwargs,
+ )
+ text, meta = None, _out
+ elif image_type == ElementType.FORMULA:
+ formula_kwargs = deepcopy(kwargs)
+ formula_kwargs['return_text'] = False
+ _out = self.text_formula_ocr.recognize_formula(
+ crop_patch, **formula_kwargs
+ )
+ score = _out['score']
+ text, meta = None, _out
+ elif image_type == ElementType.FIGURE:
+ text, meta = '', None
+ else:
+ image_type = ElementType.UNKNOWN
+ text, meta = '', None
+
+ outs.append(
+ Element(
+ id=f'{page_id}-{_id}',
+ box=box,
+ meta=meta,
+ text=text,
+ isolated=box_info['isolated'],
+ col_number=box_info['col_number'],
+ type=image_type,
+ score=score,
+ total_img=img0,
+ spellchecker=self.text_formula_ocr.spellchecker,
+ configs=kwargs,
+ )
+ )
+
+ remaining_blocks = self._parse_remaining(
+ img0, layout_out, column_meta, debug_dir, **kwargs
+ )
+ for box_info in remaining_blocks:
+ outs.append(
+ Element(
+ id=f'{page_id}-{len(outs)}-remaining',
+ box=box2list(box_info['position']),
+ meta=None,
+ text=box_info['text'],
+ isolated=False,
+ col_number=box_info['col_number'],
+ type=ElementType.TEXT
+ if box_info['type'] != 'isolated'
+ else ElementType.FORMULA,
+ score=box_info['score'],
+ total_img=img0,
+ spellchecker=self.text_formula_ocr.spellchecker,
+ configs=kwargs,
+ )
+ )
+ return Page(
+ number=page_number,
+ id=page_id,
+ elements=outs,
+ spellchecker=self.text_formula_ocr.spellchecker,
+ config=kwargs,
+ )
+
+ def _parse_remaining(self, img0, layout_out, column_meta, debug_dir, **kwargs):
+ masked_img = np.array(img0.copy())
+ bg_color = get_background_color(img0)
+ # 把layout parser 已解析出的部分mask掉，然后对其他部分进行OCR
+ for _box_info in layout_out:
+ xmin, ymin, xmax, ymax = box2list(_box_info['position'])
+ masked_img[ymin:ymax, xmin:xmax, :] = bg_color
+ masked_img = Image.fromarray(masked_img)
+
+ text_formula_kwargs = deepcopy(kwargs)
+ text_formula_kwargs['return_text'] = False
+ save_analysis_res = debug_dir / f'layout-remaining.png' if debug_dir else None
+ text_formula_kwargs['save_analysis_res'] = save_analysis_res
+ _out = self.text_formula_ocr.recognize(masked_img, **text_formula_kwargs,)
+ min_text_length = kwargs.get('min_text_length', 4)
+ _out = [_o for _o in _out if len(_o['text']) >= min_text_length]
+ # guess which column the box belongs to
+ for _box_info in _out:
+ overlap_vals = []
+ for col_number, col_info in column_meta.items():
+ overlap_val = x_overlap(_box_info, col_info, key='position')
+ overlap_vals.append([col_number, overlap_val])
+ if len(overlap_vals) > 0:
+ overlap_vals.sort(key=lambda x: (x[1], x[0]), reverse=True)
+ match_col_number = overlap_vals[0][0]
+ else:
+ match_col_number = 0
+ _box_info['col_number'] = match_col_number
+
+ if len(_out) < 2:
+ return _out
+
+ def _compare(box_info1, box_info2):
+ if box_info1['col_number'] != box_info2['col_number']:
+ return box_info1['col_number'] < box_info2['col_number']
+ else:
+ return box_info1['position'][0, 1] < box_info2['position'][0, 1]
+
+ _out = sorted(_out, key=cmp_to_key(_compare))
+
+ begin_idx = 0
+ end_idx = 1
+
+ new_blocks = []
+ while end_idx <= len(_out):
+ while (
+ end_idx < len(_out)
+ and _out[end_idx]['col_number'] == _out[begin_idx]['col_number']
+ ):
+ end_idx += 1
+ col_outs = _out[begin_idx:end_idx]
+ begin_idx = end_idx
+ end_idx += 1
+ if len(col_outs) < 2:
+ new_blocks.append(col_outs[0])
+ else:
+ new_blocks.extend(
+ _separate_blocks(
+ col_outs, self.text_formula_ocr.spellchecker, **kwargs
+ )
+ )
+
+ return new_blocks
+
+ def recognize_text_formula(
+ self, img: Union[str, Path, Image.Image], return_text: bool = True, **kwargs,
+ ) -> Union[str, List[str], List[Any], List[List[Any]]]:
+ """
+ Analyze the layout of the image, and then recognize the information contained in each section.
+
+ Args:
+ img (str or Image.Image): an image path, or `Image.Image` loaded by `Image.open()`
+ return_text (bool): Whether to return the recognized text; default value is `True`
+ kwargs ():
+ * resized_shape (int): Resize the image width to this size for processing; default value is `768`
+ * save_analysis_res (str): Save the mfd result image in this file; default is `None`, which means not to save
+ * mfr_batch_size (int): batch size for MFR; When running on GPU, this value is suggested to be set to greater than 1; default value is `1`
+ * embed_sep (tuple): Prefix and suffix for embedding latex; only effective when `return_text` is `True`; default value is `(' $', '$ ')`
+ * isolated_sep (tuple): Prefix and suffix for isolated latex; only effective when `return_text` is `True`; default value is two-dollar signs
+ * line_sep (str): The separator between lines of text; only effective when `return_text` is `True`; default value is a line break
+ * auto_line_break (bool): Automatically line break the recognized text; only effective when `return_text` is `True`; default value is `True`
+ * det_text_bbox_max_width_expand_ratio (float): Expand the width of the detected text bbox. This value represents the maximum expansion ratio above and below relative to the original bbox height; default value is `0.3`
+ * det_text_bbox_max_height_expand_ratio (float): Expand the height of the detected text bbox. This value represents the maximum expansion ratio above and below relative to the original bbox height; default value is `0.2`
+ * embed_ratio_threshold (float): The overlap threshold for embed formulas and text lines; default value is `0.6`.
+ When the overlap between an embed formula and a text line is greater than or equal to this threshold,
+ the embed formula and the text line are considered to be on the same line;
+ otherwise, they are considered to be on different lines.
+ * table_as_image (bool): If `True`, the table will be recognized as an image; default value is `False`
+ * formula_rec_kwargs (dict): generation arguments passed to formula recognizer `latex_ocr`; default value is `{}`
+
+ Returns: a str when `return_text` is `True`; or a list of ordered (top to bottom, left to right) dicts when `return_text` is `False`,
+ with each dict representing one detected box, containing keys:
+
+ * `type`: The category of the image; Optional: 'text', 'isolated', 'embedding'
+ * `text`: The recognized text or Latex formula
+ * `score`: The confidence score [0, 1]; the higher, the more confident
+ * `position`: Position information of the block, `np.ndarray`, with shape of [4, 2]
+ * `line_number`: The line number of the box (first line `line_number==0`), boxes with the same value indicate they are on the same line
+
+ """
+ return self.text_formula_ocr.recognize(img, return_text, **kwargs)
+
+ def recognize_text(
+ self,
+ imgs: Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]],
+ return_text: bool = True,
+ rec_config: Optional[dict] = None,
+ **kwargs,
+ ) -> Union[str, List[str], List[Any], List[List[Any]]]:
+ """
+ Recognize a pure Text Image.
+ Args:
+ imgs (Union[str, Path, Image.Image], List[str], List[Path], List[Image.Image]): The image or list of images
+ return_text (bool): Whether to return only the recognized text; default value is `True`
+ rec_config (Optional[dict]): The config for recognition
+ kwargs (): Other parameters for `text_ocr.ocr()`
+
+ Returns: Text str or list of text strs when `return_text` is True;
+ `List[Any]` or `List[List[Any]]` when `return_text` is False, with the same length as `imgs` and the following keys:
+
+ * `position`: Position information of the block, `np.ndarray`, with a shape of [4, 2]
+ * `text`: The recognized text
+ * `score`: The confidence score [0, 1]; the higher, the more confident
+
+ """
+ return self.text_formula_ocr.recognize_text(
+ imgs, return_text, rec_config, **kwargs
+ )
+
+ def recognize_formula(
+ self,
+ imgs: Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]],
+ batch_size: int = 1,
+ return_text: bool = True,
+ rec_config: Optional[dict] = None,
+ **kwargs,
+ ) -> Union[str, List[str], Dict[str, Any], List[Dict[str, Any]]]:
+ """
+ Recognize pure Math Formula images to LaTeX Expressions
+ Args:
+ imgs (Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]): The image or list of images
+ batch_size (int): The batch size
+ return_text (bool): Whether to return only the recognized text; default value is `True`
+ rec_config (Optional[dict]): The config for recognition
+ **kwargs (): Special model parameters. Not used for now
+
+ Returns: The LaTeX Expression or list of LaTeX Expressions;
+ str or List[str] when `return_text` is True;
+ Dict[str, Any] or List[Dict[str, Any]] when `return_text` is False, with the following keys:
+
+ * `text`: The recognized LaTeX text
+ * `score`: The confidence score [0, 1]; the higher, the more confident
+
+ """
+ return self.text_formula_ocr.recognize_formula(
+ imgs, batch_size, return_text, rec_config, **kwargs
+ )
+
+
+def _separate_blocks(col_outs, spellchecker, **kwargs):
+ out_blocks = []
+
+ def _merge_lines(cur_block_lines):
+ if len(cur_block_lines) < 2:
+ return cur_block_lines[0]
+ ymin = cur_block_lines[0]['position'][0, 1]
+ ymax = cur_block_lines[-1]['position'][3, 1]
+ xmin = min([_b['position'][0, 0] for _b in cur_block_lines])
+ xmax = max([_b['position'][3, 0] for _b in cur_block_lines])
+ position = list2box(xmin, ymin, xmax, ymax)
+ score = np.mean([_b['score'] for _b in cur_block_lines])
+ col_number = cur_block_lines[0]['col_number']
+ # text = smart_join([_b['text'] for _b in cur_block_lines], spellchecker)
+ text = merge_line_texts(
+ cur_block_lines,
+ auto_line_break=kwargs['auto_line_break'],
+ line_sep=kwargs['line_sep'],
+ embed_sep=kwargs['embed_sep'],
+ isolated_sep=kwargs['isolated_sep'],
+ spellchecker=spellchecker,
+ )
+
+ return {
+ 'type': 'text',
+ 'text': text,
+ 'position': position,
+ 'score': score,
+ 'col_number': col_number,
+ 'line_number': len(out_blocks),
+ }
+
+ cur_block_lines = [col_outs[0]]
+ for _box_info in col_outs[1:]:
+ cur_height = (
+ cur_block_lines[-1]['position'][3, 1]
+ - cur_block_lines[-1]['position'][0, 1]
+ )
+ if (
+ _box_info['position'][0, 1] - cur_block_lines[-1]['position'][3, 1]
+ < cur_height
+ ):
+ # 当前行与下一行的间距少于一行的行高，则认为它们在相同的block
+ cur_block_lines.append(_box_info)
+ else:
+ # merge lines
+ merged_line = _merge_lines(cur_block_lines)
+ out_blocks.append(merged_line)
+
+ cur_block_lines = [_box_info]
+
+ if len(cur_block_lines) > 0:
+ merged_line = _merge_lines(cur_block_lines)
+ out_blocks.append(merged_line)
+
+ return out_blocks
+
+
+if __name__ == '__main__':
+ from .utils import set_logger
+
+ logger = set_logger(log_level='DEBUG')
+
+ p2t = Pix2Text()
+ img = 'docs/examples/english.jpg'
+ img = read_img(img, return_type='Image')
+ out = p2t.recognize(img)
+ logger.info(out)
diff --git a/pix2text/render.py b/pix2text/render.py
new file mode 100644
index 0000000000000000000000000000000000000000..e36470bd69210fb2ac86eb9ad1b0012e74c32675
--- /dev/null
+++ b/pix2text/render.py
@@ -0,0 +1,217 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+
+COLOR_MAPPING = {
+ 'general': '#009933',
+ 'english': '#3399ff',
+ 'formula': '#ff8000',
+ 'hybrid': '#009999',
+ 'text': '#3399ff',
+ 'isolated': '#ff8000',
+ 'text-embed': '#009999',
+}
+
+def render_html(newest_fp, image_type, text, out_html_fp):
+ html_str = """
+
+
+
+
+
Pix2Text : a free tool like Mathpix
+
Screenshot
+
+ """
+ html_str += fr'
' + '\n
'
+ html_str += """
+
Refresh
+
Results
+ """
+
+ html_str += r'Image Type: ' \
+ fr' ' \
+ fr'{image_type}
' + '\n'
+
+ if image_type in ('formula', 'hybrid'):
+ html_str += '
'
+
+ html_str += """
+
+
+
+ """
+
+ html_str += '\n
'
+
+ html_str += """
+
+ Copy
+ $Copy$
+ $$Copy$$
+
+
Pix2Text Evaluation Results
+
+
+
+ Pix2Text Evaluation Results
+
+
+ Image
+ Ground Truth
+ Prediction
+ CER
+
+ {rows}
+
+
+"""
+
+ rows_html = ""
+ total_cer = 0.0
+ valid_count = 0
+
+ for result in results:
+ # Handle image path
+ img_path = result.get(img_path_key, '')
+ if prefix_img_dir and not os.path.isabs(img_path):
+ img_path = os.path.join(prefix_img_dir, img_path)
+
+ # Process image
+ img_html = ""
+ if img_path and os.path.exists(img_path):
+ try:
+ with PILImage.open(img_path) as pil_img:
+ if pil_img.mode in ('RGBA', 'LA', 'P'):
+ pil_img = pil_img.convert('RGB')
+
+ # Resize if needed
+ width, height = pil_img.size
+ ratio = min(max_img_width / width, max_img_height / height, 1.0)
+ new_width = int(width * ratio)
+ new_height = int(height * ratio)
+
+ if ratio < 1.0:
+ pil_img = pil_img.resize((new_width, new_height), PILImage.Resampling.LANCZOS)
+
+ # Convert to base64
+ img_bytes = io.BytesIO()
+ pil_img.save(img_bytes, format='PNG')
+ img_base64 = base64.b64encode(img_bytes.getvalue()).decode()
+
+ img_html = f'Error: {os.path.basename(img_path)} '
+ else:
+ img_html = f'Not Found: {os.path.basename(img_path) if img_path else "No path"} '
+
+ # Get text values
+ gt_text = result.get(gt_key, '').replace('\n', '
+ {img_html}
+ {gt_text}
+ {pred_text}
+ {cer_value:.4f}
+ """
+ rows_html += row_html
+
+ # Calculate average CER
+ avg_cer = total_cer / valid_count if valid_count > 0 else 0.0
+
+ # Add summary row
+ summary_row = f"""
+ Average CER
+ {avg_cer:.4f}
+ """
+ rows_html += summary_row
+
+ # Generate final HTML
+ final_html = html_template.format(
+ max_width=max_img_width,
+ max_height=max_img_height,
+ rows=rows_html
+ )
+
+ # Save HTML file
+ with open(output_file, 'w', encoding='utf-8') as f:
+ f.write(final_html)
+
+ print(f"HTML report saved to: {output_file}")
+ print(f"Average CER: {avg_cer:.4f}")
+ return True
+
+ except Exception as e:
+ print(f"Error creating HTML report: {e}")
+ return False
diff --git a/pix2text/vlm_api.py b/pix2text/vlm_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..7866548843d7e8a05605019d7dc27f3813aadca7
--- /dev/null
+++ b/pix2text/vlm_api.py
@@ -0,0 +1,240 @@
+# coding: utf-8
+import io
+import requests
+import base64
+import logging
+from typing import Optional, Union, List
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+from litellm import completion, batch_completion
+
+logger = logging.getLogger(__name__)
+
+
+# Function to encode the image
+def encode_image(
+ image_path: Union[str, Image.Image],
+ *,
+ max_image_size: int = 768,
+ auto_resize: bool = True,
+) -> Optional[str]:
+ """Encodes an image file or URL to base64 string with optional resizing.
+
+ This function can handle three types of inputs:
+ 1. PIL Image object
+ 2. URL string (starting with http:// or https://)
+ 3. Local file path
+
+ The function optionally resizes images that exceed the specified maximum dimension
+ while maintaining the aspect ratio.
+
+ Args:
+ image_path (Union[str, PIL.Image.Image]): Path to image file, URL, or PIL Image object
+ max_image_size (int, optional): Maximum dimension for image resize. Defaults to 768.
+ auto_resize (bool, optional): Whether to automatically resize large images. Defaults to True.
+
+ Returns:
+ str: Base64 encoded string of the image data.
+ Returns None if URL fetching fails.
+
+ Example:
+ >>> encoded = encode_image("path/to/image.jpg")
+ >>> encoded = encode_image("https://example.com/image.jpg")
+ >>> encoded = encode_image(pil_image_object)
+ """
+ if isinstance(image_path, Image.Image):
+ img = image_path.convert("RGB")
+ buffered = io.BytesIO()
+ img.save(buffered, format="PNG")
+ image_data = buffered.getvalue()
+ elif image_path.startswith(("http://", "https://")):
+ response = requests.get(image_path)
+ try:
+ response.raise_for_status() # Raise an error for bad responses
+ except requests.exceptions.HTTPError as e:
+ print(f"Failed to fetch image: {e}")
+ return None
+ image_data = response.content
+ else:
+ with open(image_path, "rb") as image_file:
+ image_data = image_file.read()
+ if not auto_resize:
+ return base64.b64encode(image_data).decode("utf-8")
+
+ # 对分辨率太高的图片， 把其短边压缩到 max_image_size
+ image = Image.open(io.BytesIO(image_data))
+ width, height = image.size
+ if width > max_image_size and height > max_image_size:
+ if width > height:
+ new_height = max_image_size
+ new_width = int(width * max_image_size / height)
+ else:
+ new_height = int(height * max_image_size / width)
+ new_width = max_image_size
+ image = image.resize((new_width, new_height))
+ # image.save("out-resize.png")
+ # Convert image to bytes
+ buffered = io.BytesIO()
+ image.save(buffered, format="PNG")
+ return base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+
+def parse_content(content) -> dict:
+ """Parse the content from the API response.
+ Example:
+ convert '## text_language\nzh\n## text_content\n```\n## 写作。Writing. (50 points)\n写一写自己的一个爱好。\n```' to a structured dictionary:
+ {
+ "language": "zh",
+ "content": "## 写作。Writing. (50 points)\n写一写自己的一个爱好。\n```"
+ }
+
+ Args:
+ content (str): The content string to parse.
+
+ Returns:
+ dict: The parsed content, with keys "language" and "text".
+ - language (str): The language of the content.
+ - text (str): The text content, which may include Markdown formatting.
+ """
+ if not isinstance(content, str):
+ raise ValueError("Content must be a string")
+ splits = content.split("## text_content")
+ if len(splits) != 2:
+ raise ValueError("Content format is incorrect")
+ parsed_str = splits[1].strip()
+ # 去掉 开头的 ```.*\n 和结尾的 ```
+ if parsed_str.startswith("```"):
+ parsed_str = parsed_str[parsed_str.index("\n") + 1 :]
+ if parsed_str.endswith("```"):
+ parsed_str = parsed_str[: parsed_str.rindex("```")].strip()
+ lang_splits = splits[0].split("## text_language")
+ if len(lang_splits) != 2:
+ raise ValueError("Language format is incorrect")
+ lang = lang_splits[1].strip()
+
+ return {
+ "language": lang,
+ "text": parsed_str,
+ }
+
+PROMPT = """
+首先识别图片中的文字是什么语言，然后再把图片中的文字或数学公式转换成Markdown格式表示， 数学公式使用tex表示。
+注意：
+- 不要出现任何多余的文字
+- 行内内嵌公式使用`$...$`包裹
+- 独立行公式使用`$$\n...\n$$`包裹
+- 表格中的每行开头和结尾都要有|
+- 段落标题前面使用合适数量的 #
+输出格式示例：
+## text_language
+zh
+## text_content
+```
+这是文字。内嵌公式：$x^2$。独立行公式：
+$$
+x^2 + y^2 = z^2
+$$
+```
+"""
+
+
+class Vlm(object):
+ """
+ VLM API for image-to-text conversion.
+ This class uses the Litellm library to interact with the VLM API.
+ """
+
+ def __init__(self, *, model_name: str, api_key: str) -> None:
+ self.model_name = model_name
+ self.api_key = api_key
+
+ def __call__(
+ self,
+ img_path: Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]] = None,
+ *,
+ prompt: str = PROMPT,
+ resized_shape: int = 768,
+ auto_resize: bool = True,
+ parsing_func: Optional[callable] = parse_content,
+ **kwargs,
+ ) -> Union[dict, List[dict]]:
+ """Call the VLM API to convert image to text.
+ Args:
+ img_path (Union[str, Path, Image.Image, List[str], List[Path], List[Image.Image]]): Path to the image file or files.
+ prompt (str): Prompt for the API.
+ auto_resize (bool): Whether to automatically resize large images.
+ **kwargs: Additional arguments for the API call.
+ Returns:
+ dict or List[dict]: A dictionary for single image and list of dicts for multiple images. Each dict contains the text extracted from the image and the score:
+ - text: Extracted text from the image.
+ - score: Probability score of the extracted text.
+ """
+ single_image = False if isinstance(img_path, (list, tuple)) else True
+ img_paths = [img_path] if single_image else img_path
+ messages = []
+ for img_path in img_paths:
+ if isinstance(img_path, Path):
+ img_path = str(img_path)
+ if not isinstance(img_path, (str, Image.Image)):
+ raise ValueError("img_path must be a string or PIL Image object")
+ base64_image = encode_image(img_path, max_image_size=resized_shape, auto_resize=auto_resize)
+ content = [
+ {"type": "text", "text": prompt},
+ {
+ "type": "image_url",
+ "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},
+ },
+ ]
+ messages.append(
+ [
+ {"role": "user", "content": content},
+ ]
+ )
+
+ try:
+ responses = batch_completion(
+ model=self.model_name,
+ messages=messages,
+ api_key=self.api_key,
+ **kwargs,
+ )
+
+ results = []
+ for response in responses:
+ # Extract the response content
+ out = response.get("choices", [{}])[0].get("message", {}).get("content")
+ logprob = response.get("choices", [{}])[0].get("logprobs")
+ # to probability
+ prob = float(np.exp(logprob)) if logprob else 0.0
+ if parsing_func is None:
+ one_res = {
+ "text": out,
+ "score": prob,
+ }
+ else:
+ try:
+ one_res = parsing_func(out)
+ one_res["score"] = prob
+ except Exception as exc:
+ logger.error("An error occurred while parsing the content: %s", exc)
+ one_res = {
+ "text": out,
+ "score": prob,
+ }
+ results.append(one_res)
+ except Exception as exc:
+ logger.error("An error occurred: %s", exc)
+ results = [{
+ "text": "",
+ "score": 0.0,
+ } for _ in img_paths]
+
+ return results[0] if single_image else results
+
+ def __repr__(self):
+ return f"Vlm(model_name={self.model_name})"
+
+ def __str__(self):
+ return f"Vlm(model_name={self.model_name})"
diff --git a/pix2text/vlm_table_ocr.py b/pix2text/vlm_table_ocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..2088eed78d74f5765afc01ff6a1196c10ff9ca02
--- /dev/null
+++ b/pix2text/vlm_table_ocr.py
@@ -0,0 +1,218 @@
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+
+import os
+from typing import Union, Optional, Dict, Any, List
+from copy import deepcopy
+from pathlib import Path
+
+from PIL import Image
+import numpy as np
+
+from .utils import read_img
+
+
+
+# Default VLM prompt for table recognition
+TABLE_PROMPT = """
+首先识别图片中的文字是什么语言，然后再把图片中的表格转换成Markdown格式表示， 数学公式使用tex表示。
+注意：
+- 不要出现任何多余的文字
+- 行内内嵌公式使用$符号包裹
+- 独立行公式使用$$符号包裹
+- 表格中的每行开头和结尾都要有|
+输出格式示例：
+## text_language
+en
+## text_content
+```
+|---|---|
+| 1 | line1 |
+| 2 | square: $a^2$ |
+| 3 | $$r^2$$ |
+```
+)
+"""
+
+
+class VlmTableOCR(object):
+ """
+ Implements table extraction using Vision Language Models.
+ This class uses the same interface as TableOCR but leverages VLM capabilities.
+ """
+
+ def __init__(
+ self,
+ vlm=None,
+ **kwargs,
+ ):
+ """
+ Initialize a VlmTableOCR object.
+
+ Args:
+ vlm: Vision Language Model instance for table recognition
+ **kwargs: Additional parameters
+ """
+ if vlm is None:
+ raise ValueError("vlm must be provided")
+
+ self.vlm = vlm
+
+ @classmethod
+ def from_config(
+ cls,
+ configs: Optional[dict] = None,
+ **kwargs,
+ ):
+ """
+ Create a VlmTableOCR instance from configuration.
+
+ Args:
+ vlm: Vision Language Model instance
+ configs (Optional[dict], optional): Configuration dictionary
+ **kwargs: Additional parameters
+
+ Returns:
+ VlmTableOCR: An instance of VlmTableOCR
+ """
+ from .vlm_api import Vlm
+
+ # Combine configs with any additional kwargs
+ all_kwargs = kwargs.copy()
+ if configs:
+ all_kwargs.update(configs)
+
+ vlm = Vlm(
+ model_name=all_kwargs.pop("model_name", None),
+ api_key=all_kwargs.pop("api_key", None),
+ )
+
+ return cls(
+ vlm=vlm,
+ **all_kwargs
+ )
+
+ def recognize(
+ self,
+ img: Union[str, Path, Image.Image],
+ *,
+ prompt: Optional[str] = TABLE_PROMPT,
+ out_objects=False,
+ out_cells=False,
+ out_html=False,
+ out_csv=False,
+ out_markdown=True,
+ **kwargs,
+ ) -> Dict[str, Any]:
+ """
+ Recognize tables from an image using VLM.
+
+ Args:
+ img: Input image (path, PIL.Image)
+ prompt (Optional[str]): Custom prompt for VLM
+ out_objects (bool): Whether to output objects
+ out_cells (bool): Whether to output cells
+ out_html (bool): Whether to output HTML
+ out_csv (bool): Whether to output CSV
+ out_markdown (bool): Whether to output Markdown
+ **kwargs: Additional parameters
+ * resized_shape (int): Resize shape for large images
+ * save_analysis_res (str): Save the parsed result image in this file
+
+ Returns:
+ Dict[str, Any]: Dictionary containing recognized table data in requested formats
+ """
+ out_formats = {}
+
+ if not (out_objects or out_cells or out_html or out_csv or out_markdown):
+ print("No output format specified")
+ return out_formats
+
+ if not isinstance(img, (str, Path, Image.Image)):
+ raise ValueError("img must be a path or PIL.Image")
+
+ # Process with VLM
+ try:
+ vlm_result = self.vlm(
+ img_path=img,
+ prompt=prompt,
+ auto_resize=True,
+ resized_shape=kwargs.get("resized_shape", 768),
+ **kwargs,
+ )
+
+ markdown_text = vlm_result.get("text", "")
+
+ # For markdown output
+ if out_markdown:
+ out_formats["markdown"] = [markdown_text]
+
+ # For HTML output (convert from markdown if needed)
+ if out_html:
+ try:
+ import markdown
+
+ html_text = markdown.markdown(markdown_text, extensions=["tables"])
+ # Extract just the table HTML
+ if "" in html_text:
+ table_html = html_text[
+ html_text.find("") + 8
+ ]
+ out_formats["html"] = [table_html]
+ else:
+ out_formats["html"] = [
+ "Failed to convert to HTML
"
+ ]
+ except ImportError:
+ out_formats["html"] = [
+ "Markdown conversion library not available
"
+ ]
+
+ # For CSV output (convert from markdown if needed)
+ if out_csv:
+ try:
+ import pandas as pd
+ import io
+
+ # Simple markdown table to CSV conversion
+ lines = [
+ line.strip()
+ for line in markdown_text.split("\n")
+ if line.strip()
+ ]
+ cleaned_lines = []
+
+ for line in lines:
+ if line.startswith("|") and line.endswith("|"):
+ # Remove the first and last | and split by |
+ cells = [cell.strip() for cell in line[1:-1].split("|")]
+ cleaned_lines.append(",".join(cells))
+
+ if cleaned_lines and "---" in cleaned_lines[1]:
+ # Remove the separator line (---|---|---)
+ cleaned_lines.pop(1)
+
+ csv_content = "\n".join(cleaned_lines)
+ out_formats["csv"] = [csv_content]
+ except Exception as e:
+ out_formats["csv"] = [f"Error converting to CSV: {str(e)}"]
+
+ # For cellular representation (simplified for VLM)
+ if out_cells:
+ raise NotImplementedError(
+ "Cellular representation is not implemented for VLMTableOCR."
+ )
+
+ # For objects (simplified for VLM)
+ if out_objects:
+ raise NotImplementedError(
+ "Object representation is not implemented for VLMTableOCR."
+ )
+
+ except Exception as e:
+ print(f"Error recognizing table: {e}")
+ if out_markdown:
+ out_formats["markdown"] = ["Error processing table with VLM"]
+
+ return out_formats
diff --git a/pix2text_v1_0.ipynb b/pix2text_v1_0.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..04e4186b9e8c07d718b465edd70921b96581e546
--- /dev/null
+++ b/pix2text_v1_0.ipynb
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4640eaa9cf4d52cac4c6d7963983957b7562748845e680b07772e2c9959ec42d
+size 1298689
diff --git a/pix2text_v1_1.ipynb b/pix2text_v1_1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..1cd069cae0ad723fd26ab54f63f1575ddbb040a6
--- /dev/null
+++ b/pix2text_v1_1.ipynb
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:647c0f0b58ff4314f0aaa741315bf66e06677889205eff173e108436c1c7f03a
+size 1235746
diff --git a/readme.txt b/readme.txt
new file mode 100644
index 0000000000000000000000000000000000000000..597f90681b1506023654aded755abfd9b10f246a
--- /dev/null
+++ b/readme.txt
@@ -0,0 +1 @@
+https://github.com/breezedeus/Pix2Text
\ No newline at end of file
diff --git a/requirements.in b/requirements.in
new file mode 100644
index 0000000000000000000000000000000000000000..147ad533718f0fbd9de7aa4cf169e2053861f65d
--- /dev/null
+++ b/requirements.in
@@ -0,0 +1,20 @@
+--index-url https://mirrors.aliyun.com/pypi/simple
+--extra-index-url https://pypi.tuna.tsinghua.edu.cn/simple
+--extra-index-url https://pypi.org/simple
+
+click
+tqdm
+numpy
+torch
+torchvision
+pillow>=5.3.0
+opencv-python
+cnstd>=1.2.6.1
+cnocr[ort-cpu]>=2.3.2.1
+transformers>=4.37.0
+optimum[onnxruntime]
+easyocr
+pymupdf>=1.20.0
+pyspellchecker
+doclayout-yolo<0.1
+albumentations==1.3.1
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..124f428724853c826d0fe5791c7d47690910f459
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,452 @@
+#
+# This file is autogenerated by pip-compile with Python 3.10
+# by the following command:
+#
+# pip-compile --output-file=requirements.txt requirements.in
+#
+--index-url https://mirrors.aliyun.com/pypi/simple
+--extra-index-url https://pypi.tuna.tsinghua.edu.cn/simple
+--extra-index-url https://pypi.org/simple
+
+aiohttp==3.9.3
+ # via
+ # datasets
+ # fsspec
+aiosignal==1.3.1
+ # via aiohttp
+albucore==0.0.20
+ # via albumentations
+albumentations==1.4.21
+ # via doclayout-yolo
+annotated-types==0.7.0
+ # via pydantic
+antlr4-python3-runtime==4.9.3
+ # via omegaconf
+appdirs==1.4.4
+ # via wandb
+async-timeout==4.0.3
+ # via aiohttp
+attrs==23.2.0
+ # via aiohttp
+certifi==2024.2.2
+ # via
+ # requests
+ # sentry-sdk
+charset-normalizer==3.3.2
+ # via requests
+click==8.1.7
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # wandb
+cnocr[ort-cpu]==2.3.2.1
+ # via -r requirements.in
+cnstd==1.2.6.1
+ # via
+ # -r requirements.in
+ # cnocr
+coloredlogs==15.0.1
+ # via
+ # onnxruntime
+ # optimum
+colorlog==6.9.0
+ # via rapidocr
+contourpy==1.2.0
+ # via matplotlib
+cycler==0.12.1
+ # via matplotlib
+datasets==2.17.0
+ # via
+ # evaluate
+ # optimum
+dill==0.3.8
+ # via
+ # datasets
+ # evaluate
+ # multiprocess
+docker-pycreds==0.4.0
+ # via wandb
+doclayout-yolo==0.0.4
+ # via -r requirements.in
+easyocr==1.7.1
+ # via -r requirements.in
+eval-type-backport==0.2.0
+ # via albumentations
+evaluate==0.4.1
+ # via optimum
+filelock==3.13.1
+ # via
+ # datasets
+ # huggingface-hub
+ # torch
+ # transformers
+flatbuffers==23.5.26
+ # via onnxruntime
+fonttools==4.49.0
+ # via matplotlib
+frozenlist==1.4.1
+ # via
+ # aiohttp
+ # aiosignal
+fsspec[http]==2023.10.0
+ # via
+ # datasets
+ # evaluate
+ # huggingface-hub
+ # pytorch-lightning
+ # torch
+gitdb==4.0.11
+ # via gitpython
+gitpython==3.1.42
+ # via wandb
+huggingface-hub==0.20.3
+ # via
+ # cnstd
+ # datasets
+ # evaluate
+ # optimum
+ # tokenizers
+ # transformers
+humanfriendly==10.0
+ # via coloredlogs
+idna==3.6
+ # via
+ # requests
+ # yarl
+imageio==2.34.0
+ # via scikit-image
+jinja2==3.1.3
+ # via torch
+kiwisolver==1.4.5
+ # via matplotlib
+lazy-loader==0.3
+ # via scikit-image
+lightning-utilities==0.10.1
+ # via
+ # pytorch-lightning
+ # torchmetrics
+markupsafe==2.1.5
+ # via jinja2
+matplotlib==3.8.3
+ # via
+ # cnstd
+ # doclayout-yolo
+ # seaborn
+ # ultralytics
+mpmath==1.3.0
+ # via sympy
+multidict==6.0.5
+ # via
+ # aiohttp
+ # yarl
+multiprocess==0.70.16
+ # via
+ # datasets
+ # evaluate
+networkx==3.2.1
+ # via
+ # scikit-image
+ # torch
+ninja==1.11.1.1
+ # via easyocr
+numpy==1.26.4
+ # via
+ # -r requirements.in
+ # albucore
+ # albumentations
+ # cnocr
+ # cnstd
+ # contourpy
+ # datasets
+ # easyocr
+ # evaluate
+ # imageio
+ # matplotlib
+ # onnx
+ # onnxruntime
+ # opencv-python
+ # opencv-python-headless
+ # optimum
+ # pandas
+ # pyarrow
+ # pytorch-lightning
+ # rapidocr
+ # scikit-image
+ # scipy
+ # seaborn
+ # shapely
+ # tifffile
+ # torchmetrics
+ # torchvision
+ # transformers
+ # ultralytics-thop
+omegaconf==2.3.0
+ # via rapidocr
+onnx==1.15.0
+ # via
+ # cnocr
+ # cnstd
+ # optimum
+onnxruntime==1.17.0
+ # via
+ # cnocr
+ # optimum
+opencv-python==4.9.0.80
+ # via
+ # -r requirements.in
+ # cnstd
+ # doclayout-yolo
+ # rapidocr
+ # ultralytics
+opencv-python-headless==4.9.0.80
+ # via
+ # albucore
+ # albumentations
+ # easyocr
+optimum[onnxruntime]==1.16.2
+ # via -r requirements.in
+packaging==23.2
+ # via
+ # datasets
+ # evaluate
+ # huggingface-hub
+ # lightning-utilities
+ # matplotlib
+ # onnxruntime
+ # optimum
+ # pytorch-lightning
+ # scikit-image
+ # torchmetrics
+ # transformers
+pandas==2.2.0
+ # via
+ # cnstd
+ # datasets
+ # doclayout-yolo
+ # evaluate
+ # seaborn
+ # ultralytics
+pillow==10.2.0
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # doclayout-yolo
+ # easyocr
+ # imageio
+ # matplotlib
+ # rapidocr
+ # scikit-image
+ # torchvision
+ # ultralytics
+protobuf==4.25.3
+ # via
+ # onnx
+ # onnxruntime
+ # optimum
+ # transformers
+ # wandb
+psutil==5.9.8
+ # via
+ # doclayout-yolo
+ # ultralytics
+ # wandb
+py-cpuinfo==9.0.0
+ # via
+ # doclayout-yolo
+ # ultralytics
+pyarrow==15.0.0
+ # via datasets
+pyarrow-hotfix==0.6
+ # via datasets
+pyclipper==1.3.0.post5
+ # via
+ # cnstd
+ # easyocr
+ # rapidocr
+pydantic==2.9.2
+ # via albumentations
+pydantic-core==2.23.4
+ # via pydantic
+pymupdf==1.24.1
+ # via -r requirements.in
+pymupdfb==1.24.1
+ # via pymupdf
+pyparsing==3.1.1
+ # via matplotlib
+pyspellchecker==0.8.1
+ # via -r requirements.in
+python-bidi==0.4.2
+ # via easyocr
+python-dateutil==2.8.2
+ # via
+ # matplotlib
+ # pandas
+pytorch-lightning==2.2.0.post0
+ # via
+ # cnocr
+ # cnstd
+pytz==2024.1
+ # via pandas
+pyyaml==6.0.1
+ # via
+ # albumentations
+ # cnstd
+ # datasets
+ # doclayout-yolo
+ # easyocr
+ # huggingface-hub
+ # omegaconf
+ # pytorch-lightning
+ # rapidocr
+ # transformers
+ # ultralytics
+ # wandb
+rapidocr==3.2.0
+ # via
+ # cnocr
+ # cnstd
+regex==2023.12.25
+ # via transformers
+requests==2.31.0
+ # via
+ # datasets
+ # doclayout-yolo
+ # evaluate
+ # fsspec
+ # huggingface-hub
+ # rapidocr
+ # responses
+ # torchvision
+ # transformers
+ # ultralytics
+ # wandb
+responses==0.18.0
+ # via evaluate
+safetensors==0.4.2
+ # via transformers
+scikit-image==0.22.0
+ # via easyocr
+scipy==1.12.0
+ # via
+ # albumentations
+ # cnstd
+ # doclayout-yolo
+ # easyocr
+ # scikit-image
+ # ultralytics
+seaborn==0.13.2
+ # via
+ # cnstd
+ # doclayout-yolo
+ # ultralytics
+sentencepiece==0.1.99
+ # via transformers
+sentry-sdk==1.40.4
+ # via wandb
+setproctitle==1.3.3
+ # via wandb
+shapely==2.0.2
+ # via
+ # cnstd
+ # easyocr
+ # rapidocr
+simsimd==6.0.5
+ # via albucore
+six==1.16.0
+ # via
+ # docker-pycreds
+ # python-bidi
+ # python-dateutil
+ # rapidocr
+smmap==5.0.1
+ # via gitdb
+stringzilla==3.10.10
+ # via albucore
+sympy==1.12
+ # via
+ # onnxruntime
+ # optimum
+ # torch
+thop==0.1.1.post2209072238
+ # via doclayout-yolo
+tifffile==2024.2.12
+ # via scikit-image
+tokenizers==0.15.2
+ # via transformers
+torch==2.2.0
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # doclayout-yolo
+ # easyocr
+ # optimum
+ # pytorch-lightning
+ # thop
+ # torchmetrics
+ # torchvision
+ # ultralytics
+ # ultralytics-thop
+torchmetrics==1.3.1
+ # via
+ # cnocr
+ # pytorch-lightning
+torchvision==0.17.0
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # doclayout-yolo
+ # easyocr
+ # ultralytics
+tqdm==4.66.2
+ # via
+ # -r requirements.in
+ # cnocr
+ # cnstd
+ # datasets
+ # doclayout-yolo
+ # evaluate
+ # huggingface-hub
+ # pytorch-lightning
+ # rapidocr
+ # transformers
+ # ultralytics
+transformers[sentencepiece]==4.37.2
+ # via
+ # -r requirements.in
+ # optimum
+typing-extensions==4.9.0
+ # via
+ # huggingface-hub
+ # lightning-utilities
+ # pydantic
+ # pydantic-core
+ # pytorch-lightning
+ # torch
+tzdata==2024.1
+ # via pandas
+ultralytics==8.2.32
+ # via cnstd
+ultralytics-thop==0.2.8
+ # via ultralytics
+unidecode==1.3.8
+ # via cnstd
+urllib3==2.2.0
+ # via
+ # requests
+ # responses
+ # sentry-sdk
+wandb==0.16.3
+ # via cnocr
+xxhash==3.4.1
+ # via
+ # datasets
+ # evaluate
+yarl==1.9.4
+ # via aiohttp
+
+# The following packages are considered to be unsafe in a requirements file:
+# setuptools
diff --git a/scripts/__init__.py b/scripts/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..57d631c3f004f9f6e24c31388e4df58801b8aba1
--- /dev/null
+++ b/scripts/__init__.py
@@ -0,0 +1 @@
+# coding: utf-8
diff --git a/scripts/screenshot_daemon.py b/scripts/screenshot_daemon.py
new file mode 100644
index 0000000000000000000000000000000000000000..913a9846b82f9b0fe1aecbb2f639d515f22702f5
--- /dev/null
+++ b/scripts/screenshot_daemon.py
@@ -0,0 +1,78 @@
+# coding: utf-8
+# Copyright (C) 2022, [Breezedeus](https://github.com/breezedeus).
+
+# 安装 pyperclip
+# > pip install pyperclip
+
+import os
+import time
+import glob
+
+import pyperclip as pc
+
+from pix2text import set_logger, Pix2Text, merge_line_texts, render_html
+
+logger = set_logger(log_level='DEBUG')
+
+SCREENSHOT_DIR = os.getenv(
+ "SCREENSHOT_DIR", '/Users/king/Pictures/screenshot_from_xnip'
+)
+
+thresholds = {
+ 'formula2general': 0.65, # 如果识别为 `formula` 类型，但得分小于此阈值，则改为 `general` 类型
+ 'english2general': 0.75, # 如果识别为 `english` 类型，但得分小于此阈值，则改为 `general` 类型
+}
+config = dict(analyzer=dict(model_name='mfd-1.5'), thresholds=thresholds)
+P2T = Pix2Text.from_config(config)
+
+
+def get_newest_fp_time(screenshot_dir):
+ fn_list = glob.glob1(screenshot_dir, '*g')
+ fp_list = [os.path.join(screenshot_dir, fn) for fn in fn_list]
+ if not fp_list:
+ return None, None
+ fp_list.sort(key=lambda fp: os.path.getmtime(fp), reverse=True)
+ return fp_list[0], os.path.getmtime(fp_list[0])
+
+
+def recognize(screenshot_dir, delta_interval):
+ while True:
+ newest_fp, newest_mod_time = get_newest_fp_time(screenshot_dir)
+ if (
+ newest_mod_time is not None
+ and time.time() - newest_mod_time < delta_interval
+ ):
+ logger.info(f'analyzing screenshot file {newest_fp}')
+ image_type, result = _recognize_newest(newest_fp)
+ logger.info('image type: %s, image text: %s', image_type, result)
+ if result:
+ pc.copy(result)
+ # render_html('./analysis_res.jpg', image_type, result, out_html_fp='out-text.html')
+ time.sleep(1)
+
+
+def _recognize_newest(newest_fp):
+ res = P2T.recognize(
+ newest_fp,
+ use_analyzer=True,
+ save_analysis_res='./analysis_res.jpg',
+ embed_sep=(' $$', '$$ '),
+ isolated_sep=('\n', '\n'),
+ )
+ if len(res) == 1:
+ return res[0]['type'], res[0]['text']
+ elif len(res) > 1:
+ box_types = set([info['type'] for info in res])
+ if len(box_types) > 1:
+ image_type = 'hybrid'
+ else:
+ image_type = list(box_types)[0]
+ text = merge_line_texts(res, auto_line_break=True)
+
+ return image_type, text
+
+ return 'general', ''
+
+
+if __name__ == '__main__':
+ recognize(SCREENSHOT_DIR, 1.05)
diff --git a/scripts/try_pix2text_mfr.py b/scripts/try_pix2text_mfr.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8555ec0bab843d36414713504a519217e4e4db7
--- /dev/null
+++ b/scripts/try_pix2text_mfr.py
@@ -0,0 +1,86 @@
+# coding: utf-8
+#! pip install pillow transformers optimum[onnxruntime]
+from PIL import Image
+from transformers import TrOCRProcessor
+from optimum.onnxruntime import ORTModelForVision2Seq
+from transformers import VisionEncoderDecoderModel
+
+def test_tokenizer_consistency(processor, test_strings=None):
+ """
+ 测试Tokenizer的编码和解码是否一致
+
+ Args:
+ processor: TrOCRProcessor实例
+ test_strings (list): 要测试的字符串列表
+ """
+ if test_strings is None:
+ test_strings = [
+ # "Hello, world!",
+ # "你好，世界！",
+ # "12345",
+ # "1 + 1 = 2",
+ # "The quick brown fox jumps over the lazy dog.",
+ # "测试一下中文和English混合的情况",
+ # "\mathcal{L}_{\mathrm{e y e l i d}} \,=\sum_{t=1}^{T} \sum_{v=1}^{V} \mathcal{M}_{v}^{\mathrm{( e y e l i d )}} \left( \left\| \hat{h}_{t, v}-x_{t, v} \right\|^{2} \right)",
+ "\\hat { N } _ { 3 } = \\sum \\sp f _ { j = 1 } a _ { j } \\sp { \\dagger } a _ { j } .",
+ ]
+
+ print("\n" + "="*50)
+ print("Testing Tokenizer Consistency")
+ print("="*50)
+
+ all_passed = True
+ for text in test_strings:
+ # 编码
+ encoded = processor.tokenizer.encode_plus(text, return_tensors="pt")
+ outs = processor.tokenizer(
+ [text],
+ padding="max_length",
+ truncation=True,
+ max_length=512,
+ )["input_ids"]
+ input_ids = encoded["input_ids"][0]
+ breakpoint()
+
+ # 解码
+ decoded = processor.tokenizer.decode(input_ids, skip_special_tokens=True)
+
+ # 比较
+ is_match = (text == decoded)
+ if not is_match:
+ all_passed = False
+
+ print(f"\nOriginal: {repr(text)}")
+ print(f"Encoded: {input_ids.tolist()}")
+ print(f"Decoded: {repr(decoded)}")
+ print(f"Match: {is_match}")
+
+ print("\n" + "="*50)
+ if all_passed:
+ print("✅ All tests passed! Tokenizer encoding and decoding are consistent.")
+ else:
+ print("❌ Some tests failed. Tokenizer encoding and decoding are not consistent.")
+ print("="*50 + "\n")
+
+model = 'breezedeus/pix2text-mfr'
+model = 'models/checkpoint-683356'
+processor = TrOCRProcessor.from_pretrained(model)
+
+# 测试Tokenizer的编码和解码是否一致
+# test_tokenizer_consistency(processor)
+
+# model = ORTModelForVision2Seq.from_pretrained(model, use_cache=False)
+
+model = VisionEncoderDecoderModel.from_pretrained(model)
+
+image_fps = [
+ # 'https://github.com/breezedeus/Pix2Text/blob/main/docs/examples/formula.jpg?raw=true',
+ 'docs/examples/formula.jpg',
+ # '/Users/king/Documents/WhatIHaveDone/Test/syndoc/output-latex/sqrt_tex/150-cmbright.jpg'
+ # 'examples/0000186.png',
+]
+images = [Image.open(fp).convert('RGB') for fp in image_fps]
+pixel_values = processor(images=images, return_tensors="pt").pixel_values
+generated_ids = model.generate(pixel_values)
+generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)
+print(f'generated_ids: {generated_ids}, \ngenerated text: {generated_text}')
diff --git a/scripts/try_service.py b/scripts/try_service.py
new file mode 100644
index 0000000000000000000000000000000000000000..6579113388de3b1b623c2667485dec530136ba25
--- /dev/null
+++ b/scripts/try_service.py
@@ -0,0 +1,36 @@
+# coding: utf-8
+
+import requests
+
+
+def main():
+ url = 'http://0.0.0.0:8503/pix2text'
+
+ image_fp = 'docs/examples/page2.png'
+ # image_fp = 'docs/examples/mixed.jpg'
+ # image_fp = 'docs/examples/math-formula-42.png'
+ # image_fp = 'docs/examples/english.jpg'
+ data = {
+ "file_type": "page",
+ "resized_shape": 768,
+ "embed_sep": " $,$ ",
+ "isolated_sep": "$$\n, \n$$"
+ }
+ files = {
+ "image": (image_fp, open(image_fp, 'rb'), 'image/jpeg')
+ }
+
+ r = requests.post(url, data=data, files=files)
+
+ outs = r.json()['results']
+ out_md_dir = r.json()['output_dir']
+ if isinstance(outs, str):
+ only_text = outs
+ else:
+ only_text = '\n'.join([out['text'] for out in outs])
+ print(f'{only_text=}')
+ print(f'{out_md_dir=}')
+
+
+if __name__ == '__main__':
+ main()
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000000000000000000000000000000000000..b08aa738ec5c0851110f3e9af839ad19d59bcf19
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# coding: utf-8
+# [Pix2Text](https://github.com/breezedeus/pix2text): an Open-Source Alternative to Mathpix.
+# Copyright (C) 2022-2024, [Breezedeus](https://www.breezedeus.com).
+
+import os
+from setuptools import find_packages, setup
+from pathlib import Path
+
+PACKAGE_NAME = "pix2text"
+
+here = Path(__file__).parent
+
+long_description = (here / "README.md").read_text(encoding="utf-8")
+
+about = {}
+exec(
+ (here / PACKAGE_NAME.replace('.', os.path.sep) / "__version__.py").read_text(
+ encoding="utf-8"
+ ),
+ about,
+)
+
+required = [
+ "click",
+ "tqdm",
+ "numpy",
+ "opencv-python",
+ "cnocr[ort-cpu]>=2.3.0.2",
+ "cnstd>=1.2.4.2",
+ "pillow",
+ "torch",
+ "torchvision",
+ "transformers>=4.37.0",
+ "optimum[onnxruntime]",
+ "PyMuPDF",
+ "pyspellchecker",
+ "doclayout-yolo<0.1",
+]
+extras_require = {
+ "multilingual": ["easyocr"],
+ "dev": ["pip-tools", "pytest"],
+ "serve": ["uvicorn[standard]", "fastapi", "python-multipart", "pydantic"],
+ "vlm": ["litellm"],
+}
+
+entry_points = """
+[console_scripts]
+p2t = pix2text.cli:cli
+"""
+
+setup(
+ name=PACKAGE_NAME,
+ version=about['__version__'],
+ description="An Open-Source Python3 tool for recognizing layouts, tables, math formulas, and text in images, converting them into Markdown format. A free alternative to Mathpix, empowering seamless conversion of visual content into text-based representations.",
+ long_description=long_description,
+ long_description_content_type="text/markdown",
+ author='breezedeus',
+ author_email='breezedeus@163.com',
+ license='MIT',
+ url='https://github.com/breezedeus/pix2text',
+ platforms=["Mac", "Linux", "Windows"],
+ packages=find_packages(),
+ include_package_data=True,
+ # data_files=[('', ['pix2text/doc_xl_layout/map_info.json',],)],
+ entry_points=entry_points,
+ install_requires=required,
+ extras_require=extras_require,
+ zip_safe=False,
+ classifiers=[
+ 'Development Status :: 4 - Beta',
+ 'Operating System :: OS Independent',
+ 'Intended Audience :: Developers',
+ 'License :: OSI Approved :: MIT License',
+ 'Programming Language :: Python',
+ 'Programming Language :: Python :: Implementation',
+ 'Programming Language :: Python :: 3',
+ 'Programming Language :: Python :: 3.8',
+ 'Programming Language :: Python :: 3.9',
+ 'Programming Language :: Python :: 3.10',
+ 'Programming Language :: Python :: 3.11',
+ 'Topic :: Scientific/Engineering :: Artificial Intelligence',
+ ],
+)
diff --git a/tests/test_doc_xl_layout_parser.py b/tests/test_doc_xl_layout_parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..916459744bb0a32d289d2c1e70443f7853d52600
--- /dev/null
+++ b/tests/test_doc_xl_layout_parser.py
@@ -0,0 +1,13 @@
+# coding: utf-8
+from pix2text.doc_xl_layout import DocXLayoutParser
+from pix2text.utils import set_logger
+
+logger = set_logger()
+
+
+def test_doc_xl_layout_parser():
+ # model_fp = os.path.expanduser('~/.pix2text/1.0/doc_xl_layout/DocXLayout_231012.pth')
+ img_fp = '/Users/king/Documents/WhatIHaveDone/Test/pix2text/docs/examples/page2.png'
+ layout_parser = DocXLayoutParser(debug=1)
+ out, column_meta = layout_parser.parse(img_fp)
+ print(out)
diff --git a/tests/test_doclayout_yolo.py b/tests/test_doclayout_yolo.py
new file mode 100644
index 0000000000000000000000000000000000000000..c451a63423c656616653a6b7193660b0a2ab8dd5
--- /dev/null
+++ b/tests/test_doclayout_yolo.py
@@ -0,0 +1,15 @@
+# coding: utf-8
+from doclayout_yolo import YOLOv10
+
+# Load the pre-trained model
+model = YOLOv10("doclayout_yolo_docstructbench_imgsz1024.pt")
+img = 'docs/examples/page-authors-1.png'
+# img = 'docs/examples/page.png'
+# Perform prediction
+det_res = model.predict(
+ img, # Image to predict
+ imgsz=1024, # Prediction image size
+ conf=0.2, # Confidence threshold
+ device="mps" # Device to use (e.g., 'cuda:0' or 'cpu')
+)[0]
+print(det_res.boxes)
\ No newline at end of file
diff --git a/tests/test_latex_ocr.py b/tests/test_latex_ocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..92abcde5b9cbd4bb4d86427b82cabcf5ab7ef6cb
--- /dev/null
+++ b/tests/test_latex_ocr.py
@@ -0,0 +1,59 @@
+# coding: utf-8
+import os
+import os.path
+import time
+
+from pix2text import set_logger, read_img
+from pix2text.latex_ocr import *
+
+logger = set_logger()
+
+
+def test_download_model():
+ latex_ocr = LatexOCR()
+
+ image_fps = [
+ 'docs/examples/formula.jpg',
+ 'docs/examples/math-formula-42.png',
+ ]
+ start_time = time.time()
+ outs = latex_ocr.recognize(image_fps)
+ logger.info(f'average cost time: {(time.time() - start_time) / len(image_fps):.4f} seconds')
+ for img, out in zip(image_fps, outs):
+ logger.info(f'- image: {img}, out: \n\t{out}')
+
+
+def test_infer_with_transformers():
+ from PIL import Image
+ from transformers import TrOCRProcessor
+ from optimum.onnxruntime import ORTModelForVision2Seq
+
+ model_dir = os.path.expanduser('~/.pix2text/1.1/mfr-1.5-onnx')
+ processor = TrOCRProcessor.from_pretrained(model_dir)
+ model = ORTModelForVision2Seq.from_pretrained(model_dir, use_cache=False)
+
+ image_fps = [
+ 'docs/examples/formula.jpg',
+ 'docs/examples/math-formula-42.png',
+ ]
+ images = [read_img(fp, return_type='Image') for fp in image_fps]
+ pixel_values = processor(images=images, return_tensors="pt").pixel_values
+ # print(f'pixel_values', pixel_values)
+ generated_ids = model.generate(pixel_values)
+ generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)
+ print(f'generated_ids: {generated_ids}, \ngenerated text: {generated_text}')
+
+
+def test_infer():
+ more_model_configs = {}
+ latex_ocr = LatexOCR(more_model_configs=more_model_configs)
+
+ image_fps = [
+ 'docs/examples/formula.jpg',
+ 'docs/examples/math-formula-42.png',
+ ]
+ start_time = time.time()
+ outs = latex_ocr.recognize(image_fps, batch_size=2)
+ logger.info(f'average cost time: {(time.time() - start_time) / len(image_fps):.4f} seconds')
+ for img, out in zip(image_fps, outs):
+ logger.info(f'- image: {img}, out: \n\t{out}')
\ No newline at end of file
diff --git a/tests/test_mfd.py b/tests/test_mfd.py
new file mode 100644
index 0000000000000000000000000000000000000000..44a1e96ac9062cd74f35101ae6dd8697ea058860
--- /dev/null
+++ b/tests/test_mfd.py
@@ -0,0 +1,20 @@
+# coding: utf-8
+
+from pix2text import set_logger
+from pix2text import MathFormulaDetector
+
+logger = set_logger()
+
+
+def test_formula_detector():
+ det = MathFormulaDetector()
+ image_fps = [
+ 'docs/examples/mixed.jpg',
+ 'docs/examples/vietnamese.jpg',
+ ]
+ outs = det.detect(image_fps[0])
+ print(outs)
+ outs = det.detect(image_fps)
+ # outs = det.detect(image_fps, visualize=True, save=True)
+ print(outs)
+
diff --git a/tests/test_pix2text.py b/tests/test_pix2text.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8ca41e8c61e8e0c5490ea5670469790df3a25cf
--- /dev/null
+++ b/tests/test_pix2text.py
@@ -0,0 +1,229 @@
+# coding: utf-8
+
+import os
+
+from pix2text import Pix2Text, set_logger
+
+set_logger()
+
+
+def test_recognize_pdf():
+ pdf_fn = '1804.07821'
+ img_fp = f'./docs/examples/{pdf_fn}.pdf'
+ text_formula_config = dict(
+ languages=('en', 'ch_sim'),
+ mfd=dict( # 声明 MFD 的初始化参数
+ model_path=os.path.expanduser(
+ '~/.pix2text/1.1/mfd-onnx/mfd-v20240618.onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ formula=dict(
+ model_name='mfr-pro',
+ model_backend='onnx',
+ model_dir=os.path.expanduser(
+ '~/.pix2text/1.1/mfr-pro-onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ text=dict(
+ rec_model_name='doc-densenet_lite_666-gru_large',
+ rec_model_backend='onnx',
+ rec_model_fp=os.path.expanduser(
+ '~/.cnocr/2.3/doc-densenet_lite_666-gru_large/cnocr-v2.3-doc-densenet_lite_666-gru_large-epoch=005-ft-model.onnx'
+ # noqa
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ )
+ total_config = {
+ 'layout': {},
+ 'text_formula': text_formula_config,
+ }
+ p2t = Pix2Text.from_config(total_configs=total_config, enable_formula=True)
+ out_md = p2t.recognize_pdf(
+ img_fp,
+ page_numbers=[0, 7, 8],
+ table_as_image=True,
+ save_debug_res=f'./outputs-{pdf_fn}',
+ )
+ out_md.to_markdown('page-output')
+ # print(out_page)
+ # out_page.to_markdown('page-output')
+
+
+def test_recognize_page():
+ # img_fp = './docs/examples/formula.jpg'
+ img_fp = './docs/examples/page2.png'
+ # img_fp = './docs/examples/mixed.jpg'
+ total_config = {
+ 'layout': {},
+ 'text_formula': {
+ 'formula': {
+ 'model_name': 'mfr-1.5',
+ 'model_backend': 'onnx',
+ 'more_model_configs': {'provider': 'CPUExecutionProvider'},
+ }
+ },
+ }
+ p2t = Pix2Text.from_config(total_configs=total_config)
+ out_page = p2t.recognize_page(
+ img_fp,
+ page_id='test_page_1',
+ title_contain_formula=False,
+ text_contain_formula=True,
+ save_debug_res='./outputs',
+ )
+ # print(out_page)
+ out_page.to_markdown('page-output')
+
+
+def test_spell_checker():
+ from spellchecker import SpellChecker
+
+ spell = SpellChecker()
+
+ # 找到拼写错误
+ misspelled = spell.unknown(["speci-fied"])
+
+ for word in misspelled:
+ # Get the one `most likely` answer
+ print('word:', word, ' ->', spell.correction(word))
+
+ # Get a list of `likely` options
+ print('suggestions:', spell.candidates(word))
+
+
+def test_blog_example():
+ img_fp = './docs/examples/mixed.jpg'
+
+ text_formula_config = dict(
+ mfd=dict( # 声明 MFD 的初始化参数
+ model_path=os.path.expanduser(
+ '~/.pix2text/1.1/mfd-onnx/mfd-v20240618.onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ formula=dict(
+ model_name='mfr-pro',
+ model_backend='onnx',
+ model_dir=os.path.expanduser(
+ '~/.pix2text/1.1/mfr-pro-onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ )
+ total_config = {
+ 'layout': {'scores_thresh': 0.2},
+ 'text_formula': text_formula_config,
+ }
+ p2t = Pix2Text.from_config(total_configs=total_config)
+ outs = p2t.recognize_page(
+ img_fp,
+ resized_shape=608,
+ page_id='test_page_2',
+ save_layout_res='./layout_res-mixed.jpg',
+ ) # 也可以使用 `p2t(img_fp)` 获得相同的结果
+ print(outs)
+
+
+def test_blog_pro_example():
+ img_fp = './docs/examples/mixed.jpg'
+
+ text_formula_config = dict(
+ languages=('en', 'ch_sim'),
+ mfd=dict( # 声明 MFD 的初始化参数
+ model_path=os.path.expanduser(
+ '~/.pix2text/1.1/mfd-onnx/mfd-v20240618.onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ formula=dict(
+ model_name='mfr-pro',
+ model_backend='onnx',
+ model_dir=os.path.expanduser(
+ '~/.pix2text/1.1/mfr-pro-onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ text=dict(
+ rec_model_name='doc-densenet_lite_666-gru_large',
+ rec_model_backend='onnx',
+ rec_model_fp=os.path.expanduser(
+ '~/.cnocr/2.3/doc-densenet_lite_666-gru_large/cnocr-v2.3-doc-densenet_lite_666-gru_large-epoch=005-ft-model.onnx'
+ # noqa
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ )
+ p2t = Pix2Text.from_config(total_configs={'text_formula': text_formula_config})
+ outs = p2t.recognize_page(
+ img_fp, resized_shape=608, page_id='test_page_3'
+ ) # 也可以使用 `p2t(img_fp)` 获得相同的结果
+ print(outs)
+
+
+def test_example_mixed():
+ img_fp = './docs/examples/en1.jpg'
+ p2t = Pix2Text.from_config()
+ outs = p2t.recognize_page(
+ img_fp, resized_shape=608, page_id='test_page_4'
+ ) # 也可以使用 `p2t(img_fp)` 获得相同的结果
+ print(outs)
+
+
+def test_example_formula():
+ img_fp = './docs/examples/math-formula-42.png'
+ p2t = Pix2Text.from_config()
+ outs = p2t.recognize_formula(img_fp)
+ print(outs)
+
+
+def test_example_text():
+ img_fp = './docs/examples/general.jpg'
+ p2t = Pix2Text(enable_formula=False)
+ outs = p2t.recognize_text(img_fp)
+ print(outs)
+
+
+def test_vlm_recognize_page():
+ import dotenv
+ dotenv.load_dotenv()
+
+ model_name=os.getenv("GEMINI_MODEL")
+ api_key=os.getenv("GEMINI_API_KEY")
+
+ # img_fp = './docs/examples/formula.jpg'
+ # img_fp = './docs/examples/page2.png'
+ img_fp = './docs/examples/mixed.jpg'
+ total_config = {
+ 'layout': None,
+ 'text_formula': {
+ "model_type": "VlmTextFormulaOCR",
+ "model_name": model_name,
+ "api_key": api_key,
+ },
+ "table": {
+ "model_type": "VlmTableOCR",
+ "model_name": model_name,
+ "api_key": api_key,
+ },
+ }
+ p2t = Pix2Text.from_config(total_configs=total_config)
+ tf_out = p2t.recognize_text_formula(img=img_fp, resized_shape=768, return_text=False)
+ print(tf_out)
+ # out_page = p2t.recognize_page(
+ # img_fp,
+ # page_id='test_page_1',
+ # title_contain_formula=False,
+ # text_contain_formula=True,
+ # save_debug_res='./outputs',
+ # )
+ # print(out_page)
+ # out_page.to_markdown('page-output')
+
+
+def test_multilingual_ocr():
+ img_fp = 'docs/examples/vietnamese.jpg'
+ img_fp = 'docs/feedbacks/ru.png'
+ total_config = {
+ "layout": {},
+ "text_formula": {"languages": ("ru",)},
+ }
+ p2t = Pix2Text.from_config(total_configs=total_config)
+ outs = p2t.recognize(
+ img_fp, file_type="text_formula", return_text=True, auto_line_break=False
+ )
+ print(outs)
diff --git a/tests/test_post_processors.py b/tests/test_post_processors.py
new file mode 100644
index 0000000000000000000000000000000000000000..3bb700c54d3eab1afd1388c6f080833142ba4b35
--- /dev/null
+++ b/tests/test_post_processors.py
@@ -0,0 +1,86 @@
+# coding: utf-8
+from pix2text.latex_ocr import *
+
+
+def test_remove_redundant_script():
+ latex_strs = [
+ ('^ { abc }', 'abc'),
+ ('^ { { a + b } }', '{ a + b }'),
+ ('_ { abc }', 'abc'),
+ ('_ { { a + b } }', '{ a + b }'),
+ ('\\sum _ { t = 1 } ^ { T }', '\\sum _ { t = 1 } ^ { T }'),
+ ]
+
+ for ori, res in latex_strs:
+ assert remove_redundant_script(ori) == res
+
+
+def test_remove_empty_text():
+ latex_strs = [
+ (
+ 'J _ { \\stackrel { \\arraycolsep } { 0 p t } { G } } ^ { }',
+ 'J _ { \\stackrel { \\arraycolsep } { 0 p t } { G } }',
+ ),
+ ('\\hat { }', ''),
+ ('\\hat { } _ { } : h = 0. 5', ': h = 0. 5'),
+ ('\\sum _ { t = 1 } ^ { T }', '\\sum _ { t = 1 } ^ { T }'),
+ ]
+
+ for ori, res in latex_strs:
+ assert remove_empty_text(ori) == res
+
+
+def test_remove_trailing_whitespace():
+ latex_strs = [
+ ('abc \\qquad \\qquad \\qquad', 'abc'),
+ ('abc \\qquad \\quad \\qquad', 'abc'),
+ ('abc \\qquad \\ \\quad \\qquad', 'abc'),
+ ('abc \\, \\, \\, \\, \\, \\, \\,', 'abc'),
+ ('f ^ { \\prime } \\ = \\ \\ ', 'f ^ { \\prime } \\ ='),
+ ('\\sum _ { t = 1 } ^ { T }', '\\sum _ { t = 1 } ^ { T }'),
+ ]
+
+ for ori, res in latex_strs:
+ assert remove_trailing_whitespace(ori) == res
+
+
+def test_remove_unnecessary_spaces():
+ latex_strs = [
+ ('{ \\cal L }', '{\\cal L}'), # 保留命令后紧跟大写字母的空格
+ ('\\textbf {bold text}', '\\textbf{bold text}'), # 移除命令后的空格
+ ('a + b = c', 'a+b=c'), # 数学模式内的空格被移除
+ ('\\frac{ 1 }{ 2 }', '\\frac{1}{2}'), # 移除大括号内的空格
+ ('\\sum_{ i = 1 }^{ N }', '\\sum_{i=1}^{N}'), # 移除下标和上标中的空格
+ ('\\alpha \\, \\beta', '\\alpha\\, \\beta'), # 保留显式间距调整命令的空格
+ ('\\sqrt { x } + \\sqrt { y }', '\\sqrt{x}+\\sqrt{y}'), # 移除大括号内的空格，保留操作符周围的空格
+ ('\\textit {italic text} with space', '\\textit{italic text} with space'), # 移除命令后的空格，保留文本中的空格
+ ('\\mathrm { a b c }', '\\mathrm{a b c}'), # 移除命令后的空格
+ ('\\sum _ {t=1} ^ {T} 4 _ { 2 }', '\\sum_{t=1}^{T} 4_{2}'),
+ ('\\sim q ( z | x )', '\\sim q ( z | x )'),
+ ]
+
+ for ori, res in latex_strs:
+ assert remove_unnecessary_spaces(ori) == res
+
+
+def test_fix_latex():
+ latex_strs = [
+ ('\\left \\frac{1}{2}', '\\frac{1}{2}'),
+ ('\\left ( \\frac{1}{2} + \\left \\frac{1}{2} \\right )', '\\left ( \\frac{1}{2} + \\frac{1}{2} \\right )'),
+ ('\\left( \\frac{1}{2} + \\left \\frac{1}{2} \\right)', '\\left( \\frac{1}{2} + \\frac{1}{2} \\right)'),
+ ]
+
+ for ori, res in latex_strs:
+ assert fix_latex(ori) == res
+
+
+def test_replace_illegal_symbols():
+ latex_strs = [
+ (r'a^2 \.', r'a^2 \ .'),
+ (r'a^2 \= \.', r'a^2 \ = \ .'),
+ (r'a^2 \- \.', r'a^2 \ - \ .'),
+ (r'a^2 \~ \.', r'a^2 \ ~ \ .'),
+ ]
+
+ for ori, res in latex_strs:
+ assert replace_illegal_symbols(ori) == res
\ No newline at end of file
diff --git a/tests/test_sort_boxes.py b/tests/test_sort_boxes.py
new file mode 100644
index 0000000000000000000000000000000000000000..10c6549a37eaece55477393b2c2d9190ea7c1d1c
--- /dev/null
+++ b/tests/test_sort_boxes.py
@@ -0,0 +1,56 @@
+# coding: utf-8
+import random
+from pprint import pprint
+import numpy as np
+
+from pix2text.utils import sort_and_filter_line_boxes, sort_boxes
+
+
+def list2box(xmin, ymin, xmax, ymax):
+ return np.array([[xmin, ymin], [xmax, ymin], [xmax, ymax], [xmin, ymax]])
+
+
+def test_sort_line_boxes():
+ boxes = [
+ {'position': list2box(20, 0, 30, 25), 'id': 12}, # anchor，不能动
+ {'position': list2box(0, 5, 20, 20), 'id': 11},
+ {'position': list2box(30, 5, 40, 18), 'id': 13},
+ {'position': list2box(38, 5, 60, 20), 'id': 14},
+ {'position': list2box(21, 20, 40, 30), 'id': 22},
+ ]
+ for box in boxes:
+ box['__line__'] = -1 # 所在行号，-1表示未分配
+ boxes[0]['__line__'] = 1
+ # random.shuffle(boxes)
+ outs = sort_and_filter_line_boxes(boxes, 'position')
+ pprint(outs)
+
+
+def test_sort_boxes():
+ boxes = [
+ {'position': list2box(0, 5, 20, 20), 'id': 11},
+ {'position': list2box(30, 5, 40, 18), 'id': 13},
+ {'position': list2box(38, 5, 60, 20), 'id': 14},
+ {'position': list2box(20, 0, 30, 25), 'id': 12},
+ {'position': list2box(0, 25, 20, 45), 'id': 21},
+ {'position': list2box(40, 25, 60, 44), 'id': 23},
+ {'position': list2box(21, 20, 40, 30), 'id': 22},
+ {'position': list2box(2, 85, 30, 105), 'id': 41},
+ {'position': list2box(10, 55, 50, 80), 'id': 31},
+ {'position': list2box(35, 83, 58, 103), 'id': 42},
+ ]
+
+ line_boxes = sort_boxes(boxes, 'position')
+ pprint(line_boxes)
+
+ line_ids = []
+ for boxes in line_boxes:
+ line_ids.append([box['id'] for box in boxes])
+
+ pprint(line_ids)
+ assert line_ids == [
+ [11, 12, 13, 14],
+ [21, 22, 23],
+ [31],
+ [41, 42],
+ ]
diff --git a/tests/test_table_ocr.py b/tests/test_table_ocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ba7e5e1da833180edb2feea08dbcab16a6f871a
--- /dev/null
+++ b/tests/test_table_ocr.py
@@ -0,0 +1,44 @@
+# coding: utf-8
+import pytest
+import os
+
+from pix2text.ocr_engine import prepare_ocr_engine
+from pix2text.table_ocr import TableOCR
+
+
+def test_recognize():
+ image_path = 'docs/examples/table3.jpg'
+ os.environ['HF_ENDPOINT'] = os.getenv('HF_ENDPOINT', 'https://hf-mirror.com')
+ languages = ('en', 'ch_sim')
+ text_ocr = prepare_ocr_engine(languages, {})
+ ocr = TableOCR(text_ocr=text_ocr)
+ result = ocr.recognize(
+ image_path,
+ out_csv=True,
+ out_cells=True,
+ out_objects=False,
+ out_html=True,
+ out_markdown=True,
+ save_analysis_res='out-table-rec.png',
+ )
+
+ print(result)
+
+
+def test_recognize2():
+ image_path = 'docs/examples/table3.jpg'
+ os.environ['HF_ENDPOINT'] = os.getenv('HF_ENDPOINT', 'https://hf-mirror.com')
+ languages = ('en', 'ch_sim')
+ text_ocr = prepare_ocr_engine(languages, {})
+ ocr = TableOCR.from_config(text_ocr=text_ocr)
+ result = ocr.recognize(
+ image_path,
+ out_csv=True,
+ out_cells=True,
+ out_objects=False,
+ out_html=True,
+ out_markdown=True,
+ save_analysis_res='out-table-rec.png',
+ )
+
+ print(result)
diff --git a/tests/test_text_formula_ocr.py b/tests/test_text_formula_ocr.py
new file mode 100644
index 0000000000000000000000000000000000000000..21c12fcb5f4eb7b50f94ec0e737ab9269118003d
--- /dev/null
+++ b/tests/test_text_formula_ocr.py
@@ -0,0 +1,121 @@
+# coding: utf-8
+
+import os
+
+from pix2text import TextFormulaOCR, merge_line_texts
+
+
+def test_mfd():
+ config = dict()
+ model = TextFormulaOCR.from_config(config)
+
+ res = model.recognize(
+ './docs/examples/zh1.jpg', save_analysis_res='./analysis_res.jpg',
+ )
+ print(res)
+
+
+def test_example():
+ # img_fp = './docs/examples/formula.jpg'
+ img_fp = './docs/examples/mixed.jpg'
+ formula_config = {
+ 'model_name': 'mfr-pro',
+ 'model_backend': 'onnx',
+ }
+ p2t = TextFormulaOCR.from_config(total_configs={'formula': formula_config})
+ print(p2t.recognize(img_fp))
+ # print(p2t.recognize_formula(img_fp))
+ # outs = p2t(img_fp, resized_shape=608, save_analysis_res='./analysis_res.jpg') # can also use `p2t.recognize(img_fp)`
+ # print(outs)
+ # # To get just the text contents, use:
+ # only_text = merge_line_texts(outs, auto_line_break=True)
+ # print(only_text)
+
+
+def test_blog_example():
+ img_fp = './docs/examples/mixed.jpg'
+
+ total_config = dict(
+ mfd=dict( # 声明 MFD 的初始化参数
+ model_path=os.path.expanduser(
+ '~/.pix2text/1.1/mfd-onnx/mfd-v20240618.onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ formula=dict(
+ model_name='mfr-pro',
+ model_backend='onnx',
+ model_dir=os.path.expanduser(
+ '~/.pix2text/1.1/mfr-pro-onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ )
+ p2t = TextFormulaOCR.from_config(total_configs=total_config)
+ outs = p2t.recognize(
+ img_fp, resized_shape=608, return_text=False
+ ) # 也可以使用 `p2t(img_fp)` 获得相同的结果
+ print(outs)
+ # 如果只需要识别出的文字和Latex表示，可以使用下面行的代码合并所有结果
+ only_text = merge_line_texts(outs, auto_line_break=True)
+ print(only_text)
+
+
+def test_blog_pro_example():
+ img_fp = './docs/examples/mixed.jpg'
+
+ total_config = dict(
+ languages=('en', 'ch_sim'),
+ mfd=dict( # 声明 MFD 的初始化参数
+ model_path=os.path.expanduser(
+ '~/.pix2text/1.1/mfd-onnx/mfd-v20240618.onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ formula=dict(
+ model_name='mfr-pro',
+ model_backend='onnx',
+ model_dir=os.path.expanduser(
+ '~/.pix2text/1.1/mfr-pro-onnx'
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ text=dict(
+ rec_model_name='doc-densenet_lite_666-gru_large',
+ rec_model_backend='onnx',
+ rec_model_fp=os.path.expanduser(
+ '~/.cnocr/2.3/doc-densenet_lite_666-gru_large/cnocr-v2.3-doc-densenet_lite_666-gru_large-epoch=005-ft-model.onnx'
+ # noqa
+ ), # 注：修改成你的模型文件所存储的路径
+ ),
+ )
+ p2t = TextFormulaOCR.from_config(total_configs=total_config)
+ outs = p2t.recognize(
+ img_fp, resized_shape=608, return_text=False
+ ) # 也可以使用 `p2t(img_fp)` 获得相同的结果
+ print(outs)
+ # 如果只需要识别出的文字和Latex表示，可以使用下面行的代码合并所有结果
+ only_text = merge_line_texts(outs, auto_line_break=True)
+ print(only_text)
+
+
+def test_example_mixed():
+ img_fp = './docs/examples/en1.jpg'
+ p2t = TextFormulaOCR.from_config()
+ outs = p2t.recognize(
+ img_fp, resized_shape=608, return_text=False
+ ) # 也可以使用 `p2t(img_fp)` 获得相同的结果
+ print(outs)
+ # 如果只需要识别出的文字和Latex表示，可以使用下面行的代码合并所有结果
+ only_text = merge_line_texts(outs, auto_line_break=True)
+ print(only_text)
+
+
+def test_example_formula():
+ img_fp = './docs/examples/math-formula-42.png'
+ p2t = TextFormulaOCR.from_config()
+ outs = p2t.recognize_formula(img_fp)
+ print(outs)
+
+
+def test_example_text():
+ img_fp = './docs/examples/general.jpg'
+ p2t = TextFormulaOCR()
+ outs = p2t.recognize_text(img_fp)
+ print(outs)
diff --git a/tests/test_utils_img.py b/tests/test_utils_img.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccd14b962fb305b77ce3ee4002a108fc5811389c
--- /dev/null
+++ b/tests/test_utils_img.py
@@ -0,0 +1,172 @@
+# coding: utf-8
+import os
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import pytest
+from PIL import Image
+
+from pix2text.utils import convert_transparent_to_contrasting
+
+
+def create_rgba_image(width=100, height=100, bg_color=(255, 0, 0, 0), fg_color=(0, 0, 255, 255)):
+ """Create a test RGBA image with transparent background and some foreground content."""
+ # Create a fully transparent image
+ img = Image.new('RGBA', (width, height), bg_color)
+
+ # Add some non-transparent content in center
+ pixels = img.load()
+ for i in range(width//4, 3*width//4):
+ for j in range(height//4, 3*height//4):
+ pixels[i, j] = fg_color
+
+ return img
+
+
+def create_la_image(width=100, height=100, bg_value=0, fg_value=255):
+ """Create a test LA (grayscale with alpha) image."""
+ # Create a fully transparent image
+ img = Image.new('LA', (width, height), (bg_value, 0))
+
+ # Add some non-transparent content in center
+ pixels = img.load()
+ for i in range(width//4, 3*width//4):
+ for j in range(height//4, 3*height//4):
+ pixels[i, j] = (fg_value, 255)
+
+ return img
+
+
+def create_p_image_with_transparency(width=100, height=100):
+ """Create a test palette mode (P) image with transparency."""
+ # Start with an RGBA image
+ rgba = create_rgba_image(width, height)
+
+ # Convert to palette mode with transparency
+ p_img = rgba.convert('P')
+
+ # Set transparency
+ p_img.info['transparency'] = 0
+
+ return p_img
+
+
+def create_rgb_image(width=100, height=100, color=(100, 150, 200)):
+ """Create a test RGB image."""
+ return Image.new('RGB', (width, height), color)
+
+
+def test_convert_rgba_transparent():
+ """Test converting an RGBA image with transparency."""
+ # Create test image
+ img = create_rgba_image()
+
+ # Apply the function
+ result = convert_transparent_to_contrasting(img)
+
+ # Verify the result
+ assert result.mode == 'RGB', "Result should be in RGB mode"
+ assert result.size == img.size, "Image dimensions should not change"
+
+ # Convert to numpy array to check pixel values
+ result_array = np.array(result)
+
+ # The background (originally transparent) should now have a contrasting color
+ # to the blue foreground we set in create_rgba_image
+ bg_sample = result_array[5, 5] # Sample from corner (background)
+ fg_sample = result_array[50, 50] # Sample from center (foreground)
+
+ # Make sure background and foreground are different
+ assert not np.array_equal(bg_sample, fg_sample), "Background should have different color than foreground"
+
+
+def test_convert_la_transparent():
+ """Test converting an LA (grayscale with alpha) image with transparency."""
+ img = create_la_image()
+ result = convert_transparent_to_contrasting(img)
+
+ assert result.mode == 'RGB', "Result should be in RGB mode"
+ assert result.size == img.size, "Image dimensions should not change"
+
+
+def test_convert_p_with_transparency():
+ """Test converting a palette image with transparency."""
+ img = create_p_image_with_transparency()
+ result = convert_transparent_to_contrasting(img)
+
+ assert result.mode == 'RGB', "Result should be in RGB mode"
+ assert result.size == img.size, "Image dimensions should not change"
+
+
+def test_convert_rgb_no_transparency():
+ """Test converting an RGB image (no transparency)."""
+ # For RGB images, we just expect a converted copy
+ img = create_rgb_image()
+ result = convert_transparent_to_contrasting(img)
+
+ assert result.mode == 'RGB', "Result should be in RGB mode"
+ assert result.size == img.size, "Image dimensions should not change"
+
+ # The image should look the same as input (just ensured to be RGB)
+ img_rgb = img.convert('RGB')
+ assert np.array_equal(np.array(result), np.array(img_rgb)), "RGB image should not change visually"
+
+
+def test_end_to_end():
+ """
+ Test the full workflow: create image, save it, read it, convert it,
+ then check the result matches expectations.
+ """
+ # Create a temporary directory
+ with tempfile.TemporaryDirectory() as tmp_dir:
+ # Create and save a test image
+ test_path = os.path.join(tmp_dir, "test_transparent.png")
+ img = create_rgba_image()
+ img.save(test_path)
+
+ # Read the image back and convert it
+ img_reopened = Image.open(test_path)
+ result = convert_transparent_to_contrasting(img_reopened)
+
+ # Verify results
+ assert result.mode == 'RGB', "Result should be in RGB mode"
+ assert result.size == img.size, "Image dimensions should not change"
+
+ # Save the result for comparison (optional)
+ result_path = os.path.join(tmp_dir, "test_result.jpg")
+ result.save(result_path)
+
+
+def test_edge_cases():
+ """Test edge cases like extremely small images or unusual color patterns."""
+ # Test a 1x1 pixel transparent image
+ tiny_image = Image.new('RGBA', (1, 1), (255, 0, 0, 0))
+ result = convert_transparent_to_contrasting(tiny_image)
+ assert result.mode == 'RGB', "Result should be in RGB mode"
+ assert result.size == (1, 1), "Image dimensions should not change"
+
+ # Test a fully transparent image with no content
+ empty_image = Image.new('RGBA', (50, 50), (0, 0, 0, 0))
+ result = convert_transparent_to_contrasting(empty_image)
+ assert result.mode == 'RGB', "Result should be in RGB mode"
+
+ # Test an image with partially transparent pixels
+ partial_img = Image.new('RGBA', (50, 50), (0, 0, 0, 0))
+ pixels = partial_img.load()
+ for i in range(50):
+ for j in range(50):
+ pixels[i, j] = (255, 0, 0, i % 255) # Varying alpha values
+ result = convert_transparent_to_contrasting(partial_img)
+ assert result.mode == 'RGB', "Result should be in RGB mode"
+
+
+if __name__ == "__main__":
+ # Run tests manually if needed
+ test_convert_rgba_transparent()
+ test_convert_la_transparent()
+ test_convert_p_with_transparency()
+ test_convert_rgb_no_transparency()
+ test_end_to_end()
+ test_edge_cases()
+ print("All tests passed!")
diff --git a/tests/test_vlm.py b/tests/test_vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bf7a17e994b534dba02c9e7da63907185b630c3
--- /dev/null
+++ b/tests/test_vlm.py
@@ -0,0 +1,70 @@
+# coding=utf-8
+import os
+import dotenv
+
+from pix2text import set_logger
+from pix2text.vlm_api import Vlm
+from pix2text.vlm_table_ocr import VlmTableOCR
+from pix2text.text_formula_ocr import VlmTextFormulaOCR
+
+logger = set_logger()
+# Load environment variables from .env file
+dotenv.load_dotenv()
+
+
+def init_vlm():
+ GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+ GEMINI_MODEL = os.getenv("GEMINI_MODEL")
+
+ return Vlm(
+ model_name=GEMINI_MODEL,
+ api_key=GEMINI_API_KEY,
+ )
+
+
+def test_vlm_api():
+ img_path = "/Users/king/Documents/WhatIHaveDone/Test/pix2text/docs/feedbacks/2024-09-09.jpg"
+ img_path = "/Users/king/Documents/WhatIHaveDone/Test/pix2text/docs/examples/table-cn.jpg" # 表格，中文
+ img_path = "/Users/king/Documents/WhatIHaveDone/Test/pix2text/docs/examples/ch_tra1.jpg" # 繁体中文
+ # img_path = "/Users/king/Documents/WhatIHaveDone/Test/pix2text/docs/examples/hw-formula5.jpg" # 手写公式
+ img_path = "docs/examples/hw-zh-en.jpg" # 手写文字
+ img_path = "docs/examples/hw-zh1.jpg" # 手写文字
+ img_path = "docs/examples/hw-zh2.jpg" # 手写文字
+ img_path = "docs/examples/hw-zh3.jpg" # 手写文字
+ img_path = ["docs/examples/hw-zh1.jpg", "docs/examples/hw-zh3.jpg"] # 手写文字
+
+ vlm = init_vlm()
+ result = vlm(img_path, auto_resize=True)
+
+ # Print the result
+ print(result)
+
+
+def test_vlm_table_ocr():
+ img_path = "/Users/king/Documents/WhatIHaveDone/Test/pix2text/docs/examples/table-cn.jpg" # 表格，中文
+
+ vlm_table_ocr = VlmTableOCR.from_config(
+ model_name=os.getenv("GEMINI_MODEL"),
+ api_key=os.getenv("GEMINI_API_KEY"),
+ )
+ result = vlm_table_ocr.recognize(img_path)
+
+ # Print the result
+ print(result)
+
+
+def test_vlm_text_formula_ocr():
+ # img_path = "docs/examples/vietnamese.jpg"
+ img_path = "docs/examples/mixed.jpg"
+ img_path = "docs/examples/ch_tra1.jpg"
+
+ vlm_text_formula_ocr = VlmTextFormulaOCR.from_config(
+ model_name=os.getenv("GEMINI_MODEL"),
+ api_key=os.getenv("GEMINI_API_KEY"),
+ enable_spell_checker=False,
+ )
+ result = vlm_text_formula_ocr.recognize(img_path, resized_shape=768, return_text=False)
+
+ # Print the result
+ print("识别结果:")
+ print(result)
\ No newline at end of file
+ 
+
+
+
+
+
+
+
'
+
+ except Exception as e:
+ img_html = f'Error: {os.path.basename(img_path)}'
+ else:
+ img_html = f'Not Found: {os.path.basename(img_path) if img_path else "No path"}'
+
+ # Get text values
+ gt_text = result.get(gt_key, '').replace('\n', '