Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,12 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+axmodel/ax650/cls_npu1.axmodel filter=lfs diff=lfs merge=lfs -text
+axmodel/ax650/cls_npu3.axmodel filter=lfs diff=lfs merge=lfs -text
+axmodel/ax650/det_npu1.axmodel filter=lfs diff=lfs merge=lfs -text
+axmodel/ax650/det_npu3.axmodel filter=lfs diff=lfs merge=lfs -text
+axmodel/ax650/rec_npu1.axmodel filter=lfs diff=lfs merge=lfs -text
+axmodel/ax650/rec_npu3.axmodel filter=lfs diff=lfs merge=lfs -text
+fonts/simfang.ttf filter=lfs diff=lfs merge=lfs -text
+res-ax.jpg filter=lfs diff=lfs merge=lfs -text
+res-onnx.jpg filter=lfs diff=lfs merge=lfs -text

README-zh.md

@@ -0,0 +1,186 @@
+---
+license: mit
+language:
+- zh
+base_model:
+- PP-OCRv6_mobile_det
+- PP-OCRv6_mobile_rec
+- PP-LCNet_x0_25_textline_ori
+pipeline_tag: text-classification
+tags:
+- OCR
+- paddle
+- PPOCRv6
+- axera
+---
+
+# PPOCR_v6
+> [English](./README.md) | 中文
+
+本版本 PPOCR_v6 已转换为可在爱芯 NPU 上运行的模型，采用 **w8a16** 量化。
+
+## 转换工具链接
+
+如果您对模型转换感兴趣，可以通过以下链接导出 axmodel：
+
+- [ax-samples-github](https://github.com/AXERA-TECH/ax-samples)，其他好玩的样例
+
+- [Pulsar2 文档，ONNX 转 axmodel 方法](https://pulsar2-docs.readthedocs.io/en/latest/pulsar2/introduction.html)
+
+## 支持平台
+
+- AX650
+  - [M4N-Dock(爱芯派Pro)](https://wiki.sipeed.com/hardware/zh/maixIV/m4ndock/m4ndock.html)
+  - [M.2 加速卡](https://axcl-docs.readthedocs.io/zh-cn/latest/doc_guide_hardware.html)
+- AX630C
+  - [爱芯派2](https://axera-pi-2-docs-cn.readthedocs.io/zh-cn/latest/index.html)
+  - [Module-LLM](https://docs.m5stack.com/zh_CN/module/Module-LLM)
+  - [LLM630 Compute Kit](https://docs.m5stack.com/zh_CN/core/LLM630%20Compute%20Kit)
+- AX615
+  - [AX615 IPC SoC](https://www.axera-tech.com/zh-hans/product/2956.html)
+  
+
+### 性能测试
+
+|芯片|模型|npu_mode|耗时(ms)|
+|--|--|--|--|
+||PP-OCRv6_small_det|NPU1|42.158|
+||PP-OCRv6_small_det|NPU3|23.837|
+|AX650|PP-LCNet_x0_25_textline_ori|NPU1|0.294|
+||PP-LCNet_x0_25_textline_ori|NPU3|0.172|
+||PP-OCRv6_small_rec|NPU1|2.473|
+||PP-OCRv6_small_rec|NPU3|1.073|
+
+测试方案：
+
+``` bash
+ax_run_model -w 10 -r 100 -m xx.axmodel
+```
+
+识别和检测的onnx模型来源：[PaddlePaddle/PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocrv6) 中 [small-det-onnx](https://huggingface.co/PaddlePaddle/PP-OCRv6_small_det_onnx) 和 [small-rec-onnx](https://huggingface.co/PaddlePaddle/PP-OCRv6_small_rec_onnx)
+方向分类器：[AXERA-TECH/PPOCR_v5](https://huggingface.co/AXERA-TECH/PPOCR_v5/tree/main/onnx)
+
+## 使用说明
+
+将本仓库所有文件下载到设备中
+
+```
+PPOCR_v6# tree -L 1
+.
+|-- 11.jpg          # 测试图
+|-- README-zh.md
+|-- README.md
+|-- axmodel         # 各个版本的axmodel
+|-- cls.json        # 方向分类模型转换axmodel配置文件
+|-- dataset         # 量化数据集 与 测试数据集
+|-- det.json        # 检测模型转换axmodel配置文件
+|-- fonts           # 绘制字体
+|-- onnx            # 各模型的原始onnx文件
+|-- ppocrv6_ax.py   # axmodel运行pipeline
+|-- ppocrv6_onnx.py # onnx运行pipeline
+|-- rec.json        # 识别模型转换axmodel配置文件
+|-- res-ax.jpg      # axmodel运行结果
+|-- res-onnx.jpg    # onnx运行结果
+|-- run_det_ax.py   # 检测axmodel模型准确率测试文件
+|-- run_det_onnx.py # 检测onnx模型准确率测试文件
+|-- run_rec_ax.py   # 识别axmodel模型准确率测试文件
+`-- run_rec_onnx.py # 识别onnx模型准确率测试文件
+```
+
+### 转换
+```
+cd dataset 
+sh download_quant_dataset.sh
+sh download_val_dataset.sh
+cd ..
+pulsar2 build --config det.json 
+pulsar2 build --config cls.json 
+pulsar2 build --config rec.json 
+
+```
+
+### 测试
+
+#### 检测
+
+``` python
+python3 run_det_onnx.py --resize_mode letterbox   # resize_mode可选：letterbox(默认)、stretch(官方)
+"""
+  Images:       50
+  GT boxes:     201
+  DET boxes:    151
+  Matched:      77
+  Precision:    0.5099 (50.99%)
+  Recall:       0.3831 (38.31%)
+  Hmean (F1):   0.4375
+"""
+python3 run_det_ax.py --resize_mode letterbox   # resize_mode可选：letterbox(默认)、stretch(官方)
+"""
+  Images:       50
+  GT boxes:     201
+  DET boxes:    150
+  Matched:      75
+  Precision:    0.5000 (50.00%)
+  Recall:       0.3731 (37.31%)
+  Hmean (F1):   0.4274
+"""
+```
+
+注：`resize_mode`为`stretch`时，为官方做法，直接`resize`到模型输入大小；`letterbox`为右下角填充，与动态输入的`onnx`差距较小，在本项测试中指标较优。可下载 [small-det-onnx](https://huggingface.co/PaddlePaddle/PP-OCRv6_small_det_onnx) 中动态输入 `shape` 的 `inference.onnx` 进行对比。
+
+#### 识别
+
+``` python
+python3 run_rec_onnx.py
+"""
+  Total samples:         2077
+  Correct (exact match): 1563
+  Accuracy:              0.7525 (75.25%)
+  Norm Edit Distance:    0.8947
+"""
+python3 run_rec_ax.py
+"""
+  Total samples:         2077
+  Correct (exact match): 1518
+  Accuracy:              0.7309 (73.09%)
+  Norm Edit Distance:    0.8781
+"""
+```
+
+### 推理
+
+在 AX650 主机上推理，如 M4N-Dock(爱芯派Pro)
+
+输入图片：
+![input](./11.jpg)
+
+
+
+``` python
+python3 ppocrv6_onnx.py --use_angle_cls --visualize --image 11.jpg
+python3 ppocrv6_ax.py --use_angle_cls --visualize --image 11.jpg
+```
+
+输出图片：
+![output](./res-ax.jpg)
+
+### 其他
+`tiny`的识别模型量化误差较大，指标如下：
+```
+onnx-preds:
+  Total samples:         2077
+  Correct (exact match): 1271
+  Accuracy:              0.6119 (61.19%)
+  Norm Edit Distance:    0.8263
+
+ax-w8a16-preds:
+  Total samples:         2077
+  Correct (exact match): 1178
+  Accuracy:              0.5672 (56.72%)
+  Norm Edit Distance:    0.7941
+```
+
+#### TODO
+
+- ax620性能测试
+- ax615性能测试

README.md

@@ -1,3 +1,185 @@
 ---
-license: apache-2.0
+license: mit
+language:
+- en
+base_model:
+- PP-OCRv6_mobile_det
+- PP-OCRv6_mobile_rec
+- PP-LCNet_x0_25_textline_ori
+pipeline_tag: text-classification
+tags:
+- OCR
+- paddle
+- PPOCRv6
+- axera
 ---
+
+# PPOCR_v6
+> English | [中文](./README-zh.md)
+
+This version of PPOCR_v6 has been converted to run on AXERA NPU with **w8a16** quantization.
+
+## Conversion Tool Links
+
+If you are interested in model conversion, you can export axmodel through the following links:
+
+- [ax-samples-github](https://github.com/AXERA-TECH/ax-samples), other interesting samples
+
+- [Pulsar2 Documentation, ONNX to axmodel conversion](https://pulsar2-docs.readthedocs.io/en/latest/pulsar2/introduction.html)
+
+## Supported Platforms
+
+- AX650
+  - [M4N-Dock (AXERA Pi Pro)](https://wiki.sipeed.com/hardware/zh/maixIV/m4ndock/m4ndock.html)
+  - [M.2 Accelerator Card](https://axcl-docs.readthedocs.io/zh-cn/latest/doc_guide_hardware.html)
+- AX630C
+  - [AXERA Pi 2](https://axera-pi-2-docs-cn.readthedocs.io/zh-cn/latest/index.html)
+  - [Module-LLM](https://docs.m5stack.com/zh_CN/module/Module-LLM)
+  - [LLM630 Compute Kit](https://docs.m5stack.com/zh_CN/core/LLM630%20Compute%20Kit)
+- AX615
+  - [AX615 IPC SoC](https://www.axera-tech.com/zh-hans/product/2956.html)
+
+### Performance Benchmarks
+
+| Chip  | Model                           | npu_mode | Latency (ms) |
+| ----- | ------------------------------- | -------- | ------------ |
+|       | PP-OCRv6_small_det              | NPU1     | 42.158       |
+|       | PP-OCRv6_small_det              | NPU3     | 23.837       |
+| AX650 | PP-LCNet_x0_25_textline_ori     | NPU1     | 0.294        |
+|       | PP-LCNet_x0_25_textline_ori     | NPU3     | 0.172        |
+|       | PP-OCRv6_small_rec              | NPU1     | 2.473        |
+|       | PP-OCRv6_small_rec              | NPU3     | 1.073        |
+
+Benchmarking command:
+
+``` bash
+ax_run_model -w 10 -r 100 -m xx.axmodel
+```
+
+Recognition and detection ONNX model sources: [small-det-onnx](https://huggingface.co/PaddlePaddle/PP-OCRv6_small_det_onnx) and [small-rec-onnx](https://huggingface.co/PaddlePaddle/PP-OCRv6_small_rec_onnx) from [PaddlePaddle/PP-OCRv6](https://huggingface.co/collections/PaddlePaddle/pp-ocrv6)
+
+Text direction classifier: [AXERA-TECH/PPOCR_v5](https://huggingface.co/AXERA-TECH/PPOCR_v5/tree/main/onnx)
+
+## Usage
+
+Download all files from this repository to your device.
+
+```
+PPOCR_v6# tree -L 1
+.
+|-- 11.jpg          # Test image
+|-- README-zh.md
+|-- README.md
+|-- axmodel         # Axmodel files for each version
+|-- cls.json        # Text direction classifier axmodel conversion config
+|-- dataset         # Quantization dataset & test dataset
+|-- det.json        # Detection model axmodel conversion config
+|-- fonts           # Rendering fonts
+|-- onnx            # Original ONNX files for each model
+|-- ppocrv6_ax.py   # Axmodel inference pipeline
+|-- ppocrv6_onnx.py # ONNX inference pipeline
+|-- rec.json        # Recognition model axmodel conversion config
+|-- res-ax.jpg      # Axmodel inference result
+|-- res-onnx.jpg    # ONNX inference result
+|-- run_det_ax.py   # Detection axmodel accuracy test script
+|-- run_det_onnx.py # Detection ONNX accuracy test script
+|-- run_rec_ax.py   # Recognition axmodel accuracy test script
+`-- run_rec_onnx.py # Recognition ONNX accuracy test script
+```
+
+### Conversion
+```
+cd dataset 
+sh download_quant_dataset.sh
+sh download_val_dataset.sh
+cd ..
+pulsar2 build --config det.json 
+pulsar2 build --config cls.json 
+pulsar2 build --config rec.json 
+
+```
+
+### Testing
+
+#### Detection
+
+``` python
+python3 run_det_onnx.py --resize_mode letterbox   # resize_mode options: letterbox (default), stretch (official)
+"""
+  Images:       50
+  GT boxes:     201
+  DET boxes:    151
+  Matched:      77
+  Precision:    0.5099 (50.99%)
+  Recall:       0.3831 (38.31%)
+  Hmean (F1):   0.4375
+"""
+python3 run_det_ax.py --resize_mode letterbox   # resize_mode options: letterbox (default), stretch (official)
+"""
+  Images:       50
+  GT boxes:     201
+  DET boxes:    150
+  Matched:      75
+  Precision:    0.5000 (50.00%)
+  Recall:       0.3731 (37.31%)
+  Hmean (F1):   0.4274
+"""
+```
+
+Note: When `resize_mode` is `stretch`, it follows the official approach of directly resizing to the model input size. When `resize_mode` is `letterbox`, it pads the bottom-right corner, which has a smaller gap from the dynamic-input ONNX model and achieves better metrics in this test. You can download the `inference.onnx` with dynamic input `shape` from [small-det-onnx](https://huggingface.co/PaddlePaddle/PP-OCRv6_small_det_onnx) for comparison.
+
+#### Recognition
+
+``` python
+python3 run_rec_onnx.py
+"""
+  Total samples:         2077
+  Correct (exact match): 1563
+  Accuracy:              0.7525 (75.25%)
+  Norm Edit Distance:    0.8947
+"""
+python3 run_rec_ax.py
+"""
+  Total samples:         2077
+  Correct (exact match): 1518
+  Accuracy:              0.7309 (73.09%)
+  Norm Edit Distance:    0.8781
+"""
+```
+
+### Inference
+
+Run inference on AX650 host, such as M4N-Dock (AXERA Pi Pro).
+
+Input image:
+![input](./11.jpg)
+
+
+``` python
+python3 ppocrv6_onnx.py --use_angle_cls --visualize --image 11.jpg
+python3 ppocrv6_ax.py --use_angle_cls --visualize --image 11.jpg
+```
+
+Output image:
+![output](./res-ax.jpg)
+
+### Others
+The `tiny` recognition model has a large quantization error. Metrics are as follows:
+```
+onnx-preds:
+  Total samples:         2077
+  Correct (exact match): 1271
+  Accuracy:              0.6119 (61.19%)
+  Norm Edit Distance:    0.8263
+
+ax-w8a16-preds:
+  Total samples:         2077
+  Correct (exact match): 1178
+  Accuracy:              0.5672 (56.72%)
+  Norm Edit Distance:    0.7941
+```
+
+#### TODO
+
+- ax620 performance benchmark
+- ax615 performance benchmark

axmodel/ax650/cls_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9bf1940e8047b7308045248740089fb453aeb7af641bafd10508334d71121179
+size 647741

axmodel/ax650/cls_npu3.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db63d3946a4af62533a939a2e7121f595fdac931cddb57413d4f9a3099a0e17a
+size 786685

axmodel/ax650/det_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ddcbfb8d13ebfeaeaedecfdf87778ec86c7203cc1dbf0340031ed070e145616a
+size 4712586

axmodel/ax650/det_npu3.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07e1f5ca9369076b0a7bafeffef2456f24394cfe9beac048e6403cd3f901c885
+size 4264170

axmodel/ax650/rec_npu1.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b32efcc3840955bec45f9b44683192494c8deee9eed86dce1a29fec2e15e24fd
+size 6713642

axmodel/ax650/rec_npu3.axmodel

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:722fcd568848065549ed9d6a190c12790eae7ef81e7e5ff593905c302d90432a
+size 6904074

cls.json

@@ -0,0 +1,51 @@
+{
+  "input": "./onnx/cls_mobile_sim_static.onnx",
+  "output_dir": "./cls-650-npu1",
+  "output_name": "cls_npu1.axmodel",
+  "model_type": "ONNX",
+  // "target_hardware": "AX620E",
+  "npu_mode": "NPU1",
+  "onnx_opt": {
+    "disable_onnx_optimization": false,
+    "enable_onnxsim": true,
+    "model_check": true,
+    "disable_transformation_check": false
+  },
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "x",
+        "calibration_dataset": "./dataset/rec_quant.tar",
+        "calibration_format": "Image",
+        "calibration_size": -1,
+        "calibration_mean": [127.5, 127.5, 127.5],
+        "calibration_std": [127.5, 127.5, 127.5]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "Reference",
+    "layer_configs": [
+      {
+        "start_tensor_names": ["DEFAULT"],
+        "end_tensor_names": ["DEFAULT"],
+        "data_type": "U16"
+      }
+  ]
+  },
+  "input_processors": [
+    {
+      "tensor_name": "x",
+      "tensor_format": "BGR",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "FP32",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}

dataset/download_quant_dataset.sh

@@ -0,0 +1,2 @@
+wget https://github.com/AXERA-TECH/PPOCR_v5.axera/releases/download/v1.0.1/rec_pic.tar.gz
+wget https://github.com/AXERA-TECH/PPOCR_v5.axera/releases/download/v1.0.1/ocr_pic.tar.gz

dataset/download_val_dataset.sh

@@ -0,0 +1,2 @@
+wget https://paddle-model-ecology.bj.bcebos.com/paddlex/data/ocr_det_dataset_examples.tar && tar -xvf ocr_det_dataset_examples.tar
+wget https://paddle-model-ecology.bj.bcebos.com/paddlex/data/ocr_rec_dataset_examples.tar && tar -xvf ocr_rec_dataset_examples.tar

det.json

@@ -0,0 +1,46 @@
+{
+  "input": "onnx/det_inference_static_sim.onnx",
+  "output_dir": "./det-ax650-npu3",
+  "output_name": "det_npu3.axmodel",
+  "model_type": "ONNX",
+  // "target_hardware": "AX620E",
+  "npu_mode": "NPU3",
+
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "DEFAULT",
+        "calibration_dataset": "./dataset/ocr_pic.tar.gz",
+        "calibration_size": -1,
+        "calibration_mean": [123.675,116.28,103.53],
+        "calibration_std": [58.395,57.12,57.375]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "Reference", 
+    "conv_bias_data_type": "FP32",
+    "layer_configs": [
+      {
+        "start_tensor_names": ["DEFAULT"],
+        "end_tensor_names": ["DEFAULT"],
+        "data_type": "U16"
+      }
+    ]
+  },
+  "input_processors": [
+    {
+      "tensor_name": "DEFAULT",
+      "tensor_format": "BGR",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "FP32",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}

fonts/simfang.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:521c6f7546b4eb64fa4b0cd604bbd36333a20a57e388c8e2ad2ad07b9e593864
+size 10576012

onnx/cls_mobile_sim_static.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:870f2ed9c720a3e955e570c5309f88ed3a8b06c02a537762a10fac33070384a2
+size 980006

onnx/det_inference_static_sim.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47b0141861a709e98871cf407924e6012cec5cf076e5073a94dd4a910039b3bd
+size 9855211

onnx/rec_inference_static_sim.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffda730a074cbd034878d6ad2d47915d1307cd3a007bcc606a5763b89e5637f3
+size 21106528

ppocrv6_ax.py

@@ -0,0 +1,721 @@
+#!/usr/bin/env python3
+"""
+PP-OCRv6 ONNX Inference (standalone, zero Paddle dependency)
+
+Dependencies:
+    numpy, opencv-python, onnxruntime, pyyaml, shapely, pyclipper
+
+Usage:
+    from ppocrv6_onnx import PPOCRv6Onnx
+    ocr = PPOCRv6Onnx(det_onnx="det.onnx", rec_onnx="rec.onnx", char_dict="inference.yml")
+    results = ocr(img)  # img is BGR numpy array
+
+    # With direction classifier:
+    ocr = PPOCRv6Onnx(..., cls_onnx="cls.onnx", cls_label_list=["0","180"], cls_thresh=0.9)
+"""
+
+import argparse
+import json
+import math
+import os
+from typing import List, Optional, Tuple, Union
+
+import cv2
+import numpy as np
+import axengine as ort
+import yaml
+
+from PIL import Image, ImageDraw, ImageFont
+from shapely.geometry import Polygon
+import pyclipper
+import random
+
+
+# ============================================================================
+# Helpers
+# ============================================================================
+
+def _get_dim_value(dim):
+    """Extract integer value from an ONNX Runtime dimension, returning 0 for dynamic."""
+    if dim is None:
+        return 0
+    if isinstance(dim, str):
+        return 0
+    if hasattr(dim, "dim_value"):
+        return int(dim.dim_value) if dim.dim_value else 0
+    if hasattr(dim, "dim_param"):
+        return 0
+    try:
+        return int(dim)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _detect_fixed_dims(session: ort.InferenceSession, det_onnx: str):
+    """Detect fixed H/W from ONNX input shape. Returns (fixed_h, fixed_w)."""
+    inp = session.get_inputs()[0]
+    h, w = _get_dim_value(inp.shape[2]), _get_dim_value(inp.shape[3])
+    if h == 0 and w == 0:
+        try:
+            import onnx
+            m = onnx.load(det_onnx)
+            dims = m.graph.input[0].type.tensor_type.shape.dim
+            h = dims[2].dim_value if len(dims) > 2 else 0
+            w = dims[3].dim_value if len(dims) > 3 else 0
+        except Exception:
+            pass
+    return (h if h > 0 else 0), (w if w > 0 else 0)
+
+
+def _load_char_dict(source: Union[str, List[str]]) -> List[str]:
+    if isinstance(source, list):
+        return source
+    ext = os.path.splitext(source)[1].lower()
+    if ext in (".yml", ".yaml"):
+        with open(source, "r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f)
+        dic = cfg.get("PostProcess", {}).get("character_dict", [])
+        if not dic:
+            raise ValueError(f"No PostProcess.character_dict found in {source}")
+        return dic
+    elif ext == ".txt":
+        with open(source, "r", encoding="utf-8") as f:
+            return [line.strip("\n\r") for line in f.readlines()]
+    else:
+        raise ValueError(f"Unsupported char_dict source: {source}. Use .yml, .txt, or list.")
+
+
+# ============================================================================
+# 1. Detection Preprocessing
+# ============================================================================
+
+class _DetResizeForTest:
+    def __init__(self, limit_side_len=960, limit_type="max", max_side_limit=4000):
+        self.limit_side_len = limit_side_len
+        self.limit_type = limit_type
+        self.max_side_limit = max_side_limit
+
+    def _image_padding(self, im, value=0):
+        h, w, c = im.shape
+        im_pad = np.zeros((max(32, h), max(32, w), c), np.uint8) + value
+        im_pad[:h, :w, :] = im
+        return im_pad
+
+    def _resize_image_type0(self, img):
+        h, w, _ = img.shape
+        limit_side_len = self.limit_side_len
+        if self.limit_type == "max":
+            ratio = float(limit_side_len) / max(h, w) if max(h, w) > limit_side_len else 1.0
+        elif self.limit_type == "min":
+            ratio = float(limit_side_len) / min(h, w) if min(h, w) < limit_side_len else 1.0
+        elif self.limit_type == "resize_long":
+            ratio = float(limit_side_len) / max(h, w)
+        else:
+            raise ValueError(f"not support limit_type: {self.limit_type}")
+
+        resize_h, resize_w = int(h * ratio), int(w * ratio)
+        if max(resize_h, resize_w) > self.max_side_limit:
+            ratio = float(self.max_side_limit) / max(resize_h, resize_w)
+            resize_h, resize_w = int(resize_h * ratio), int(resize_w * ratio)
+        resize_h = max(int(round(resize_h / 32) * 32), 32)
+        resize_w = max(int(round(resize_w / 32) * 32), 32)
+        if int(resize_w) <= 0 or int(resize_h) <= 0:
+            return None, (None, None)
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        ratio_h, ratio_w = resize_h / float(h), resize_w / float(w)
+        return img, [ratio_h, ratio_w]
+
+    def __call__(self, img):
+        src_h, src_w = img.shape[:2]
+        if sum([src_h, src_w]) < 64:
+            img = self._image_padding(img)
+        img, [ratio_h, ratio_w] = self._resize_image_type0(img)
+        shape = np.array([src_h, src_w, ratio_h, ratio_w])
+        return img, shape
+
+
+class _NormalizeImage:
+    def __init__(self, mean, std, scale=1.0 / 255.0, order="hwc"):
+        self.scale = np.float32(scale)
+        shape = (1, 1, 3) if order == "hwc" else (3, 1, 1)
+        self.mean = np.array(mean, dtype=np.float32).reshape(shape)
+        self.std = np.array(std, dtype=np.float32).reshape(shape)
+
+    def __call__(self, img):
+        return (img.astype("float32") * self.scale - self.mean) / self.std
+
+
+class _ToCHWImage:
+    def __call__(self, img):
+        return img.transpose((2, 0, 1))
+
+
+# ============================================================================
+# 2. Recognition Preprocessing
+# ============================================================================
+
+def _resize_norm_img(img, image_shape, max_wh_ratio=None):
+    imgC, imgH, imgW = image_shape
+    if max_wh_ratio is None:
+        max_wh_ratio = imgW * 1.0 / imgH
+        h, w = img.shape[:2]
+        max_wh_ratio = max(max_wh_ratio, w / h)
+    target_w = int(imgH * max_wh_ratio)
+    h, w = img.shape[:2]
+    ratio = w / h
+    resized_w = target_w if math.ceil(imgH * ratio) > target_w else int(math.ceil(imgH * ratio))
+    resized_image = cv2.resize(img, (resized_w, imgH)).astype("float32")
+    resized_image = resized_image.transpose((2, 0, 1))
+    # resized_image /= 255.0
+    # resized_image -= 0.5
+    # resized_image /= 0.5
+    padding_im = np.zeros((imgC, imgH, target_w), dtype=np.float32)
+    padding_im[:, :, 0:resized_w] = resized_image
+    return padding_im
+
+
+# ============================================================================
+# 3. Detection Postprocessing
+# ============================================================================
+
+class _DBPostProcess:
+    def __init__(self, thresh=0.3, box_thresh=0.7, max_candidates=1000,
+                 unclip_ratio=2.0, use_dilation=False, score_mode="fast", box_type="quad"):
+        self.thresh = thresh
+        self.box_thresh = box_thresh
+        self.max_candidates = max_candidates
+        self.unclip_ratio = unclip_ratio
+        self.min_size = 3
+        self.score_mode = score_mode
+        self.box_type = box_type
+        self.dilation_kernel = None if not use_dilation else np.array([[1, 1], [1, 1]])
+
+    def _unclip(self, box, unclip_ratio):
+        poly = Polygon(box)
+        distance = poly.area * unclip_ratio / poly.length
+        offset = pyclipper.PyclipperOffset()
+        offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+        return offset.Execute(distance)
+
+    def _get_mini_boxes(self, contour):
+        bb = cv2.minAreaRect(contour)
+        points = sorted(list(cv2.boxPoints(bb)), key=lambda x: x[0])
+        i1, i4 = (0, 1) if points[1][1] > points[0][1] else (1, 0)
+        i2, i3 = (2, 3) if points[3][1] > points[2][1] else (3, 2)
+        return [points[i1], points[i2], points[i3], points[i4]], min(bb[1])
+
+    def _box_score_fast(self, bitmap, _box):
+        h, w = bitmap.shape[:2]
+        box = _box.copy()
+        xmin = np.clip(np.floor(box[:, 0].min()).astype("int32"), 0, w - 1)
+        xmax = np.clip(np.ceil(box[:, 0].max()).astype("int32"), 0, w - 1)
+        ymin = np.clip(np.floor(box[:, 1].min()).astype("int32"), 0, h - 1)
+        ymax = np.clip(np.ceil(box[:, 1].max()).astype("int32"), 0, h - 1)
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        box[:, 0] -= xmin
+        box[:, 1] -= ymin
+        cv2.fillPoly(mask, box.reshape(1, -1, 2).astype("int32"), 1)
+        return cv2.mean(bitmap[ymin:ymax + 1, xmin:xmax + 1], mask)[0]
+
+    def _boxes_from_bitmap(self, pred, _bitmap, dest_width, dest_height):
+        height, width = _bitmap.shape
+        outs = cv2.findContours(
+            (_bitmap * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE
+        )
+        contours = outs[0] if len(outs) == 2 else outs[1]
+        num = min(len(contours), self.max_candidates)
+        boxes, scores = [], []
+        for i in range(num):
+            points, sside = self._get_mini_boxes(contours[i])
+            if sside < self.min_size:
+                continue
+            points = np.array(points)
+            score = self._box_score_fast(pred, points.reshape(-1, 2))
+            if self.box_thresh > score:
+                continue
+            box = self._unclip(points, self.unclip_ratio)
+            if len(box) > 1:
+                continue
+            box = np.array(box).reshape(-1, 1, 2)
+            box, sside = self._get_mini_boxes(box)
+            if sside < self.min_size + 2:
+                continue
+            box = np.array(box)
+            box[:, 0] = np.clip(np.round(box[:, 0] / width * dest_width), 0, dest_width)
+            box[:, 1] = np.clip(np.round(box[:, 1] / height * dest_height), 0, dest_height)
+            boxes.append(box.astype("int32"))
+            scores.append(score)
+        return np.array(boxes, dtype="int32"), scores
+
+    def __call__(self, pred, shape_list):
+        pred = pred[:, 0, :, :]
+        segmentation = pred > self.thresh
+        boxes_batch = []
+        for bi in range(pred.shape[0]):
+            src_h, src_w, ratio_h, ratio_w = shape_list[bi]
+            mask = cv2.dilate(np.array(segmentation[bi]).astype(np.uint8),
+                              self.dilation_kernel) if self.dilation_kernel is not None else segmentation[bi]
+            boxes, _ = self._boxes_from_bitmap(pred[bi], mask, src_w, src_h)
+            boxes_batch.append(boxes)
+        return boxes_batch
+
+
+# ============================================================================
+# 4. Recognition Postprocessing
+# ============================================================================
+
+class _CTCLabelDecode:
+    def __init__(self, character_list: List[str], use_space_char=True):
+        self.character_str = list(character_list)
+        if use_space_char:
+            self.character_str.append(" ")
+        dict_character = ["blank"] + self.character_str
+        self.character = dict_character
+
+    def decode(self, text_index, text_prob=None, is_remove_duplicate=True):
+        result_list = []
+        for bi in range(len(text_index)):
+            sel = np.ones(len(text_index[bi]), dtype=bool)
+            if is_remove_duplicate:
+                sel[1:] = text_index[bi][1:] != text_index[bi][:-1]
+            sel &= text_index[bi] != 0
+            chars = [self.character[int(t)] for t in text_index[bi][sel]]
+            conf = text_prob[bi][sel] if text_prob is not None else [1] * len(sel)
+            if len(conf) == 0:
+                conf = [0]
+            result_list.append(("".join(chars), float(np.mean(conf))))
+        return result_list
+
+    def __call__(self, preds):
+        return self.decode(preds.argmax(axis=2), preds.max(axis=2), is_remove_duplicate=True)
+
+
+# ============================================================================
+# 5. Image Utilities
+# ============================================================================
+
+def _get_rotate_crop_image(img: np.ndarray, points: np.ndarray) -> np.ndarray:
+    assert len(points) == 4
+    cw = int(max(np.linalg.norm(points[0] - points[1]), np.linalg.norm(points[2] - points[3])))
+    ch = int(max(np.linalg.norm(points[0] - points[3]), np.linalg.norm(points[1] - points[2])))
+    pts_std = np.float32([[0, 0], [cw, 0], [cw, ch], [0, ch]])
+    M = cv2.getPerspectiveTransform(points.astype(np.float32), pts_std)
+    dst = cv2.warpPerspective(img, M, (cw, ch), borderMode=cv2.BORDER_REPLICATE, flags=cv2.INTER_CUBIC)
+    if dst.shape[0] * 1.0 / dst.shape[1] >= 1.5:
+        dst = np.rot90(dst)
+    return dst
+
+
+def _sorted_boxes(dt_boxes):
+    if len(dt_boxes) == 0:
+        return dt_boxes
+    boxes = sorted(dt_boxes, key=lambda x: (x[0][1], x[0][0]))
+    lst = list(boxes)
+    for i in range(len(lst) - 1):
+        for j in range(i, -1, -1):
+            if abs(lst[j + 1][0][1] - lst[j][0][1]) < 10 and lst[j + 1][0][0] < lst[j][0][0]:
+                lst[j], lst[j + 1] = lst[j + 1], lst[j]
+            else:
+                break
+    return lst
+
+
+def draw_ocr_result(
+    img: np.ndarray,
+    results: List[dict],
+    font_path: str = "./fonts/simfang.ttf",
+) -> np.ndarray:
+    """Draw detection boxes (semi-transparent) on original image, with text list on the right side."""
+    h, w = img.shape[:2]
+
+    # --- left: original image with semi-transparent colored boxes ---
+    pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+    overlay = Image.new("RGBA", pil_img.size, (0, 0, 0, 0))
+    draw_overlay = ImageDraw.Draw(overlay)
+
+    random.seed(0)
+    for res in results:
+        box = res["box"]
+        color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255), 90)
+        draw_overlay.polygon([tuple(p) for p in box], fill=color)
+
+    left_img = Image.alpha_composite(pil_img.convert("RGBA"), overlay).convert("RGB")
+
+    # --- right: white canvas with text list ---
+    right_w = int(w * 0.9)
+    right = Image.new("RGB", (right_w, h), (255, 255, 255))
+    draw_right = ImageDraw.Draw(right)
+
+    try:
+        font = ImageFont.truetype(font_path, 14)
+    except (OSError, IOError):
+        font = ImageFont.load_default()
+
+    y = 5
+    gap = 18
+    for i, res in enumerate(results):
+        text = f"{i+1}. {res['text']}  ({res['confidence']:.3f})"
+        # Color block matching the box
+        random.seed(i)
+        blk_color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+        draw_right.rectangle([5, y + 3, 15, y + 14], fill=blk_color, outline=(0, 0, 0))
+        draw_right.text((20, y), text, fill=(0, 0, 0), font=font)
+        y += gap
+
+    # --- concat left + right ---
+    result_img = Image.new("RGB", (w + right_w, h))
+    result_img.paste(left_img, (0, 0))
+    result_img.paste(right, (w, 0))
+
+    return cv2.cvtColor(np.array(result_img), cv2.COLOR_RGB2BGR)
+
+
+# ============================================================================
+# 6. Main Inference Engine
+# ============================================================================
+
+class PPOCRv6Onnx:
+
+    def __init__(
+        self,
+        det_onnx: str,
+        rec_onnx: str,
+        char_dict: Union[str, List[str]],
+        # Detection params
+        det_limit_side_len: int = 960,
+        det_db_thresh: float = 0.2,
+        det_db_box_thresh: float = 0.4,
+        det_db_unclip_ratio: float = 1.4,
+        det_max_candidates: int = 3000,
+        # Recognition params
+        rec_image_shape: Tuple[int, int, int] = (3, 48, 320),
+        rec_batch_num: int = 1,
+        # Classifier params
+        use_angle_cls: bool = False,
+        cls_onnx: Optional[str] = None,
+        cls_image_shape: Tuple[int, int, int] = (3, 48, 192),
+        cls_batch_num: int = 1,
+        cls_thresh: float = 0.9,
+        cls_label_list: Optional[List[str]] = None,
+        # Common
+        drop_score: float = 0.5,
+        use_gpu: bool = False,
+        onnx_providers: Optional[List[str]] = None,
+        resize_mode: str = "letterbox",
+    ):
+        assert resize_mode in ("letterbox", "stretch"), f"invalid resize_mode: {resize_mode}"
+        if cls_label_list is None:
+            cls_label_list = ["0", "180"]
+
+        self.rec_image_shape = rec_image_shape
+        self.rec_batch_num = rec_batch_num
+        self.drop_score = drop_score
+        self.use_angle_cls = use_angle_cls
+        self.cls_thresh = cls_thresh
+        self.cls_label_list = cls_label_list
+        self.cls_batch_num = cls_batch_num
+        self.cls_image_shape = cls_image_shape
+        self._resize_mode = resize_mode
+
+        self.det_session = ort.InferenceSession(det_onnx)
+        self.det_input_name = self.det_session.get_inputs()[0].name
+
+        self.rec_session = ort.InferenceSession(rec_onnx)
+        self.rec_input_name = self.rec_session.get_inputs()[0].name
+
+        # Classifier session
+        if use_angle_cls:
+            if cls_onnx is None:
+                raise ValueError("cls_onnx is required when use_angle_cls=True")
+            self.cls_session = ort.InferenceSession(cls_onnx)
+            self.cls_input_name = self.cls_session.get_inputs()[0].name
+            # Detect fixed dims for cls
+            cls_h, cls_w = _detect_fixed_dims(self.cls_session, cls_onnx)
+            self._cls_fixed_h = cls_h if cls_h > 0 else 0
+            self._cls_fixed_w = cls_w if cls_w > 0 else 0
+        else:
+            self.cls_session = None
+
+        # Detect fixed dims for det/rec
+        self._det_fixed_h, self._det_fixed_w = _detect_fixed_dims(self.det_session, det_onnx)
+        det_shape = self.det_session.get_inputs()[0].shape
+        print(f"[PPOCRv6] det shape={det_shape}, fixed_h={self._det_fixed_h}, fixed_w={self._det_fixed_w}, "
+              f"cls={use_angle_cls}, resize_mode={resize_mode}")
+
+        # Fixed rec width from ONNX
+        rec_inp = self.rec_session.get_inputs()[0]
+        rec_fw = _get_dim_value(rec_inp.shape[3])
+        self._rec_fixed_w = rec_fw if rec_fw > 0 else 0
+
+        # ---- Detection pre/post ----
+        self._det_resize = _DetResizeForTest(limit_side_len=det_limit_side_len, limit_type="max")
+        # self._det_normalize = _NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        self._det_normalize = _NormalizeImage(mean=[0., 0., 0.], std=[1.0, 1.0, 1.0], scale=1.0)
+        self._det_to_chw = _ToCHWImage()
+        self._det_post = _DBPostProcess(thresh=det_db_thresh, box_thresh=det_db_box_thresh,
+                                         unclip_ratio=det_db_unclip_ratio, max_candidates=det_max_candidates, box_type="quad")
+
+        # ---- Recognition post ----
+        self._rec_post = _CTCLabelDecode(_load_char_dict(char_dict), use_space_char=True)
+
+    # ---- Detection with static shape support ----
+
+    def _preprocess_det(self, img: np.ndarray):
+        src_h, src_w = img.shape[:2]
+        fh, fw = self._det_fixed_h, self._det_fixed_w
+        # print(f'fh {fh} fw {fw}')
+        if fh > 0 and fw > 0:
+            if self._resize_mode == "stretch":
+                # Direct resize (official behavior)
+                img_r = cv2.resize(img, (fw, fh))
+                shape = np.array([src_h, src_w, float(fh) / src_h, float(fw) / src_w])
+            else:
+                # Letterbox: ratio-preserving + pad
+                ratio = min(fh / src_h, fw / src_w)
+                new_h = min(max(int(round(src_h * ratio / 32) * 32), 32), fh)
+                new_w = min(max(int(round(src_w * ratio / 32) * 32), 32), fw)
+                img_r = cv2.resize(img, (new_w, new_h))
+                pad_h, pad_w = max(0, fh - new_h), max(0, fw - new_w)
+                if pad_h or pad_w:
+                    img_r = cv2.copyMakeBorder(img_r, 0, pad_h, 0, pad_w, cv2.BORDER_CONSTANT, value=(0, 0, 0))
+                shape = np.array([src_h * fh / new_h, src_w * fw / new_w,
+                                  float(new_h) / src_h, float(new_w) / src_w])
+        else:
+            img_r, shape = self._det_resize(img)
+
+        img_n = self._det_normalize(img_r)
+        img_c = self._det_to_chw(img_n)
+        return np.expand_dims(img_c.astype(np.float32), axis=0), shape
+
+    def _postprocess_det(self, output, shape):
+        return self._det_post(output, np.expand_dims(shape, axis=0))[0]
+
+    def detect(self, img):
+        tensor, shape = self._preprocess_det(img)
+        out = self.det_session.run(None, {self.det_input_name: tensor})
+        return self._postprocess_det(out[0], shape)
+
+    # ---- Classifier ----
+
+    def _preprocess_cls(self, img_list):
+        num = len(img_list)
+        width_list = [im.shape[1] / float(im.shape[0]) for im in img_list]
+        indices = np.argsort(np.array(width_list))
+        batches, idx_maps = [], []
+        for beg in range(0, num, self.cls_batch_num):
+            end = min(num, beg + self.cls_batch_num)
+            imgC, imgH, imgW = self.cls_image_shape
+
+            # Override with ONNX fixed dimensions
+            if self._cls_fixed_h > 0:
+                imgH = self._cls_fixed_h
+            if self._cls_fixed_w > 0:
+                imgW = self._cls_fixed_w
+
+            max_wh_ratio = imgW / imgH
+            for ino in range(beg, end):
+                h, w = img_list[indices[ino]].shape[:2]
+                max_wh_ratio = max(max_wh_ratio, w / h)
+            if self._cls_fixed_w > 0:
+                max_wh_ratio = self._cls_fixed_w / imgH
+
+            shape = (imgC, imgH, imgW)
+            norm_list, idx_list = [], []
+            for ino in range(beg, end):
+                orig_idx = indices[ino]
+                norm = _resize_norm_img(img_list[orig_idx], shape, max_wh_ratio=max_wh_ratio)
+                norm_list.append(np.expand_dims(norm, axis=0))
+                idx_list.append(orig_idx)
+            if norm_list:
+                batches.append(np.concatenate(norm_list, axis=0).astype(np.float32))
+            idx_maps.append(idx_list)
+        return batches, idx_maps
+
+    def _postprocess_cls(self, batch_outputs, idx_maps, total_num, img_list):
+        results = [("0", 1.0)] * total_num
+        for preds_batch, idx_list in zip(batch_outputs, idx_maps):
+            pred_ids = preds_batch.argmax(axis=1)
+            for i, orig_idx in enumerate(idx_list):
+                label = self.cls_label_list[int(pred_ids[i])]
+                score = float(preds_batch[i, int(pred_ids[i])])
+                results[orig_idx] = (label, score)
+                if "180" in str(label) and score > self.cls_thresh:
+                    img_list[orig_idx] = cv2.rotate(img_list[orig_idx], cv2.ROTATE_180)
+        return results
+
+    def classify(self, img_list):
+        if not img_list or not self.use_angle_cls:
+            return img_list, [], 0
+        img_list = [im.copy() for im in img_list]
+        batches, idx_maps = self._preprocess_cls(img_list)
+        outputs = []
+        for batch in batches:
+            out = self.cls_session.run(None, {self.cls_input_name: batch})
+            outputs.append(out[0])
+        cls_res = self._postprocess_cls(outputs, idx_maps, len(img_list), img_list)
+        return img_list, cls_res, 0
+
+    # ---- Recognition ----
+
+    def _preprocess_rec(self, img_crop_list):
+        num = len(img_crop_list)
+        width_list = [im.shape[1] / float(im.shape[0]) for im in img_crop_list]
+        indices = np.argsort(np.array(width_list))
+        batches, idx_maps = [], []
+        for beg in range(0, num, self.rec_batch_num):
+            end = min(num, beg + self.rec_batch_num)
+            imgC, imgH, imgW = self.rec_image_shape
+            max_wh_ratio = imgW / imgH
+            for ino in range(beg, end):
+                h, w = img_crop_list[indices[ino]].shape[:2]
+                max_wh_ratio = max(max_wh_ratio, w / h)
+            # Use fixed width if set by ONNX
+            if self._rec_fixed_w > 0:
+                max_wh_ratio = self._rec_fixed_w / imgH
+            norm_list, idx_list = [], []
+            for ino in range(beg, end):
+                orig_idx = indices[ino]
+                norm = _resize_norm_img(img_crop_list[orig_idx], self.rec_image_shape, max_wh_ratio=max_wh_ratio)
+                norm_list.append(np.expand_dims(norm, axis=0))
+                idx_list.append(orig_idx)
+            if norm_list:
+                batches.append(np.concatenate(norm_list, axis=0).astype(np.float32))
+            idx_maps.append(idx_list)
+        return batches, idx_maps
+
+    def _postprocess_rec(self, batch_outputs, idx_maps, total_num):
+        results = [("", 0.0)] * total_num
+        # Decode each batch separately (different T per batch)
+        for preds_batch, idx_list in zip(batch_outputs, idx_maps):
+            texts = self._rec_post(preds_batch)
+            for i, orig_idx in enumerate(idx_list):
+                results[orig_idx] = texts[i]
+        return results
+
+    def recognize(self, img_crop_list):
+        if not img_crop_list:
+            return []
+        batches, idx_maps = self._preprocess_rec(img_crop_list)
+        outputs = []
+        for batch in batches:
+            out = self.rec_session.run(None, {self.rec_input_name: batch})
+            outputs.append(out[0])
+        return self._postprocess_rec(outputs, idx_maps, len(img_crop_list))
+
+    # ---- Full pipeline ----
+
+    def predict_image(self, image_path, visualize=False):
+        img = cv2.imread(image_path)
+        if img is None:
+            raise FileNotFoundError(f"Cannot read image: {image_path}")
+        return self(img, visualize=visualize)
+
+    def __call__(self, img: np.ndarray, visualize=False, use_cls=None):
+        ori_im = img.copy()
+
+        boxes = self.detect(img)
+        # print(f"[PPOCRv6] Detected {len(boxes)}")
+        if len(boxes) == 0:
+            return [] if not visualize else ori_im
+
+        boxes = _sorted_boxes(boxes)
+        # print(f"[PPOCRv6] Detected _sorted_boxes {len(boxes)}")
+
+        img_crop_list = []
+        for i, box in enumerate(boxes):
+            crop = _get_rotate_crop_image(ori_im, np.array(box, dtype=np.float32))
+            img_crop_list.append(crop)
+
+        # Direction classifier
+        do_cls = self.use_angle_cls if use_cls is None else use_cls
+        if do_cls and self.cls_session is not None:
+            img_crop_list, cls_res, _ = self.classify(img_crop_list)
+
+        rec_res = self.recognize(img_crop_list)
+
+        results = []
+        for box, (text, conf) in zip(boxes, rec_res):
+            if conf >= self.drop_score:
+                results.append({"text": text, "confidence": round(conf, 4), "box": box.tolist()})
+
+        return (results, draw_ocr_result(ori_im, results)) if visualize else (results, None)
+
+
+# ============================================================================
+# 7. CLI
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(description="PP-OCRv6 ONNX Inference (standalone, no Paddle dependency)")
+    parser.add_argument("--det_onnx", type=str, default="axmodel/ax650/det_npu1.axmodel")
+    parser.add_argument("--rec_onnx", type=str, default="axmodel/ax650/rec_npu1.axmodel")
+    parser.add_argument("--char_dict", type=str, default="onnx/rec_inference.yml")
+    parser.add_argument("--image", required=True, help="Input image path")
+    parser.add_argument("--use_gpu", action="store_true")
+    parser.add_argument("--drop_score", type=float, default=0.5)
+    parser.add_argument("--det_limit_side_len", type=int, default=960)
+    parser.add_argument("--det_db_thresh", type=float, default=0.2)
+    parser.add_argument("--det_db_box_thresh", type=float, default=0.45)
+    parser.add_argument("--det_db_unclip_ratio", type=float, default=1.4)
+    parser.add_argument("--rec_batch_num", type=int, default=1)
+    parser.add_argument("--resize_mode", type=str, default="letterbox", choices=["letterbox", "stretch"])
+    # Classifier
+    parser.add_argument("--use_angle_cls", action="store_true", help="Enable direction classifier")
+    parser.add_argument("--cls_onnx", type=str, default="axmodel/ax650/cls_npu1.axmodel", help="Classifer ONNX model path")
+    parser.add_argument("--cls_thresh", type=float, default=0.9, help="Angie classifier confidence threshold")
+    parser.add_argument("--cls_batch_num", type=int, default=1)
+    # Output
+    parser.add_argument("--visualize", action="store_true")
+    parser.add_argument("--output", type=str, default=None)
+    parser.add_argument("--json", type=str, default=None)
+
+    args = parser.parse_args()
+
+    char_dict_src = args.char_dict
+    if not os.path.exists(char_dict_src) and ("," in char_dict_src or char_dict_src.startswith("[")):
+        char_dict = [c.strip() for c in char_dict_src.strip("[]").split(",") if c.strip()]
+    else:
+        char_dict = char_dict_src
+
+    ocr = PPOCRv6Onnx(
+        det_onnx=args.det_onnx,
+        rec_onnx=args.rec_onnx,
+        char_dict=char_dict,
+        det_limit_side_len=args.det_limit_side_len,
+        det_db_thresh=args.det_db_thresh,
+        det_db_box_thresh=args.det_db_box_thresh,
+        det_db_unclip_ratio=args.det_db_unclip_ratio,
+        rec_batch_num=args.rec_batch_num,
+        use_angle_cls=args.use_angle_cls,
+        cls_onnx=args.cls_onnx,
+        cls_thresh=args.cls_thresh,
+        cls_batch_num=args.cls_batch_num,
+        drop_score=args.drop_score,
+        use_gpu=args.use_gpu,
+        resize_mode=args.resize_mode,
+    )
+
+    do_viz = args.visualize or args.output is not None
+    img = cv2.imread(args.image)
+    if img is None:
+        raise FileNotFoundError(f"Cannot read image: {args.image}")
+
+    if do_viz:
+        results, vis = ocr(img, visualize=True)
+        out_path = args.output or "res-ax.jpg"
+        cv2.imwrite(out_path, vis)
+        print(f"Annotated image saved to: {out_path}")
+    else:
+        results, vis = ocr(img)
+
+    if args.json:
+        with open(args.json, "w", encoding="utf-8") as f:
+            json.dump(results, f, ensure_ascii=False, indent=2)
+        print(f"Results saved to: {args.json}")
+    else:
+        for i, res in enumerate(results):
+            print(f"{i+1}. {res['text']}  ({res['confidence']:.3f})")
+
+
+if __name__ == "__main__":
+    main()

ppocrv6_onnx.py

@@ -0,0 +1,721 @@
+#!/usr/bin/env python3
+"""
+PP-OCRv6 ONNX Inference (standalone, zero Paddle dependency)
+
+Dependencies:
+    numpy, opencv-python, onnxruntime, pyyaml, shapely, pyclipper
+
+Usage:
+    from ppocrv6_onnx import PPOCRv6Onnx
+    ocr = PPOCRv6Onnx(det_onnx="det.onnx", rec_onnx="rec.onnx", char_dict="inference.yml")
+    results = ocr(img)  # img is BGR numpy array
+
+    # With direction classifier:
+    ocr = PPOCRv6Onnx(..., cls_onnx="cls.onnx", cls_label_list=["0","180"], cls_thresh=0.9)
+"""
+
+import argparse
+import json
+import math
+import os
+from typing import List, Optional, Tuple, Union
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+import yaml
+
+from PIL import Image, ImageDraw, ImageFont
+from shapely.geometry import Polygon
+import pyclipper
+import random
+
+
+# ============================================================================
+# Helpers
+# ============================================================================
+
+def _get_dim_value(dim):
+    """Extract integer value from an ONNX Runtime dimension, returning 0 for dynamic."""
+    if dim is None:
+        return 0
+    if isinstance(dim, str):
+        return 0
+    if hasattr(dim, "dim_value"):
+        return int(dim.dim_value) if dim.dim_value else 0
+    if hasattr(dim, "dim_param"):
+        return 0
+    try:
+        return int(dim)
+    except (TypeError, ValueError):
+        return 0
+
+
+def _detect_fixed_dims(session: ort.InferenceSession, det_onnx: str):
+    """Detect fixed H/W from ONNX input shape. Returns (fixed_h, fixed_w)."""
+    inp = session.get_inputs()[0]
+    h, w = _get_dim_value(inp.shape[2]), _get_dim_value(inp.shape[3])
+    if h == 0 and w == 0:
+        try:
+            import onnx
+            m = onnx.load(det_onnx)
+            dims = m.graph.input[0].type.tensor_type.shape.dim
+            h = dims[2].dim_value if len(dims) > 2 else 0
+            w = dims[3].dim_value if len(dims) > 3 else 0
+        except Exception:
+            pass
+    return (h if h > 0 else 0), (w if w > 0 else 0)
+
+
+def _load_char_dict(source: Union[str, List[str]]) -> List[str]:
+    if isinstance(source, list):
+        return source
+    ext = os.path.splitext(source)[1].lower()
+    if ext in (".yml", ".yaml"):
+        with open(source, "r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f)
+        dic = cfg.get("PostProcess", {}).get("character_dict", [])
+        if not dic:
+            raise ValueError(f"No PostProcess.character_dict found in {source}")
+        return dic
+    elif ext == ".txt":
+        with open(source, "r", encoding="utf-8") as f:
+            return [line.strip("\n\r") for line in f.readlines()]
+    else:
+        raise ValueError(f"Unsupported char_dict source: {source}. Use .yml, .txt, or list.")
+
+
+# ============================================================================
+# 1. Detection Preprocessing
+# ============================================================================
+
+class _DetResizeForTest:
+    def __init__(self, limit_side_len=960, limit_type="max", max_side_limit=4000):
+        self.limit_side_len = limit_side_len
+        self.limit_type = limit_type
+        self.max_side_limit = max_side_limit
+
+    def _image_padding(self, im, value=0):
+        h, w, c = im.shape
+        im_pad = np.zeros((max(32, h), max(32, w), c), np.uint8) + value
+        im_pad[:h, :w, :] = im
+        return im_pad
+
+    def _resize_image_type0(self, img):
+        h, w, _ = img.shape
+        limit_side_len = self.limit_side_len
+        if self.limit_type == "max":
+            ratio = float(limit_side_len) / max(h, w) if max(h, w) > limit_side_len else 1.0
+        elif self.limit_type == "min":
+            ratio = float(limit_side_len) / min(h, w) if min(h, w) < limit_side_len else 1.0
+        elif self.limit_type == "resize_long":
+            ratio = float(limit_side_len) / max(h, w)
+        else:
+            raise ValueError(f"not support limit_type: {self.limit_type}")
+
+        resize_h, resize_w = int(h * ratio), int(w * ratio)
+        if max(resize_h, resize_w) > self.max_side_limit:
+            ratio = float(self.max_side_limit) / max(resize_h, resize_w)
+            resize_h, resize_w = int(resize_h * ratio), int(resize_w * ratio)
+        resize_h = max(int(round(resize_h / 32) * 32), 32)
+        resize_w = max(int(round(resize_w / 32) * 32), 32)
+        if int(resize_w) <= 0 or int(resize_h) <= 0:
+            return None, (None, None)
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        ratio_h, ratio_w = resize_h / float(h), resize_w / float(w)
+        return img, [ratio_h, ratio_w]
+
+    def __call__(self, img):
+        src_h, src_w = img.shape[:2]
+        if sum([src_h, src_w]) < 64:
+            img = self._image_padding(img)
+        img, [ratio_h, ratio_w] = self._resize_image_type0(img)
+        shape = np.array([src_h, src_w, ratio_h, ratio_w])
+        return img, shape
+
+
+class _NormalizeImage:
+    def __init__(self, mean, std, scale=1.0 / 255.0, order="hwc"):
+        self.scale = np.float32(scale)
+        shape = (1, 1, 3) if order == "hwc" else (3, 1, 1)
+        self.mean = np.array(mean, dtype=np.float32).reshape(shape)
+        self.std = np.array(std, dtype=np.float32).reshape(shape)
+
+    def __call__(self, img):
+        return (img.astype("float32") * self.scale - self.mean) / self.std
+
+
+class _ToCHWImage:
+    def __call__(self, img):
+        return img.transpose((2, 0, 1))
+
+
+# ============================================================================
+# 2. Recognition Preprocessing
+# ============================================================================
+
+def _resize_norm_img(img, image_shape, max_wh_ratio=None):
+    imgC, imgH, imgW = image_shape
+    if max_wh_ratio is None:
+        max_wh_ratio = imgW * 1.0 / imgH
+        h, w = img.shape[:2]
+        max_wh_ratio = max(max_wh_ratio, w / h)
+    target_w = int(imgH * max_wh_ratio)
+    h, w = img.shape[:2]
+    ratio = w / h
+    resized_w = target_w if math.ceil(imgH * ratio) > target_w else int(math.ceil(imgH * ratio))
+    resized_image = cv2.resize(img, (resized_w, imgH)).astype("float32")
+    resized_image = resized_image.transpose((2, 0, 1)) / 255.0
+    resized_image -= 0.5
+    resized_image /= 0.5
+    padding_im = np.zeros((imgC, imgH, target_w), dtype=np.float32)
+    padding_im[:, :, 0:resized_w] = resized_image
+    return padding_im
+
+
+# ============================================================================
+# 3. Detection Postprocessing
+# ============================================================================
+
+class _DBPostProcess:
+    def __init__(self, thresh=0.3, box_thresh=0.7, max_candidates=1000,
+                 unclip_ratio=2.0, use_dilation=False, score_mode="fast", box_type="quad"):
+        self.thresh = thresh
+        self.box_thresh = box_thresh
+        self.max_candidates = max_candidates
+        self.unclip_ratio = unclip_ratio
+        self.min_size = 3
+        self.score_mode = score_mode
+        self.box_type = box_type
+        self.dilation_kernel = None if not use_dilation else np.array([[1, 1], [1, 1]])
+
+    def _unclip(self, box, unclip_ratio):
+        poly = Polygon(box)
+        distance = poly.area * unclip_ratio / poly.length
+        offset = pyclipper.PyclipperOffset()
+        offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+        return offset.Execute(distance)
+
+    def _get_mini_boxes(self, contour):
+        bb = cv2.minAreaRect(contour)
+        points = sorted(list(cv2.boxPoints(bb)), key=lambda x: x[0])
+        i1, i4 = (0, 1) if points[1][1] > points[0][1] else (1, 0)
+        i2, i3 = (2, 3) if points[3][1] > points[2][1] else (3, 2)
+        return [points[i1], points[i2], points[i3], points[i4]], min(bb[1])
+
+    def _box_score_fast(self, bitmap, _box):
+        h, w = bitmap.shape[:2]
+        box = _box.copy()
+        xmin = np.clip(np.floor(box[:, 0].min()).astype("int32"), 0, w - 1)
+        xmax = np.clip(np.ceil(box[:, 0].max()).astype("int32"), 0, w - 1)
+        ymin = np.clip(np.floor(box[:, 1].min()).astype("int32"), 0, h - 1)
+        ymax = np.clip(np.ceil(box[:, 1].max()).astype("int32"), 0, h - 1)
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        box[:, 0] -= xmin
+        box[:, 1] -= ymin
+        cv2.fillPoly(mask, box.reshape(1, -1, 2).astype("int32"), 1)
+        return cv2.mean(bitmap[ymin:ymax + 1, xmin:xmax + 1], mask)[0]
+
+    def _boxes_from_bitmap(self, pred, _bitmap, dest_width, dest_height):
+        height, width = _bitmap.shape
+        outs = cv2.findContours(
+            (_bitmap * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE
+        )
+        contours = outs[0] if len(outs) == 2 else outs[1]
+        num = min(len(contours), self.max_candidates)
+        boxes, scores = [], []
+        for i in range(num):
+            points, sside = self._get_mini_boxes(contours[i])
+            if sside < self.min_size:
+                continue
+            points = np.array(points)
+            score = self._box_score_fast(pred, points.reshape(-1, 2))
+            if self.box_thresh > score:
+                continue
+            box = self._unclip(points, self.unclip_ratio)
+            if len(box) > 1:
+                continue
+            box = np.array(box).reshape(-1, 1, 2)
+            box, sside = self._get_mini_boxes(box)
+            if sside < self.min_size + 2:
+                continue
+            box = np.array(box)
+            box[:, 0] = np.clip(np.round(box[:, 0] / width * dest_width), 0, dest_width)
+            box[:, 1] = np.clip(np.round(box[:, 1] / height * dest_height), 0, dest_height)
+            boxes.append(box.astype("int32"))
+            scores.append(score)
+        return np.array(boxes, dtype="int32"), scores
+
+    def __call__(self, pred, shape_list):
+        pred = pred[:, 0, :, :]
+        segmentation = pred > self.thresh
+        boxes_batch = []
+        for bi in range(pred.shape[0]):
+            src_h, src_w, ratio_h, ratio_w = shape_list[bi]
+            mask = cv2.dilate(np.array(segmentation[bi]).astype(np.uint8),
+                              self.dilation_kernel) if self.dilation_kernel is not None else segmentation[bi]
+            boxes, _ = self._boxes_from_bitmap(pred[bi], mask, src_w, src_h)
+            boxes_batch.append(boxes)
+        return boxes_batch
+
+
+# ============================================================================
+# 4. Recognition Postprocessing
+# ============================================================================
+
+class _CTCLabelDecode:
+    def __init__(self, character_list: List[str], use_space_char=True):
+        self.character_str = list(character_list)
+        if use_space_char:
+            self.character_str.append(" ")
+        dict_character = ["blank"] + self.character_str
+        self.character = dict_character
+
+    def decode(self, text_index, text_prob=None, is_remove_duplicate=True):
+        result_list = []
+        for bi in range(len(text_index)):
+            sel = np.ones(len(text_index[bi]), dtype=bool)
+            if is_remove_duplicate:
+                sel[1:] = text_index[bi][1:] != text_index[bi][:-1]
+            sel &= text_index[bi] != 0
+            chars = [self.character[int(t)] for t in text_index[bi][sel]]
+            conf = text_prob[bi][sel] if text_prob is not None else [1] * len(sel)
+            if len(conf) == 0:
+                conf = [0]
+            result_list.append(("".join(chars), float(np.mean(conf))))
+        return result_list
+
+    def __call__(self, preds):
+        return self.decode(preds.argmax(axis=2), preds.max(axis=2), is_remove_duplicate=True)
+
+
+# ============================================================================
+# 5. Image Utilities
+# ============================================================================
+
+def _get_rotate_crop_image(img: np.ndarray, points: np.ndarray) -> np.ndarray:
+    assert len(points) == 4
+    cw = int(max(np.linalg.norm(points[0] - points[1]), np.linalg.norm(points[2] - points[3])))
+    ch = int(max(np.linalg.norm(points[0] - points[3]), np.linalg.norm(points[1] - points[2])))
+    pts_std = np.float32([[0, 0], [cw, 0], [cw, ch], [0, ch]])
+    M = cv2.getPerspectiveTransform(points.astype(np.float32), pts_std)
+    dst = cv2.warpPerspective(img, M, (cw, ch), borderMode=cv2.BORDER_REPLICATE, flags=cv2.INTER_CUBIC)
+    if dst.shape[0] * 1.0 / dst.shape[1] >= 1.5:
+        dst = np.rot90(dst)
+    return dst
+
+
+def _sorted_boxes(dt_boxes):
+    if len(dt_boxes) == 0:
+        return dt_boxes
+    boxes = sorted(dt_boxes, key=lambda x: (x[0][1], x[0][0]))
+    lst = list(boxes)
+    for i in range(len(lst) - 1):
+        for j in range(i, -1, -1):
+            if abs(lst[j + 1][0][1] - lst[j][0][1]) < 10 and lst[j + 1][0][0] < lst[j][0][0]:
+                lst[j], lst[j + 1] = lst[j + 1], lst[j]
+            else:
+                break
+    return lst
+
+
+def draw_ocr_result(
+    img: np.ndarray,
+    results: List[dict],
+    font_path: str = "./fonts/simfang.ttf",
+) -> np.ndarray:
+    """Draw detection boxes (semi-transparent) on original image, with text list on the right side."""
+    h, w = img.shape[:2]
+
+    # --- left: original image with semi-transparent colored boxes ---
+    pil_img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+    overlay = Image.new("RGBA", pil_img.size, (0, 0, 0, 0))
+    draw_overlay = ImageDraw.Draw(overlay)
+
+    random.seed(0)
+    for res in results:
+        box = res["box"]
+        color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255), 90)
+        draw_overlay.polygon([tuple(p) for p in box], fill=color)
+
+    left_img = Image.alpha_composite(pil_img.convert("RGBA"), overlay).convert("RGB")
+
+    # --- right: white canvas with text list ---
+    right_w = int(w * 0.9)
+    right = Image.new("RGB", (right_w, h), (255, 255, 255))
+    draw_right = ImageDraw.Draw(right)
+
+    try:
+        font = ImageFont.truetype(font_path, 14)
+    except (OSError, IOError):
+        font = ImageFont.load_default()
+
+    y = 5
+    gap = 18
+    for i, res in enumerate(results):
+        text = f"{i+1}. {res['text']}  ({res['confidence']:.3f})"
+        # Color block matching the box
+        random.seed(i)
+        blk_color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+        draw_right.rectangle([5, y + 3, 15, y + 14], fill=blk_color, outline=(0, 0, 0))
+        draw_right.text((20, y), text, fill=(0, 0, 0), font=font)
+        y += gap
+
+    # --- concat left + right ---
+    result_img = Image.new("RGB", (w + right_w, h))
+    result_img.paste(left_img, (0, 0))
+    result_img.paste(right, (w, 0))
+
+    return cv2.cvtColor(np.array(result_img), cv2.COLOR_RGB2BGR)
+
+
+# ============================================================================
+# 6. Main Inference Engine
+# ============================================================================
+
+class PPOCRv6Onnx:
+
+    def __init__(
+        self,
+        det_onnx: str,
+        rec_onnx: str,
+        char_dict: Union[str, List[str]],
+        # Detection params
+        det_limit_side_len: int = 960,
+        det_db_thresh: float = 0.2,
+        det_db_box_thresh: float = 0.4,
+        det_db_unclip_ratio: float = 1.4,
+        det_max_candidates: int = 3000,
+        # Recognition params
+        rec_image_shape: Tuple[int, int, int] = (3, 48, 320),
+        rec_batch_num: int = 6,
+        # Classifier params
+        use_angle_cls: bool = False,
+        cls_onnx: Optional[str] = None,
+        cls_image_shape: Tuple[int, int, int] = (3, 48, 192),
+        cls_batch_num: int = 6,
+        cls_thresh: float = 0.9,
+        cls_label_list: Optional[List[str]] = None,
+        # Common
+        drop_score: float = 0.5,
+        use_gpu: bool = False,
+        onnx_providers: Optional[List[str]] = None,
+        resize_mode: str = "letterbox",
+    ):
+        assert resize_mode in ("letterbox", "stretch"), f"invalid resize_mode: {resize_mode}"
+        if cls_label_list is None:
+            cls_label_list = ["0", "180"]
+
+        self.rec_image_shape = rec_image_shape
+        self.rec_batch_num = rec_batch_num
+        self.drop_score = drop_score
+        self.use_angle_cls = use_angle_cls
+        self.cls_thresh = cls_thresh
+        self.cls_label_list = cls_label_list
+        self.cls_batch_num = cls_batch_num
+        self.cls_image_shape = cls_image_shape
+        self._resize_mode = resize_mode
+
+        # ---- ONNX sessions ----
+        if onnx_providers is None:
+            onnx_providers = ["CUDAExecutionProvider", "CPUExecutionProvider"] if use_gpu else ["CPUExecutionProvider"]
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+        self.det_session = ort.InferenceSession(det_onnx, sess_options=sess_options, providers=onnx_providers)
+        self.det_input_name = self.det_session.get_inputs()[0].name
+
+        self.rec_session = ort.InferenceSession(rec_onnx, sess_options=sess_options, providers=onnx_providers)
+        self.rec_input_name = self.rec_session.get_inputs()[0].name
+
+        # Classifier session
+        if use_angle_cls:
+            if cls_onnx is None:
+                raise ValueError("cls_onnx is required when use_angle_cls=True")
+            self.cls_session = ort.InferenceSession(cls_onnx, sess_options=sess_options, providers=onnx_providers)
+            self.cls_input_name = self.cls_session.get_inputs()[0].name
+            # Detect fixed dims for cls
+            cls_h, cls_w = _detect_fixed_dims(self.cls_session, cls_onnx)
+            self._cls_fixed_h = cls_h if cls_h > 0 else 0
+            self._cls_fixed_w = cls_w if cls_w > 0 else 0
+        else:
+            self.cls_session = None
+
+        # Detect fixed dims for det/rec
+        self._det_fixed_h, self._det_fixed_w = _detect_fixed_dims(self.det_session, det_onnx)
+        det_shape = self.det_session.get_inputs()[0].shape
+        print(f"[PPOCRv6] det shape={det_shape}, fixed_h={self._det_fixed_h}, fixed_w={self._det_fixed_w}, "
+              f"cls={use_angle_cls}, resize_mode={resize_mode}")
+
+        # Fixed rec width from ONNX
+        rec_inp = self.rec_session.get_inputs()[0]
+        rec_fw = _get_dim_value(rec_inp.shape[3])
+        self._rec_fixed_w = rec_fw if rec_fw > 0 else 0
+
+        # ---- Detection pre/post ----
+        self._det_resize = _DetResizeForTest(limit_side_len=det_limit_side_len, limit_type="max")
+        self._det_normalize = _NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        self._det_to_chw = _ToCHWImage()
+        self._det_post = _DBPostProcess(thresh=det_db_thresh, box_thresh=det_db_box_thresh,
+                                         unclip_ratio=det_db_unclip_ratio, max_candidates=det_max_candidates, box_type="quad")
+
+        # ---- Recognition post ----
+        self._rec_post = _CTCLabelDecode(_load_char_dict(char_dict), use_space_char=True)
+
+    # ---- Detection with static shape support ----
+
+    def _preprocess_det(self, img: np.ndarray):
+        src_h, src_w = img.shape[:2]
+        fh, fw = self._det_fixed_h, self._det_fixed_w
+
+        if fh > 0 and fw > 0:
+            if self._resize_mode == "stretch":
+                # Direct resize (official behavior)
+                img_r = cv2.resize(img, (fw, fh))
+                shape = np.array([src_h, src_w, float(fh) / src_h, float(fw) / src_w])
+            else:
+                # Letterbox: ratio-preserving + pad
+                ratio = min(fh / src_h, fw / src_w)
+                new_h = min(max(int(round(src_h * ratio / 32) * 32), 32), fh)
+                new_w = min(max(int(round(src_w * ratio / 32) * 32), 32), fw)
+                img_r = cv2.resize(img, (new_w, new_h))
+                pad_h, pad_w = max(0, fh - new_h), max(0, fw - new_w)
+                if pad_h or pad_w:
+                    img_r = cv2.copyMakeBorder(img_r, 0, pad_h, 0, pad_w, cv2.BORDER_CONSTANT, value=(0, 0, 0))
+                shape = np.array([src_h * fh / new_h, src_w * fw / new_w,
+                                  float(new_h) / src_h, float(new_w) / src_w])
+        else:
+            img_r, shape = self._det_resize(img)
+
+        img_n = self._det_normalize(img_r)
+        img_c = self._det_to_chw(img_n)
+        return np.expand_dims(img_c.astype(np.float32), axis=0), shape
+
+    def _postprocess_det(self, output, shape):
+        return self._det_post(output, np.expand_dims(shape, axis=0))[0]
+
+    def detect(self, img):
+        tensor, shape = self._preprocess_det(img)
+        out = self.det_session.run(None, {self.det_input_name: tensor})
+        return self._postprocess_det(out[0], shape)
+
+    # ---- Classifier ----
+
+    def _preprocess_cls(self, img_list):
+        num = len(img_list)
+        width_list = [im.shape[1] / float(im.shape[0]) for im in img_list]
+        indices = np.argsort(np.array(width_list))
+        batches, idx_maps = [], []
+        for beg in range(0, num, self.cls_batch_num):
+            end = min(num, beg + self.cls_batch_num)
+            imgC, imgH, imgW = self.cls_image_shape
+
+            # Override with ONNX fixed dimensions
+            if self._cls_fixed_h > 0:
+                imgH = self._cls_fixed_h
+            if self._cls_fixed_w > 0:
+                imgW = self._cls_fixed_w
+
+            max_wh_ratio = imgW / imgH
+            for ino in range(beg, end):
+                h, w = img_list[indices[ino]].shape[:2]
+                max_wh_ratio = max(max_wh_ratio, w / h)
+            if self._cls_fixed_w > 0:
+                max_wh_ratio = self._cls_fixed_w / imgH
+
+            shape = (imgC, imgH, imgW)
+            norm_list, idx_list = [], []
+            for ino in range(beg, end):
+                orig_idx = indices[ino]
+                norm = _resize_norm_img(img_list[orig_idx], shape, max_wh_ratio=max_wh_ratio)
+                norm_list.append(np.expand_dims(norm, axis=0))
+                idx_list.append(orig_idx)
+            if norm_list:
+                batches.append(np.concatenate(norm_list, axis=0).astype(np.float32))
+            idx_maps.append(idx_list)
+        return batches, idx_maps
+
+    def _postprocess_cls(self, batch_outputs, idx_maps, total_num, img_list):
+        results = [("0", 1.0)] * total_num
+        for preds_batch, idx_list in zip(batch_outputs, idx_maps):
+            pred_ids = preds_batch.argmax(axis=1)
+            for i, orig_idx in enumerate(idx_list):
+                label = self.cls_label_list[int(pred_ids[i])]
+                score = float(preds_batch[i, int(pred_ids[i])])
+                results[orig_idx] = (label, score)
+                if "180" in str(label) and score > self.cls_thresh:
+                    img_list[orig_idx] = cv2.rotate(img_list[orig_idx], cv2.ROTATE_180)
+        return results
+
+    def classify(self, img_list):
+        if not img_list or not self.use_angle_cls:
+            return img_list, [], 0
+        img_list = [im.copy() for im in img_list]
+        batches, idx_maps = self._preprocess_cls(img_list)
+        outputs = []
+        for batch in batches:
+            out = self.cls_session.run(None, {self.cls_input_name: batch})
+            outputs.append(out[0])
+        cls_res = self._postprocess_cls(outputs, idx_maps, len(img_list), img_list)
+        return img_list, cls_res, 0
+
+    # ---- Recognition ----
+
+    def _preprocess_rec(self, img_crop_list):
+        num = len(img_crop_list)
+        width_list = [im.shape[1] / float(im.shape[0]) for im in img_crop_list]
+        indices = np.argsort(np.array(width_list))
+        batches, idx_maps = [], []
+        for beg in range(0, num, self.rec_batch_num):
+            end = min(num, beg + self.rec_batch_num)
+            imgC, imgH, imgW = self.rec_image_shape
+            max_wh_ratio = imgW / imgH
+            for ino in range(beg, end):
+                h, w = img_crop_list[indices[ino]].shape[:2]
+                max_wh_ratio = max(max_wh_ratio, w / h)
+            # Use fixed width if set by ONNX
+            if self._rec_fixed_w > 0:
+                max_wh_ratio = self._rec_fixed_w / imgH
+            norm_list, idx_list = [], []
+            for ino in range(beg, end):
+                orig_idx = indices[ino]
+                norm = _resize_norm_img(img_crop_list[orig_idx], self.rec_image_shape, max_wh_ratio=max_wh_ratio)
+                norm_list.append(np.expand_dims(norm, axis=0))
+                idx_list.append(orig_idx)
+            if norm_list:
+                batches.append(np.concatenate(norm_list, axis=0).astype(np.float32))
+            idx_maps.append(idx_list)
+        return batches, idx_maps
+
+    def _postprocess_rec(self, batch_outputs, idx_maps, total_num):
+        results = [("", 0.0)] * total_num
+        # Decode each batch separately (different T per batch)
+        for preds_batch, idx_list in zip(batch_outputs, idx_maps):
+            texts = self._rec_post(preds_batch)
+            for i, orig_idx in enumerate(idx_list):
+                results[orig_idx] = texts[i]
+        return results
+
+    def recognize(self, img_crop_list):
+        if not img_crop_list:
+            return []
+        batches, idx_maps = self._preprocess_rec(img_crop_list)
+        outputs = []
+        for batch in batches:
+            out = self.rec_session.run(None, {self.rec_input_name: batch})
+            outputs.append(out[0])
+        return self._postprocess_rec(outputs, idx_maps, len(img_crop_list))
+
+    # ---- Full pipeline ----
+
+    def predict_image(self, image_path, visualize=False):
+        img = cv2.imread(image_path)
+        if img is None:
+            raise FileNotFoundError(f"Cannot read image: {image_path}")
+        return self(img, visualize=visualize)
+
+    def __call__(self, img: np.ndarray, visualize=False, use_cls=None):
+        ori_im = img.copy()
+
+        boxes = self.detect(img)
+        if len(boxes) == 0:
+            return [] if not visualize else ori_im
+
+        boxes = _sorted_boxes(boxes)
+
+        img_crop_list = []
+        for box in boxes:
+            crop = _get_rotate_crop_image(ori_im, np.array(box, dtype=np.float32))
+            img_crop_list.append(crop)
+
+        # Direction classifier
+        do_cls = self.use_angle_cls if use_cls is None else use_cls
+        if do_cls and self.cls_session is not None:
+            img_crop_list, cls_res, _ = self.classify(img_crop_list)
+
+        rec_res = self.recognize(img_crop_list)
+
+        results = []
+        for box, (text, conf) in zip(boxes, rec_res):
+            if conf >= self.drop_score:
+                results.append({"text": text, "confidence": round(conf, 4), "box": box.tolist()})
+
+        return draw_ocr_result(ori_im, results) if visualize else results
+
+
+# ============================================================================
+# 7. CLI
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(description="PP-OCRv6 ONNX Inference (standalone, no Paddle dependency)")
+    parser.add_argument("--det_onnx", type=str, default="onnx/det_inference_static_sim.onnx")
+    parser.add_argument("--rec_onnx", type=str, default="onnx/rec_inference_static_sim.onnx")
+    parser.add_argument("--char_dict", type=str, default="onnx/rec_inference.yml")
+    parser.add_argument("--image", required=True, help="Input image path")
+    parser.add_argument("--use_gpu", action="store_true")
+    parser.add_argument("--drop_score", type=float, default=0.5)
+    parser.add_argument("--det_limit_side_len", type=int, default=960)
+    parser.add_argument("--det_db_thresh", type=float, default=0.2)
+    parser.add_argument("--det_db_box_thresh", type=float, default=0.45)
+    parser.add_argument("--det_db_unclip_ratio", type=float, default=1.4)
+    parser.add_argument("--rec_batch_num", type=int, default=1)
+    parser.add_argument("--resize_mode", type=str, default="letterbox", choices=["letterbox", "stretch"])
+    # Classifier
+    parser.add_argument("--use_angle_cls", action="store_true", help="Enable direction classifier")
+    parser.add_argument("--cls_onnx", type=str, default="onnx/cls_mobile_sim_static.onnx", help="Classifer ONNX model path")
+    parser.add_argument("--cls_thresh", type=float, default=0.9, help="Angie classifier confidence threshold")
+    parser.add_argument("--cls_batch_num", type=int, default=1)
+    # Output
+    parser.add_argument("--visualize", action="store_true")
+    parser.add_argument("--output", type=str, default=None)
+    parser.add_argument("--json", type=str, default=None)
+
+    args = parser.parse_args()
+
+    char_dict_src = args.char_dict
+    if not os.path.exists(char_dict_src) and ("," in char_dict_src or char_dict_src.startswith("[")):
+        char_dict = [c.strip() for c in char_dict_src.strip("[]").split(",") if c.strip()]
+    else:
+        char_dict = char_dict_src
+
+    ocr = PPOCRv6Onnx(
+        det_onnx=args.det_onnx,
+        rec_onnx=args.rec_onnx,
+        char_dict=char_dict,
+        det_limit_side_len=args.det_limit_side_len,
+        det_db_thresh=args.det_db_thresh,
+        det_db_box_thresh=args.det_db_box_thresh,
+        det_db_unclip_ratio=args.det_db_unclip_ratio,
+        rec_batch_num=args.rec_batch_num,
+        use_angle_cls=args.use_angle_cls,
+        cls_onnx=args.cls_onnx,
+        cls_thresh=args.cls_thresh,
+        cls_batch_num=args.cls_batch_num,
+        drop_score=args.drop_score,
+        use_gpu=args.use_gpu,
+        resize_mode=args.resize_mode,
+    )
+
+    do_viz = args.visualize or args.output is not None
+    img = cv2.imread(args.image)
+    if img is None:
+        raise FileNotFoundError(f"Cannot read image: {args.image}")
+    results = ocr(img)
+
+    if do_viz:
+        vis = ocr(img, visualize=True)
+        out_path = args.output or "res-onnx.jpg"
+        cv2.imwrite(out_path, vis)
+        print(f"Annotated image saved to: {out_path}")
+
+    # if args.json:
+    #     with open(args.json, "w", encoding="utf-8") as f:
+    #         json.dump(results, f, ensure_ascii=False, indent=2)
+    #     print(f"Results saved to: {args.json}")
+    # else:
+    #     print(json.dumps(results, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

rec.json

@@ -0,0 +1,54 @@
+{
+  "input": "./onnx/rec_inference_static_sim.onnx",
+  "output_dir": "./rec-ax650-npu1",
+  "output_name": "rec_npu1.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU1",
+
+  // "onnx_opt": {
+  //   "disable_onnx_optimization": false,
+  //   "enable_onnxsim": false,
+  //   "model_check": true,
+  //   "disable_transformation_check": false
+  // },
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "DEFAULT",
+        "calibration_dataset": "./dataset/rec_quant.tar",
+        "calibration_format": "Image",
+        "calibration_size": -1,
+        "calibration_mean": [127.5, 127.5, 127.5],
+        "calibration_std": [127.5, 127.5, 127.5]
+      }
+    ],
+
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "Reference",
+    "conv_bias_data_type": "FP32",
+    "layer_configs": [
+      {
+        "start_tensor_names": ["DEFAULT"],
+        "end_tensor_names": ["DEFAULT"],
+        "data_type": "U16"
+      }
+    ]
+  },
+  "input_processors": [
+    {
+      "tensor_name": "DEFAULT",
+      "tensor_format": "BGR",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "FP32",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}

run_det_ax.py

@@ -0,0 +1,894 @@
+#!/usr/bin/env python3
+"""
+PP-OCRv6 Detection ONNX Inference & Evaluation (standalone, zero Paddle dependency)
+
+Dependencies:
+    numpy, opencv-python, onnxruntime, pyyaml, shapely, pyclipper
+
+Data format (same as PaddleOCR official):
+    Label file: image_path<TAB>json_label
+    json_label: [{"transcription": "text_or_###", "points": [[x,y]*4]}, ...]
+
+Usage:
+    # Single image inference
+    python ppocrv6_det_onnx.py --det_onnx det.onnx --image test.jpg --visualize
+
+    # Batch evaluation
+    python ppocrv6_det_onnx.py --det_onnx det.onnx \\
+        --label_file val.txt --dataset_root ./ocr_det_dataset_examples \\
+        --visualize --output_json result.json --verbose
+"""
+
+import argparse
+import json
+import math
+import os
+from collections import namedtuple
+from typing import List, Optional, Tuple
+
+import cv2
+import numpy as np
+import axengine as ort
+import yaml
+from shapely.geometry import Polygon
+import pyclipper
+
+
+def _get_dim_value(dim):
+    """Extract integer value from an ONNX Runtime dimension, returning 0 for dynamic dims."""
+    if dim is None:
+        return 0
+    if isinstance(dim, str):
+        return 0
+    if hasattr(dim, 'dim_value'):
+        return int(dim.dim_value) if dim.dim_value else 0
+    if hasattr(dim, 'dim_param'):
+        # named dim like "batch_size" → dynamic
+        return 0
+    try:
+        v = int(dim)
+        return v
+    except (TypeError, ValueError):
+        return 0
+
+
+# ============================================================================
+# 1. Detection Preprocessing
+# ============================================================================
+
+class _DetResizeForTest:
+    def __init__(self, limit_side_len=960, limit_type="max", max_side_limit=4000,
+                 image_shape=None, keep_ratio=False):
+        self.max_side_limit = max_side_limit
+        # resize_type=0: limit_side_len (dynamic input)
+        # resize_type=1: image_shape (fixed ONNX input)
+        if image_shape is not None:
+            self.resize_type = 1
+            self.image_shape = image_shape
+            self.keep_ratio = keep_ratio
+        else:
+            self.resize_type = 0
+            self.limit_side_len = limit_side_len
+            self.limit_type = limit_type
+
+    def _image_padding(self, im, value=0):
+        h, w, c = im.shape
+        im_pad = np.zeros((max(32, h), max(32, w), c), np.uint8) + value
+        im_pad[:h, :w, :] = im
+        return im_pad
+
+    def _resize_image_type0(self, img):
+        h, w, _ = img.shape
+        limit_side_len = self.limit_side_len
+
+        if self.limit_type == "max":
+            if max(h, w) > limit_side_len:
+                ratio = float(limit_side_len) / max(h, w)
+            else:
+                ratio = 1.0
+        elif self.limit_type == "min":
+            if min(h, w) < limit_side_len:
+                ratio = float(limit_side_len) / min(h, w)
+            else:
+                ratio = 1.0
+        elif self.limit_type == "resize_long":
+            ratio = float(limit_side_len) / max(h, w)
+        else:
+            raise ValueError(f"not support limit_type: {self.limit_type}")
+
+        resize_h = int(h * ratio)
+        resize_w = int(w * ratio)
+        if max(resize_h, resize_w) > self.max_side_limit:
+            ratio = float(self.max_side_limit) / max(resize_h, resize_w)
+            resize_h, resize_w = int(resize_h * ratio), int(resize_w * ratio)
+
+        resize_h = max(int(round(resize_h / 32) * 32), 32)
+        resize_w = max(int(round(resize_w / 32) * 32), 32)
+
+        if int(resize_w) <= 0 or int(resize_h) <= 0:
+            return None, (None, None)
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        ratio_h = resize_h / float(h)
+        ratio_w = resize_w / float(w)
+        return img, [ratio_h, ratio_w]
+
+    def _resize_image_type1(self, img):
+        """Direct resize to fixed [H, W]. Used when ONNX has fixed input dimensions."""
+        resize_h, resize_w = self.image_shape
+        ori_h, ori_w = img.shape[:2]
+        if self.keep_ratio:
+            resize_w = ori_w * resize_h / ori_h
+            N = math.ceil(resize_w / 32)
+            resize_w = N * 32
+        ratio_h = float(resize_h) / ori_h
+        ratio_w = float(resize_w) / ori_w
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        return img, [ratio_h, ratio_w]
+
+    def __call__(self, img):
+        src_h, src_w = img.shape[:2]
+        if sum([src_h, src_w]) < 64:
+            img = self._image_padding(img)
+        if self.resize_type == 1:
+            img, [ratio_h, ratio_w] = self._resize_image_type1(img)
+        else:
+            img, [ratio_h, ratio_w] = self._resize_image_type0(img)
+        shape = np.array([src_h, src_w, ratio_h, ratio_w])
+        return img, shape
+
+
+class _NormalizeImage:
+    def __init__(self, mean, std, scale=1.0 / 255.0, order="hwc"):
+        self.scale = np.float32(scale)
+        shape = (1, 1, 3) if order == "hwc" else (3, 1, 1)
+        self.mean = np.array(mean, dtype=np.float32).reshape(shape)
+        self.std = np.array(std, dtype=np.float32).reshape(shape)
+
+    def __call__(self, img):
+        return (img.astype("float32") * self.scale - self.mean) / self.std
+
+
+class _ToCHWImage:
+    def __call__(self, img):
+        return img.transpose((2, 0, 1))
+
+
+# ============================================================================
+# 2. Detection Postprocessing (DB)
+# ============================================================================
+
+class _DBPostProcess:
+    def __init__(
+        self,
+        thresh=0.3,
+        box_thresh=0.7,
+        max_candidates=1000,
+        unclip_ratio=2.0,
+        use_dilation=False,
+        score_mode="fast",
+    ):
+        self.thresh = thresh
+        self.box_thresh = box_thresh
+        self.max_candidates = max_candidates
+        self.unclip_ratio = unclip_ratio
+        self.min_size = 3
+        self.score_mode = score_mode
+        assert score_mode in ("slow", "fast")
+        self.dilation_kernel = None if not use_dilation else np.array([[1, 1], [1, 1]])
+
+    def _unclip(self, box, unclip_ratio):
+        poly = Polygon(box)
+        distance = poly.area * unclip_ratio / poly.length
+        offset = pyclipper.PyclipperOffset()
+        offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+        expanded = offset.Execute(distance)
+        return expanded
+
+    def _get_mini_boxes(self, contour):
+        bounding_box = cv2.minAreaRect(contour)
+        points = sorted(list(cv2.boxPoints(bounding_box)), key=lambda x: x[0])
+        i1, i2, i3, i4 = 0, 1, 2, 3
+        if points[1][1] > points[0][1]:
+            i1, i4 = 0, 1
+        else:
+            i1, i4 = 1, 0
+        if points[3][1] > points[2][1]:
+            i2, i3 = 2, 3
+        else:
+            i2, i3 = 3, 2
+        box = [points[i1], points[i2], points[i3], points[i4]]
+        return box, min(bounding_box[1])
+
+    def _box_score_fast(self, bitmap, _box):
+        h, w = bitmap.shape[:2]
+        box = _box.copy()
+        xmin = np.clip(np.floor(box[:, 0].min()).astype("int32"), 0, w - 1)
+        xmax = np.clip(np.ceil(box[:, 0].max()).astype("int32"), 0, w - 1)
+        ymin = np.clip(np.floor(box[:, 1].min()).astype("int32"), 0, h - 1)
+        ymax = np.clip(np.ceil(box[:, 1].max()).astype("int32"), 0, h - 1)
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        box[:, 0] = box[:, 0] - xmin
+        box[:, 1] = box[:, 1] - ymin
+        cv2.fillPoly(mask, box.reshape(1, -1, 2).astype("int32"), 1)
+        return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0]
+
+    def _boxes_from_bitmap(self, pred, _bitmap, dest_width, dest_height):
+        bitmap = _bitmap
+        height, width = bitmap.shape
+        outs = cv2.findContours(
+            (bitmap * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE
+        )
+        if len(outs) == 3:
+            _, contours, _ = outs
+        else:
+            contours, _ = outs
+        num_contours = min(len(contours), self.max_candidates)
+        boxes, scores = [], []
+        for index in range(num_contours):
+            contour = contours[index]
+            points, sside = self._get_mini_boxes(contour)
+            if sside < self.min_size:
+                continue
+            points = np.array(points)
+            if self.score_mode == "fast":
+                score = self._box_score_fast(pred, points.reshape(-1, 2))
+            else:
+                score = self._box_score_slow(pred, contour)
+            if self.box_thresh > score:
+                continue
+            box = self._unclip(points, self.unclip_ratio)
+            if len(box) > 1:
+                continue
+            box = np.array(box).reshape(-1, 1, 2)
+            box, sside = self._get_mini_boxes(box)
+            if sside < self.min_size + 2:
+                continue
+            box = np.array(box)
+            box[:, 0] = np.clip(np.round(box[:, 0] / width * dest_width), 0, dest_width)
+            box[:, 1] = np.clip(np.round(box[:, 1] / height * dest_height), 0, dest_height)
+            boxes.append(box.astype("int32"))
+            scores.append(score)
+        return np.array(boxes, dtype="int32"), scores
+
+    def _box_score_slow(self, bitmap, contour):
+        h, w = bitmap.shape[:2]
+        contour = contour.copy().reshape((-1, 2))
+        xmin = np.clip(np.min(contour[:, 0]), 0, w - 1)
+        xmax = np.clip(np.max(contour[:, 0]), 0, w - 1)
+        ymin = np.clip(np.min(contour[:, 1]), 0, h - 1)
+        ymax = np.clip(np.max(contour[:, 1]), 0, h - 1)
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        contour[:, 0] = contour[:, 0] - xmin
+        contour[:, 1] = contour[:, 1] - ymin
+        cv2.fillPoly(mask, contour.reshape(1, -1, 2).astype("int32"), 1)
+        return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0]
+
+    def __call__(self, pred, shape_list):
+        pred = pred[:, 0, :, :]
+        segmentation = pred > self.thresh
+        boxes_batch = []
+        for batch_index in range(pred.shape[0]):
+            src_h, src_w, ratio_h, ratio_w = shape_list[batch_index]
+            if self.dilation_kernel is not None:
+                mask = cv2.dilate(
+                    np.array(segmentation[batch_index]).astype(np.uint8),
+                    self.dilation_kernel,
+                )
+            else:
+                mask = segmentation[batch_index]
+            boxes, _ = self._boxes_from_bitmap(pred[batch_index], mask, src_w, src_h)
+            boxes_batch.append(boxes)
+        return boxes_batch
+
+
+# ============================================================================
+# 3. Detection IoU Evaluator (inline from eval_det_iou.py)
+# ============================================================================
+
+_Rectangle = namedtuple("Rectangle", "xmin ymin xmax ymax")
+
+
+def _get_intersection(pD, pG):
+    return Polygon(pD).intersection(Polygon(pG)).area
+
+
+def _get_union(pD, pG):
+    return Polygon(pD).union(Polygon(pG)).area
+
+
+def _get_iou(pD, pG):
+    return _get_intersection(pD, pG) / _get_union(pD, pG)
+
+
+class _DetectionIoUEvaluator:
+    def __init__(self, iou_constraint=0.5, area_precision_constraint=0.5):
+        self.iou_constraint = iou_constraint
+        self.area_precision_constraint = area_precision_constraint
+
+    def evaluate_image(self, gt: List[dict], det: List[dict]) -> dict:
+        gt_pols = []
+        gt_dont_care = []
+
+        for n, g in enumerate(gt):
+            points = g.get("points", [])
+            if not points:
+                continue
+            try:
+                if not Polygon(points).is_valid:
+                    continue
+            except Exception:
+                continue
+            gt_pols.append(points)
+            if g.get("ignore", False):
+                gt_dont_care.append(len(gt_pols) - 1)
+
+        det_pols = []
+        det_dont_care = []
+
+        for n, d in enumerate(det):
+            points = d.get("points", [])
+            if not points:
+                continue
+            try:
+                if not Polygon(points).is_valid:
+                    continue
+            except Exception:
+                continue
+            det_pols.append(points)
+            if gt_dont_care:
+                for dc_idx in gt_dont_care:
+                    dc_pol = gt_pols[dc_idx]
+                    inter = _get_intersection(dc_pol, points)
+                    pd_area = Polygon(points).area
+                    prec = 0 if pd_area == 0 else inter / pd_area
+                    if prec > self.area_precision_constraint:
+                        det_dont_care.append(len(det_pols) - 1)
+                        break
+
+        det_matched = 0
+
+        if gt_pols and det_pols:
+            iou_mat = np.empty([len(gt_pols), len(det_pols)])
+            for g_i, g_pts in enumerate(gt_pols):
+                for d_i, d_pts in enumerate(det_pols):
+                    iou_mat[g_i, d_i] = _get_iou(d_pts, g_pts)
+
+            gt_matched = np.zeros(len(gt_pols), dtype=np.uint8)
+            det_matched_arr = np.zeros(len(det_pols), dtype=np.uint8)
+            for g_i in range(len(gt_pols)):
+                for d_i in range(len(det_pols)):
+                    if (
+                        gt_matched[g_i] == 0
+                        and det_matched_arr[d_i] == 0
+                        and g_i not in gt_dont_care
+                        and d_i not in det_dont_care
+                    ):
+                        if iou_mat[g_i, d_i] > self.iou_constraint:
+                            gt_matched[g_i] = 1
+                            det_matched_arr[d_i] = 1
+                            det_matched += 1
+
+        num_gt_care = len(gt_pols) - len(gt_dont_care)
+        num_det_care = len(det_pols) - len(det_dont_care)
+
+        return {
+            "gt_care": num_gt_care,
+            "det_care": num_det_care,
+            "det_matched": det_matched,
+        }
+
+    def combine_results(self, results: List[dict]) -> dict:
+        num_gt = sum(r["gt_care"] for r in results)
+        num_det = sum(r["det_care"] for r in results)
+        matched = sum(r["det_matched"] for r in results)
+
+        recall = 0 if num_gt == 0 else float(matched) / num_gt
+        precision = 0 if num_det == 0 else float(matched) / num_det
+        hmean = (
+            0
+            if (precision + recall) == 0
+            else 2.0 * precision * recall / (precision + recall)
+        )
+
+        return {
+            "precision": precision,
+            "recall": recall,
+            "hmean": hmean,
+        }
+
+
+# ============================================================================
+# 4. Visualization
+# ============================================================================
+
+def draw_det_result(
+    img: np.ndarray,
+    det_boxes: np.ndarray,
+    gt_boxes: Optional[List[dict]] = None,
+    matched_pairs: Optional[List[Tuple[int, int]]] = None,
+    thickness: int = 2,
+) -> np.ndarray:
+    """Draw detection boxes on image with optional ground-truth and matching info.
+
+    Colors:
+        green  = matched detection
+        blue   = unmatched detection
+        red    = unmatched ground truth (missed)
+    """
+    vis = img.copy()
+
+    if gt_boxes is not None and matched_pairs is not None:
+        gt_matched = set()
+        det_matched = set()
+        for p in matched_pairs:
+            gt_matched.add(p["gt"])
+            det_matched.add(p["det"])
+
+        for i, d in enumerate(det_boxes):
+            box = np.array(d, dtype=np.int32).reshape((-1, 1, 2))
+            color = (0, 255, 0) if i in det_matched else (255, 0, 0)
+            cv2.polylines(vis, [box], True, color, thickness)
+
+        for i, g in enumerate(gt_boxes):
+            if g.get("ignore", False):
+                continue
+            if i not in gt_matched:
+                pts = np.array(g["points"], dtype=np.int32).reshape((-1, 1, 2))
+                cv2.polylines(vis, [pts], True, (0, 0, 255), max(thickness, 3))
+                # Draw dashed effect by alternating segments
+                cx, cy = int(np.mean(pts[:, 0, 0])), int(np.mean(pts[:, 0, 1]))
+                cv2.putText(vis, "MISS", (cx, cy),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 1)
+    else:
+        for box in det_boxes:
+            box = np.array(box, dtype=np.int32).reshape((-1, 1, 2))
+            cv2.polylines(vis, [box], True, (0, 255, 0), thickness)
+
+    return vis
+
+
+# ============================================================================
+# 5. Detection Engine
+# ============================================================================
+
+class PPOCRv6DetOnnx:
+
+    def __init__(
+        self,
+        det_onnx: str,
+        det_limit_side_len: int = 960,
+        det_db_thresh: float = 0.2,
+        det_db_box_thresh: float = 0.4,
+        det_db_unclip_ratio: float = 1.4,
+        det_max_candidates: int = 3000,
+        use_gpu: bool = False,
+        onnx_providers: Optional[List[str]] = None,
+        resize_mode: str = "letterbox",
+    ):
+        assert resize_mode in ("letterbox", "stretch"), f"invalid resize_mode: {resize_mode}"
+
+        self.session = ort.InferenceSession(det_onnx)
+        self.input_name = self.session.get_inputs()[0].name
+
+        # Detect fixed vs dynamic input dimensions
+        det_input = self.session.get_inputs()[0]
+        img_h = _get_dim_value(det_input.shape[2])
+        img_w = _get_dim_value(det_input.shape[3])
+
+        self._fixed_h = img_h if img_h > 0 else 0
+        self._fixed_w = img_w if img_w > 0 else 0
+
+        print(f"[PPOCRv6Det] ONNX input shape: {det_input.shape}, fixed_h={self._fixed_h}, fixed_w={self._fixed_w}, resize_mode={resize_mode}")
+
+        self._resize_mode = resize_mode
+
+        # Preprocessing: choose resize strategy
+        if self._fixed_h > 0 and self._fixed_w > 0:
+            # Fully fixed ONNX input — handled in _preprocess
+            self._resize_style = "fixed"
+        else:
+            # Dynamic or partially-fixed — ratio-preserving resize
+            self._resize = _DetResizeForTest(
+                limit_side_len=det_limit_side_len, limit_type="max"
+            )
+            self._resize_style = "dynamic"
+
+        self._normalize = _NormalizeImage(
+            mean=[0., 0., 0.],
+            std=[1.0, 1.0, 1.0],
+            scale=1.0,
+        )
+
+        self._to_chw = _ToCHWImage()
+        self._post = _DBPostProcess(
+            thresh=det_db_thresh,
+            box_thresh=det_db_box_thresh,
+            unclip_ratio=det_db_unclip_ratio,
+            max_candidates=det_max_candidates,
+        )
+
+    def _preprocess(self, img: np.ndarray):
+        src_h, src_w = img.shape[:2]
+        fixed_w = self._fixed_w
+        fixed_h = self._fixed_h
+
+        # Stretch mode: direct resize to fixed size (official PaddleOCR behavior)
+        if self._resize_mode == "stretch" and fixed_h > 0 and fixed_w > 0:
+            img_resized = cv2.resize(img, (fixed_w, fixed_h))
+            ratio_h = float(fixed_h) / src_h
+            ratio_w = float(fixed_w) / src_w
+            # Post-processing maps: origin = fm_coord / fm_dim * dest_dim
+            # For direct stretch, fm_dim corresponds uniformly to src_dim.
+            shape = np.array([src_h, src_w, ratio_h, ratio_w])
+
+        elif fixed_w > 0 or fixed_h > 0:
+            # Letterbox mode (default): ratio-preserving + pad to fixed size
+            ratios = []
+            if fixed_w > 0:
+                ratios.append(fixed_w / src_w)
+            if fixed_h > 0:
+                ratios.append(fixed_h / src_h)
+            ratio = min(ratios)
+            new_w = max(int(round(src_w * ratio / 32) * 32), 32)
+            new_h = max(int(round(src_h * ratio / 32) * 32), 32)
+            new_w = min(new_w, fixed_w) if fixed_w > 0 else new_w
+            new_h = min(new_h, fixed_h) if fixed_h > 0 else new_h
+
+            img_resized = cv2.resize(img, (new_w, new_h))
+            ratio_h = new_h / float(src_h)
+            ratio_w = new_w / float(src_w)
+
+            pad_h = max(0, fixed_h - new_h)
+            pad_w = max(0, fixed_w - new_w)
+            if pad_h > 0 or pad_w > 0:
+                img_resized = cv2.copyMakeBorder(
+                    img_resized, 0, pad_h, 0, pad_w,
+                    cv2.BORDER_CONSTANT, value=(0, 0, 0),
+                )
+
+            # Adjust shape for correct coordinate mapping after padding
+            adj_h = src_h * fixed_h / new_h if fixed_h > 0 else src_h
+            adj_w = src_w * fixed_w / new_w if fixed_w > 0 else src_w
+            shape = np.array([adj_h, adj_w, ratio_h, ratio_w])
+
+        else:
+            img_resized, shape = self._resize(img)
+
+        img_norm = self._normalize(img_resized)
+        img_chw = self._to_chw(img_norm)
+        tensor = np.expand_dims(img_chw.astype(np.float32), axis=0)
+        return tensor, shape
+
+    def _postprocess(self, output: np.ndarray, shape: np.ndarray):
+        shape_list = np.expand_dims(shape, axis=0)
+        boxes_batch = self._post(output, shape_list)
+        return boxes_batch[0]
+
+    def __call__(self, img: np.ndarray) -> np.ndarray:
+        """Detect text boxes. Returns (N, 4, 2) int32 array."""
+        tensor, shape = self._preprocess(img)
+        onnx_out = self.session.run(None, {self.input_name: tensor})
+        boxes = self._postprocess(onnx_out[0], shape)
+        return boxes
+
+    def predict_image(self, path: str) -> np.ndarray:
+        im = cv2.imread(path)
+        if im is None:
+            raise FileNotFoundError(f"Cannot read: {path}")
+        return self.__call__(im)
+
+
+# ============================================================================
+# 6. Evaluation
+# ============================================================================
+
+def evaluate(
+    det: PPOCRv6DetOnnx,
+    label_file: str,
+    dataset_root: str = "",
+    iou_constraint: float = 0.5,
+    verbose: bool = False,
+) -> dict:
+    """Evaluate detection against a PaddleOCR format label file.
+
+    Label format (one per line, tab-separated)::
+
+        rel/path/to/img.jpg<TAB>[{"transcription":"text_or_###","points":[[x,y]*4]}, ...]
+
+    "###" means ignored / don't-care region.
+
+    Returns:
+        dict: precision, recall, hmean, total_images, total_gt, total_det, det_matched, per_sample
+    """
+    samples = []
+    with open(label_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+            img_path = os.path.join(dataset_root, parts[0].strip())
+            try:
+                gt_label = json.loads(parts[1])
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(gt_label, list):
+                continue
+            samples.append((img_path, gt_label))
+
+    if not samples:
+        print("[WARN] No samples found in label file.")
+        return {
+            "precision": 0, "recall": 0, "hmean": 0,
+            "total_images": 0, "total_gt": 0, "total_det": 0, "det_matched": 0,
+            "per_sample": [],
+        }
+
+    evaluator = _DetectionIoUEvaluator(iou_constraint=iou_constraint)
+    per_sample = []
+    total_gt = 0
+    total_det = 0
+    total_matched = 0
+
+    for idx, (img_path, gt_label) in enumerate(samples):
+        img = cv2.imread(img_path)
+        if img is None:
+            print(f"[WARN] Cannot read {img_path}, skipping.")
+            per_sample.append({
+                "image": img_path, "error": "cannot read",
+                "gt_care": 0, "det_care": 0, "det_matched": 0,
+            })
+            continue
+
+        # Run detection
+        det_boxes = det(img)
+
+        # Prepare GT
+        gt_info = []
+        for g in gt_label:
+            pts = g.get("points", [])
+            if not pts or len(pts) < 4:
+                continue
+            is_ignored = g.get("transcription", "") == "###"
+            gt_info.append({"points": pts, "ignore": is_ignored})
+
+        # Prepare DET
+        det_info = [{"points": d.tolist()} for d in det_boxes]
+
+        # Evaluate
+        result = evaluator.evaluate_image(gt_info, det_info)
+        total_gt += result["gt_care"]
+        total_det += result["det_care"]
+        total_matched += result["det_matched"]
+
+        per_sample.append({
+            "image": img_path,
+            "gt_care": result["gt_care"],
+            "det_care": result["det_care"],
+            "det_matched": result["det_matched"],
+            "det_boxes": [d.tolist() for d in det_boxes],
+        })
+
+        if verbose:
+            miss = result["gt_care"] - result["det_matched"]
+            extra = result["det_care"] - result["det_matched"]
+            parts = [
+                f"gt={result['gt_care']}",
+                f"det={result['det_care']}",
+                f"match={result['det_matched']}",
+            ]
+            if miss > 0:
+                parts.append(f"MISS={miss}")
+            if extra > 0:
+                parts.append(f"EXTRA={extra}")
+            print(f"[{os.path.basename(img_path)}] " + " ".join(parts))
+
+    metrics = evaluator.combine_results(
+        [r for r in per_sample if "error" not in r]
+    )
+
+    return {
+        "precision": round(metrics["precision"], 6),
+        "recall": round(metrics["recall"], 6),
+        "hmean": round(metrics["hmean"], 6),
+        "total_images": len(samples),
+        "total_gt": total_gt,
+        "total_det": total_det,
+        "det_matched": total_matched,
+        "per_sample": per_sample,
+    }
+
+
+# ============================================================================
+# 7. CLI
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="PP-OCRv6 Detection ONNX – inference & evaluation"
+    )
+    # Model
+    parser.add_argument("--det_onnx", type=str,
+                        default="./axmodel/ax650/det_npu1.axmodel",
+                        help="Path to detection ONNX model")
+    parser.add_argument("--limit_side_len", type=int, default=960)
+    parser.add_argument("--det_db_thresh", type=float, default=0.2)
+    parser.add_argument("--det_db_box_thresh", type=float, default=0.45)
+    parser.add_argument("--det_db_unclip_ratio", type=float, default=1.4)
+    parser.add_argument("--use_gpu", action="store_true", help="Enable GPU inference")
+    parser.add_argument("--resize_mode", type=str, default="letterbox",
+                        choices=["letterbox", "stretch"],
+                        help="Resize strategy for fixed-size ONNX: letterbox (keep ratio+pad) or stretch (direct resize)")
+
+    # Single image mode
+    parser.add_argument("--image", type=str, default=None, help="Single image path")
+
+    # Evaluation mode
+    parser.add_argument("--label_file", type=str, 
+                        default='dataset/ocr_det_dataset_examples/val.txt',
+                        help="Label file (image_path<TAB>json_label per line)")
+    parser.add_argument("--dataset_root", type=str, 
+                        default="dataset/ocr_det_dataset_examples",
+                        help="Prefix directory for image paths in label file")
+
+    # Common
+    parser.add_argument("--visualize", action="store_true", help="Draw boxes on image")
+    parser.add_argument("--output", type=str, default=None,
+                        help="Save visualized image (implies --visualize)")
+    parser.add_argument("--verbose", action="store_true", help="Print per-image metrics")
+    parser.add_argument("--output_json", type=str, default=None,
+                        help="Save results to JSON file")
+
+    args = parser.parse_args()
+
+    det = PPOCRv6DetOnnx(
+        det_onnx=args.det_onnx,
+        det_limit_side_len=args.limit_side_len,
+        det_db_thresh=args.det_db_thresh,
+        det_db_box_thresh=args.det_db_box_thresh,
+        det_db_unclip_ratio=args.det_db_unclip_ratio,
+        use_gpu=args.use_gpu,
+        resize_mode=args.resize_mode,
+    )
+
+    # --- Single image mode ---
+    if args.image and not args.label_file:
+        img = cv2.imread(args.image)
+        if img is None:
+            raise FileNotFoundError(f"Cannot read: {args.image}")
+        boxes = det(img)
+        print(f"Detected {len(boxes)} text boxes:")
+        for i, box in enumerate(boxes):
+            print(f"  [{i}] {box.tolist()}")
+
+        do_viz = args.visualize or args.output
+        if do_viz:
+            vis = draw_det_result(img, boxes)
+            out_path = args.output or "det_result.jpg"
+            cv2.imwrite(out_path, vis)
+            print(f"Visualization saved to: {out_path}")
+
+        if args.output_json:
+            with open(args.output_json, "w") as f:
+                json.dump(
+                    {"image": args.image, "boxes": [b.tolist() for b in boxes]},
+                    f, indent=2,
+                )
+            print(f"Results saved to: {args.output_json}")
+        return
+
+    # --- Evaluation mode ---
+    if args.label_file:
+        metrics = evaluate(
+            det, args.label_file,
+            dataset_root=args.dataset_root,
+            verbose=args.verbose,
+        )
+
+        print()
+        print("=" * 60)
+        print("Evaluation Results")
+        print("=" * 60)
+        print(f"  Images:       {metrics['total_images']}")
+        print(f"  GT boxes:     {metrics['total_gt']}")
+        print(f"  DET boxes:    {metrics['total_det']}")
+        print(f"  Matched:      {metrics['det_matched']}")
+        print(f"  Precision:    {metrics['precision']:.4f} ({metrics['precision']*100:.2f}%)")
+        print(f"  Recall:       {metrics['recall']:.4f} ({metrics['recall']*100:.2f}%)")
+        print(f"  Hmean (F1):   {metrics['hmean']:.4f}")
+        print("=" * 60)
+
+        # Visualization for eval mode
+        do_viz = args.visualize or args.output
+        if do_viz:
+            out_dir = args.output if args.output else "det_eval_vis"
+            os.makedirs(out_dir, exist_ok=True)
+            for i, smp in enumerate(metrics["per_sample"]):
+                img = cv2.imread(smp["image"])
+                if img is None:
+                    continue
+                # Load GT boxes with matching info
+                with open(args.label_file, "r") as f:
+                    lines = f.readlines()
+                gt_label = []
+                for line in lines:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    parts = line.split("\t")
+                    if len(parts) < 2:
+                        continue
+                    if os.path.join(args.dataset_root, parts[0].strip()) == smp["image"]:
+                        gt_label = json.loads(parts[1])
+                        break
+
+                det_boxes = np.array(smp.get("det_boxes", []))
+                # Simple matching for visualization (re-run evaluate_image)
+                gt_info = []
+                for g in gt_label:
+                    pts = g.get("points", [])
+                    if not pts or len(pts) < 4:
+                        continue
+                    gt_info.append({
+                        "points": pts,
+                        "ignore": g.get("transcription", "") == "###",
+                    })
+                det_info = [{"points": d} for d in det_boxes.tolist()]
+
+                # Compute matches for coloring
+                matched_pairs = _compute_matched_pairs(gt_info, det_info)
+                vis = draw_det_result(img, det_boxes, gt_info, matched_pairs)
+                fname = os.path.basename(smp["image"])
+                cv2.imwrite(os.path.join(out_dir, fname), vis)
+
+            print(f"Visualization saved to: {out_dir}/")
+
+        if args.output_json:
+            out = {k: v for k, v in metrics.items() if k != "per_sample"}
+            out["per_sample"] = metrics["per_sample"]
+            with open(args.output_json, "w") as f:
+                json.dump(out, f, indent=2)
+            print(f"Results saved to: {args.output_json}")
+        return
+
+    parser.error("Either --image or --label_file must be provided.")
+
+
+def _compute_matched_pairs(gt_info, det_info, iou_thr=0.5):
+    """Compute matched GT-det pairs for visualization coloring."""
+    pairs = []
+    gt_pols = [g["points"] for g in gt_info if not g.get("ignore")]
+    det_pols = [d["points"] for d in det_info]
+    if not gt_pols or not det_pols:
+        return pairs
+
+    iou_mat = np.empty([len(gt_pols), len(det_pols)])
+    for g_i, g_pts in enumerate(gt_pols):
+        for d_i, d_pts in enumerate(det_pols):
+            try:
+                int_area = _get_intersection(d_pts, g_pts)
+                union_area = _get_union(d_pts, g_pts)
+                iou_mat[g_i, d_i] = int_area / union_area if union_area > 0 else 0
+            except Exception:
+                iou_mat[g_i, d_i] = 0
+
+    gt_used = set()
+    det_used = set()
+    # Greedy matching by descending IoU
+    flat = []
+    for g_i in range(len(gt_pols)):
+        for d_i in range(len(det_pols)):
+            flat.append((iou_mat[g_i, d_i], g_i, d_i))
+    flat.sort(key=lambda x: x[0], reverse=True)
+    for iou, g_i, d_i in flat:
+        if iou > iou_thr and g_i not in gt_used and d_i not in det_used:
+            pairs.append({"gt": g_i, "det": d_i})
+            gt_used.add(g_i)
+            det_used.add(d_i)
+    return pairs
+
+
+if __name__ == "__main__":
+    main()

run_det_onnx.py

@@ -0,0 +1,913 @@
+#!/usr/bin/env python3
+"""
+PP-OCRv6 Detection ONNX Inference & Evaluation (standalone, zero Paddle dependency)
+
+Dependencies:
+    numpy, opencv-python, onnxruntime, pyyaml, shapely, pyclipper
+
+Data format (same as PaddleOCR official):
+    Label file: image_path<TAB>json_label
+    json_label: [{"transcription": "text_or_###", "points": [[x,y]*4]}, ...]
+
+Usage:
+    # Single image inference
+    python ppocrv6_det_onnx.py --det_onnx det.onnx --image test.jpg --visualize
+
+    # Batch evaluation
+    python ppocrv6_det_onnx.py --det_onnx det.onnx \\
+        --label_file val.txt --dataset_root ./ocr_det_dataset_examples \\
+        --visualize --output_json result.json --verbose
+"""
+
+import argparse
+import json
+import math
+import os
+from collections import namedtuple
+from typing import List, Optional, Tuple
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+import yaml
+from shapely.geometry import Polygon
+import pyclipper
+
+
+def _get_dim_value(dim):
+    """Extract integer value from an ONNX Runtime dimension, returning 0 for dynamic dims."""
+    if dim is None:
+        return 0
+    if isinstance(dim, str):
+        return 0
+    if hasattr(dim, 'dim_value'):
+        return int(dim.dim_value) if dim.dim_value else 0
+    if hasattr(dim, 'dim_param'):
+        # named dim like "batch_size" → dynamic
+        return 0
+    try:
+        v = int(dim)
+        return v
+    except (TypeError, ValueError):
+        return 0
+
+
+# ============================================================================
+# 1. Detection Preprocessing
+# ============================================================================
+
+class _DetResizeForTest:
+    def __init__(self, limit_side_len=960, limit_type="max", max_side_limit=4000,
+                 image_shape=None, keep_ratio=False):
+        self.max_side_limit = max_side_limit
+        # resize_type=0: limit_side_len (dynamic input)
+        # resize_type=1: image_shape (fixed ONNX input)
+        if image_shape is not None:
+            self.resize_type = 1
+            self.image_shape = image_shape
+            self.keep_ratio = keep_ratio
+        else:
+            self.resize_type = 0
+            self.limit_side_len = limit_side_len
+            self.limit_type = limit_type
+
+    def _image_padding(self, im, value=0):
+        h, w, c = im.shape
+        im_pad = np.zeros((max(32, h), max(32, w), c), np.uint8) + value
+        im_pad[:h, :w, :] = im
+        return im_pad
+
+    def _resize_image_type0(self, img):
+        h, w, _ = img.shape
+        limit_side_len = self.limit_side_len
+
+        if self.limit_type == "max":
+            if max(h, w) > limit_side_len:
+                ratio = float(limit_side_len) / max(h, w)
+            else:
+                ratio = 1.0
+        elif self.limit_type == "min":
+            if min(h, w) < limit_side_len:
+                ratio = float(limit_side_len) / min(h, w)
+            else:
+                ratio = 1.0
+        elif self.limit_type == "resize_long":
+            ratio = float(limit_side_len) / max(h, w)
+        else:
+            raise ValueError(f"not support limit_type: {self.limit_type}")
+
+        resize_h = int(h * ratio)
+        resize_w = int(w * ratio)
+        if max(resize_h, resize_w) > self.max_side_limit:
+            ratio = float(self.max_side_limit) / max(resize_h, resize_w)
+            resize_h, resize_w = int(resize_h * ratio), int(resize_w * ratio)
+
+        resize_h = max(int(round(resize_h / 32) * 32), 32)
+        resize_w = max(int(round(resize_w / 32) * 32), 32)
+
+        if int(resize_w) <= 0 or int(resize_h) <= 0:
+            return None, (None, None)
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        ratio_h = resize_h / float(h)
+        ratio_w = resize_w / float(w)
+        return img, [ratio_h, ratio_w]
+
+    def _resize_image_type1(self, img):
+        """Direct resize to fixed [H, W]. Used when ONNX has fixed input dimensions."""
+        resize_h, resize_w = self.image_shape
+        ori_h, ori_w = img.shape[:2]
+        if self.keep_ratio:
+            resize_w = ori_w * resize_h / ori_h
+            N = math.ceil(resize_w / 32)
+            resize_w = N * 32
+        ratio_h = float(resize_h) / ori_h
+        ratio_w = float(resize_w) / ori_w
+        img = cv2.resize(img, (int(resize_w), int(resize_h)))
+        return img, [ratio_h, ratio_w]
+
+    def __call__(self, img):
+        src_h, src_w = img.shape[:2]
+        if sum([src_h, src_w]) < 64:
+            img = self._image_padding(img)
+        if self.resize_type == 1:
+            img, [ratio_h, ratio_w] = self._resize_image_type1(img)
+        else:
+            img, [ratio_h, ratio_w] = self._resize_image_type0(img)
+        shape = np.array([src_h, src_w, ratio_h, ratio_w])
+        return img, shape
+
+
+class _NormalizeImage:
+    def __init__(self, mean, std, scale=1.0 / 255.0, order="hwc"):
+        self.scale = np.float32(scale)
+        shape = (1, 1, 3) if order == "hwc" else (3, 1, 1)
+        self.mean = np.array(mean, dtype=np.float32).reshape(shape)
+        self.std = np.array(std, dtype=np.float32).reshape(shape)
+
+    def __call__(self, img):
+        return (img.astype("float32") * self.scale - self.mean) / self.std
+
+
+class _ToCHWImage:
+    def __call__(self, img):
+        return img.transpose((2, 0, 1))
+
+
+# ============================================================================
+# 2. Detection Postprocessing (DB)
+# ============================================================================
+
+class _DBPostProcess:
+    def __init__(
+        self,
+        thresh=0.3,
+        box_thresh=0.7,
+        max_candidates=1000,
+        unclip_ratio=2.0,
+        use_dilation=False,
+        score_mode="fast",
+    ):
+        self.thresh = thresh
+        self.box_thresh = box_thresh
+        self.max_candidates = max_candidates
+        self.unclip_ratio = unclip_ratio
+        self.min_size = 3
+        self.score_mode = score_mode
+        assert score_mode in ("slow", "fast")
+        self.dilation_kernel = None if not use_dilation else np.array([[1, 1], [1, 1]])
+
+    def _unclip(self, box, unclip_ratio):
+        poly = Polygon(box)
+        distance = poly.area * unclip_ratio / poly.length
+        offset = pyclipper.PyclipperOffset()
+        offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
+        expanded = offset.Execute(distance)
+        return expanded
+
+    def _get_mini_boxes(self, contour):
+        bounding_box = cv2.minAreaRect(contour)
+        points = sorted(list(cv2.boxPoints(bounding_box)), key=lambda x: x[0])
+        i1, i2, i3, i4 = 0, 1, 2, 3
+        if points[1][1] > points[0][1]:
+            i1, i4 = 0, 1
+        else:
+            i1, i4 = 1, 0
+        if points[3][1] > points[2][1]:
+            i2, i3 = 2, 3
+        else:
+            i2, i3 = 3, 2
+        box = [points[i1], points[i2], points[i3], points[i4]]
+        return box, min(bounding_box[1])
+
+    def _box_score_fast(self, bitmap, _box):
+        h, w = bitmap.shape[:2]
+        box = _box.copy()
+        xmin = np.clip(np.floor(box[:, 0].min()).astype("int32"), 0, w - 1)
+        xmax = np.clip(np.ceil(box[:, 0].max()).astype("int32"), 0, w - 1)
+        ymin = np.clip(np.floor(box[:, 1].min()).astype("int32"), 0, h - 1)
+        ymax = np.clip(np.ceil(box[:, 1].max()).astype("int32"), 0, h - 1)
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        box[:, 0] = box[:, 0] - xmin
+        box[:, 1] = box[:, 1] - ymin
+        cv2.fillPoly(mask, box.reshape(1, -1, 2).astype("int32"), 1)
+        return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0]
+
+    def _boxes_from_bitmap(self, pred, _bitmap, dest_width, dest_height):
+        bitmap = _bitmap
+        height, width = bitmap.shape
+        outs = cv2.findContours(
+            (bitmap * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE
+        )
+        if len(outs) == 3:
+            _, contours, _ = outs
+        else:
+            contours, _ = outs
+        num_contours = min(len(contours), self.max_candidates)
+        boxes, scores = [], []
+        for index in range(num_contours):
+            contour = contours[index]
+            points, sside = self._get_mini_boxes(contour)
+            if sside < self.min_size:
+                continue
+            points = np.array(points)
+            if self.score_mode == "fast":
+                score = self._box_score_fast(pred, points.reshape(-1, 2))
+            else:
+                score = self._box_score_slow(pred, contour)
+            if self.box_thresh > score:
+                continue
+            box = self._unclip(points, self.unclip_ratio)
+            if len(box) > 1:
+                continue
+            box = np.array(box).reshape(-1, 1, 2)
+            box, sside = self._get_mini_boxes(box)
+            if sside < self.min_size + 2:
+                continue
+            box = np.array(box)
+            box[:, 0] = np.clip(np.round(box[:, 0] / width * dest_width), 0, dest_width)
+            box[:, 1] = np.clip(np.round(box[:, 1] / height * dest_height), 0, dest_height)
+            boxes.append(box.astype("int32"))
+            scores.append(score)
+        return np.array(boxes, dtype="int32"), scores
+
+    def _box_score_slow(self, bitmap, contour):
+        h, w = bitmap.shape[:2]
+        contour = contour.copy().reshape((-1, 2))
+        xmin = np.clip(np.min(contour[:, 0]), 0, w - 1)
+        xmax = np.clip(np.max(contour[:, 0]), 0, w - 1)
+        ymin = np.clip(np.min(contour[:, 1]), 0, h - 1)
+        ymax = np.clip(np.max(contour[:, 1]), 0, h - 1)
+        mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8)
+        contour[:, 0] = contour[:, 0] - xmin
+        contour[:, 1] = contour[:, 1] - ymin
+        cv2.fillPoly(mask, contour.reshape(1, -1, 2).astype("int32"), 1)
+        return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0]
+
+    def __call__(self, pred, shape_list):
+        pred = pred[:, 0, :, :]
+        segmentation = pred > self.thresh
+        boxes_batch = []
+        for batch_index in range(pred.shape[0]):
+            src_h, src_w, ratio_h, ratio_w = shape_list[batch_index]
+            if self.dilation_kernel is not None:
+                mask = cv2.dilate(
+                    np.array(segmentation[batch_index]).astype(np.uint8),
+                    self.dilation_kernel,
+                )
+            else:
+                mask = segmentation[batch_index]
+            boxes, _ = self._boxes_from_bitmap(pred[batch_index], mask, src_w, src_h)
+            boxes_batch.append(boxes)
+        return boxes_batch
+
+
+# ============================================================================
+# 3. Detection IoU Evaluator (inline from eval_det_iou.py)
+# ============================================================================
+
+_Rectangle = namedtuple("Rectangle", "xmin ymin xmax ymax")
+
+
+def _get_intersection(pD, pG):
+    return Polygon(pD).intersection(Polygon(pG)).area
+
+
+def _get_union(pD, pG):
+    return Polygon(pD).union(Polygon(pG)).area
+
+
+def _get_iou(pD, pG):
+    return _get_intersection(pD, pG) / _get_union(pD, pG)
+
+
+class _DetectionIoUEvaluator:
+    def __init__(self, iou_constraint=0.5, area_precision_constraint=0.5):
+        self.iou_constraint = iou_constraint
+        self.area_precision_constraint = area_precision_constraint
+
+    def evaluate_image(self, gt: List[dict], det: List[dict]) -> dict:
+        gt_pols = []
+        gt_dont_care = []
+
+        for n, g in enumerate(gt):
+            points = g.get("points", [])
+            if not points:
+                continue
+            try:
+                if not Polygon(points).is_valid:
+                    continue
+            except Exception:
+                continue
+            gt_pols.append(points)
+            if g.get("ignore", False):
+                gt_dont_care.append(len(gt_pols) - 1)
+
+        det_pols = []
+        det_dont_care = []
+
+        for n, d in enumerate(det):
+            points = d.get("points", [])
+            if not points:
+                continue
+            try:
+                if not Polygon(points).is_valid:
+                    continue
+            except Exception:
+                continue
+            det_pols.append(points)
+            if gt_dont_care:
+                for dc_idx in gt_dont_care:
+                    dc_pol = gt_pols[dc_idx]
+                    inter = _get_intersection(dc_pol, points)
+                    pd_area = Polygon(points).area
+                    prec = 0 if pd_area == 0 else inter / pd_area
+                    if prec > self.area_precision_constraint:
+                        det_dont_care.append(len(det_pols) - 1)
+                        break
+
+        det_matched = 0
+
+        if gt_pols and det_pols:
+            iou_mat = np.empty([len(gt_pols), len(det_pols)])
+            for g_i, g_pts in enumerate(gt_pols):
+                for d_i, d_pts in enumerate(det_pols):
+                    iou_mat[g_i, d_i] = _get_iou(d_pts, g_pts)
+
+            gt_matched = np.zeros(len(gt_pols), dtype=np.uint8)
+            det_matched_arr = np.zeros(len(det_pols), dtype=np.uint8)
+            for g_i in range(len(gt_pols)):
+                for d_i in range(len(det_pols)):
+                    if (
+                        gt_matched[g_i] == 0
+                        and det_matched_arr[d_i] == 0
+                        and g_i not in gt_dont_care
+                        and d_i not in det_dont_care
+                    ):
+                        if iou_mat[g_i, d_i] > self.iou_constraint:
+                            gt_matched[g_i] = 1
+                            det_matched_arr[d_i] = 1
+                            det_matched += 1
+
+        num_gt_care = len(gt_pols) - len(gt_dont_care)
+        num_det_care = len(det_pols) - len(det_dont_care)
+
+        return {
+            "gt_care": num_gt_care,
+            "det_care": num_det_care,
+            "det_matched": det_matched,
+        }
+
+    def combine_results(self, results: List[dict]) -> dict:
+        num_gt = sum(r["gt_care"] for r in results)
+        num_det = sum(r["det_care"] for r in results)
+        matched = sum(r["det_matched"] for r in results)
+
+        recall = 0 if num_gt == 0 else float(matched) / num_gt
+        precision = 0 if num_det == 0 else float(matched) / num_det
+        hmean = (
+            0
+            if (precision + recall) == 0
+            else 2.0 * precision * recall / (precision + recall)
+        )
+
+        return {
+            "precision": precision,
+            "recall": recall,
+            "hmean": hmean,
+        }
+
+
+# ============================================================================
+# 4. Visualization
+# ============================================================================
+
+def draw_det_result(
+    img: np.ndarray,
+    det_boxes: np.ndarray,
+    gt_boxes: Optional[List[dict]] = None,
+    matched_pairs: Optional[List[Tuple[int, int]]] = None,
+    thickness: int = 2,
+) -> np.ndarray:
+    """Draw detection boxes on image with optional ground-truth and matching info.
+
+    Colors:
+        green  = matched detection
+        blue   = unmatched detection
+        red    = unmatched ground truth (missed)
+    """
+    vis = img.copy()
+
+    if gt_boxes is not None and matched_pairs is not None:
+        gt_matched = set()
+        det_matched = set()
+        for p in matched_pairs:
+            gt_matched.add(p["gt"])
+            det_matched.add(p["det"])
+
+        for i, d in enumerate(det_boxes):
+            box = np.array(d, dtype=np.int32).reshape((-1, 1, 2))
+            color = (0, 255, 0) if i in det_matched else (255, 0, 0)
+            cv2.polylines(vis, [box], True, color, thickness)
+
+        for i, g in enumerate(gt_boxes):
+            if g.get("ignore", False):
+                continue
+            if i not in gt_matched:
+                pts = np.array(g["points"], dtype=np.int32).reshape((-1, 1, 2))
+                cv2.polylines(vis, [pts], True, (0, 0, 255), max(thickness, 3))
+                # Draw dashed effect by alternating segments
+                cx, cy = int(np.mean(pts[:, 0, 0])), int(np.mean(pts[:, 0, 1]))
+                cv2.putText(vis, "MISS", (cx, cy),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 1)
+    else:
+        for box in det_boxes:
+            box = np.array(box, dtype=np.int32).reshape((-1, 1, 2))
+            cv2.polylines(vis, [box], True, (0, 255, 0), thickness)
+
+    return vis
+
+
+# ============================================================================
+# 5. Detection Engine
+# ============================================================================
+
+class PPOCRv6DetOnnx:
+
+    def __init__(
+        self,
+        det_onnx: str,
+        det_limit_side_len: int = 960,
+        det_db_thresh: float = 0.2,
+        det_db_box_thresh: float = 0.4,
+        det_db_unclip_ratio: float = 1.4,
+        det_max_candidates: int = 3000,
+        use_gpu: bool = False,
+        onnx_providers: Optional[List[str]] = None,
+        resize_mode: str = "letterbox",
+    ):
+        assert resize_mode in ("letterbox", "stretch"), f"invalid resize_mode: {resize_mode}"
+        # ONNX session
+        if onnx_providers is None:
+            onnx_providers = (
+                ["CUDAExecutionProvider", "CPUExecutionProvider"]
+                if use_gpu
+                else ["CPUExecutionProvider"]
+            )
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        self.session = ort.InferenceSession(
+            det_onnx, sess_options=sess_options, providers=onnx_providers
+        )
+        self.input_name = self.session.get_inputs()[0].name
+
+        # Detect fixed vs dynamic input dimensions
+        det_input = self.session.get_inputs()[0]
+        img_h = _get_dim_value(det_input.shape[2])
+        img_w = _get_dim_value(det_input.shape[3])
+
+        # Fallback: try onnx.load() if ORT returned ambiguous dims
+        if img_h == 0 and img_w == 0:
+            try:
+                import onnx
+                m = onnx.load(det_onnx)
+                inp = m.graph.input[0]
+                dims = inp.type.tensor_type.shape.dim
+                img_h = dims[2].dim_value if len(dims) > 2 else 0
+                img_w = dims[3].dim_value if len(dims) > 3 else 0
+            except Exception:
+                pass
+
+        self._fixed_h = img_h if img_h > 0 else 0
+        self._fixed_w = img_w if img_w > 0 else 0
+
+        print(f"[PPOCRv6Det] ONNX input shape: {det_input.shape}, fixed_h={self._fixed_h}, fixed_w={self._fixed_w}, resize_mode={resize_mode}")
+
+        self._resize_mode = resize_mode
+
+        # Preprocessing: choose resize strategy
+        if self._fixed_h > 0 and self._fixed_w > 0:
+            # Fully fixed ONNX input — handled in _preprocess
+            self._resize_style = "fixed"
+        else:
+            # Dynamic or partially-fixed — ratio-preserving resize
+            self._resize = _DetResizeForTest(
+                limit_side_len=det_limit_side_len, limit_type="max"
+            )
+            self._resize_style = "dynamic"
+        self._normalize = _NormalizeImage(
+            mean=[0.485, 0.456, 0.406],
+            std=[0.229, 0.224, 0.225],
+        )
+        self._to_chw = _ToCHWImage()
+        self._post = _DBPostProcess(
+            thresh=det_db_thresh,
+            box_thresh=det_db_box_thresh,
+            unclip_ratio=det_db_unclip_ratio,
+            max_candidates=det_max_candidates,
+        )
+
+    def _preprocess(self, img: np.ndarray):
+        src_h, src_w = img.shape[:2]
+        fixed_w = self._fixed_w
+        fixed_h = self._fixed_h
+
+        # Stretch mode: direct resize to fixed size (official PaddleOCR behavior)
+        if self._resize_mode == "stretch" and fixed_h > 0 and fixed_w > 0:
+            img_resized = cv2.resize(img, (fixed_w, fixed_h))
+            ratio_h = float(fixed_h) / src_h
+            ratio_w = float(fixed_w) / src_w
+            # Post-processing maps: origin = fm_coord / fm_dim * dest_dim
+            # For direct stretch, fm_dim corresponds uniformly to src_dim.
+            shape = np.array([src_h, src_w, ratio_h, ratio_w])
+
+        elif fixed_w > 0 or fixed_h > 0:
+            # Letterbox mode (default): ratio-preserving + pad to fixed size
+            ratios = []
+            if fixed_w > 0:
+                ratios.append(fixed_w / src_w)
+            if fixed_h > 0:
+                ratios.append(fixed_h / src_h)
+            ratio = min(ratios)
+            new_w = max(int(round(src_w * ratio / 32) * 32), 32)
+            new_h = max(int(round(src_h * ratio / 32) * 32), 32)
+            new_w = min(new_w, fixed_w) if fixed_w > 0 else new_w
+            new_h = min(new_h, fixed_h) if fixed_h > 0 else new_h
+
+            img_resized = cv2.resize(img, (new_w, new_h))
+            ratio_h = new_h / float(src_h)
+            ratio_w = new_w / float(src_w)
+
+            pad_h = max(0, fixed_h - new_h)
+            pad_w = max(0, fixed_w - new_w)
+            if pad_h > 0 or pad_w > 0:
+                img_resized = cv2.copyMakeBorder(
+                    img_resized, 0, pad_h, 0, pad_w,
+                    cv2.BORDER_CONSTANT, value=(0, 0, 0),
+                )
+
+            # Adjust shape for correct coordinate mapping after padding
+            adj_h = src_h * fixed_h / new_h if fixed_h > 0 else src_h
+            adj_w = src_w * fixed_w / new_w if fixed_w > 0 else src_w
+            shape = np.array([adj_h, adj_w, ratio_h, ratio_w])
+
+        else:
+            img_resized, shape = self._resize(img)
+
+        img_norm = self._normalize(img_resized)
+        img_chw = self._to_chw(img_norm)
+        tensor = np.expand_dims(img_chw.astype(np.float32), axis=0)
+        return tensor, shape
+
+    def _postprocess(self, output: np.ndarray, shape: np.ndarray):
+        shape_list = np.expand_dims(shape, axis=0)
+        boxes_batch = self._post(output, shape_list)
+        return boxes_batch[0]
+
+    def __call__(self, img: np.ndarray) -> np.ndarray:
+        """Detect text boxes. Returns (N, 4, 2) int32 array."""
+        tensor, shape = self._preprocess(img)
+        onnx_out = self.session.run(None, {self.input_name: tensor})
+        boxes = self._postprocess(onnx_out[0], shape)
+        return boxes
+
+    def predict_image(self, path: str) -> np.ndarray:
+        im = cv2.imread(path)
+        if im is None:
+            raise FileNotFoundError(f"Cannot read: {path}")
+        return self.__call__(im)
+
+
+# ============================================================================
+# 6. Evaluation
+# ============================================================================
+
+def evaluate(
+    det: PPOCRv6DetOnnx,
+    label_file: str,
+    dataset_root: str = "",
+    iou_constraint: float = 0.5,
+    verbose: bool = False,
+) -> dict:
+    """Evaluate detection against a PaddleOCR format label file.
+
+    Label format (one per line, tab-separated)::
+
+        rel/path/to/img.jpg<TAB>[{"transcription":"text_or_###","points":[[x,y]*4]}, ...]
+
+    "###" means ignored / don't-care region.
+
+    Returns:
+        dict: precision, recall, hmean, total_images, total_gt, total_det, det_matched, per_sample
+    """
+    samples = []
+    with open(label_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+            img_path = os.path.join(dataset_root, parts[0].strip())
+            try:
+                gt_label = json.loads(parts[1])
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(gt_label, list):
+                continue
+            samples.append((img_path, gt_label))
+
+    if not samples:
+        print("[WARN] No samples found in label file.")
+        return {
+            "precision": 0, "recall": 0, "hmean": 0,
+            "total_images": 0, "total_gt": 0, "total_det": 0, "det_matched": 0,
+            "per_sample": [],
+        }
+
+    evaluator = _DetectionIoUEvaluator(iou_constraint=iou_constraint)
+    per_sample = []
+    total_gt = 0
+    total_det = 0
+    total_matched = 0
+
+    for idx, (img_path, gt_label) in enumerate(samples):
+        img = cv2.imread(img_path)
+        if img is None:
+            print(f"[WARN] Cannot read {img_path}, skipping.")
+            per_sample.append({
+                "image": img_path, "error": "cannot read",
+                "gt_care": 0, "det_care": 0, "det_matched": 0,
+            })
+            continue
+
+        # Run detection
+        det_boxes = det(img)
+
+        # Prepare GT
+        gt_info = []
+        for g in gt_label:
+            pts = g.get("points", [])
+            if not pts or len(pts) < 4:
+                continue
+            is_ignored = g.get("transcription", "") == "###"
+            gt_info.append({"points": pts, "ignore": is_ignored})
+
+        # Prepare DET
+        det_info = [{"points": d.tolist()} for d in det_boxes]
+
+        # Evaluate
+        result = evaluator.evaluate_image(gt_info, det_info)
+        total_gt += result["gt_care"]
+        total_det += result["det_care"]
+        total_matched += result["det_matched"]
+
+        per_sample.append({
+            "image": img_path,
+            "gt_care": result["gt_care"],
+            "det_care": result["det_care"],
+            "det_matched": result["det_matched"],
+            "det_boxes": [d.tolist() for d in det_boxes],
+        })
+
+        if verbose:
+            miss = result["gt_care"] - result["det_matched"]
+            extra = result["det_care"] - result["det_matched"]
+            parts = [
+                f"gt={result['gt_care']}",
+                f"det={result['det_care']}",
+                f"match={result['det_matched']}",
+            ]
+            if miss > 0:
+                parts.append(f"MISS={miss}")
+            if extra > 0:
+                parts.append(f"EXTRA={extra}")
+            print(f"[{os.path.basename(img_path)}] " + " ".join(parts))
+
+    metrics = evaluator.combine_results(
+        [r for r in per_sample if "error" not in r]
+    )
+
+    return {
+        "precision": round(metrics["precision"], 6),
+        "recall": round(metrics["recall"], 6),
+        "hmean": round(metrics["hmean"], 6),
+        "total_images": len(samples),
+        "total_gt": total_gt,
+        "total_det": total_det,
+        "det_matched": total_matched,
+        "per_sample": per_sample,
+    }
+
+
+# ============================================================================
+# 7. CLI
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="PP-OCRv6 Detection ONNX – inference & evaluation"
+    )
+    # Model
+    parser.add_argument("--det_onnx", type=str,
+                        default="onnx/det_inference_static_sim.onnx",
+                        help="Path to detection ONNX model")
+    parser.add_argument("--limit_side_len", type=int, default=960)
+    parser.add_argument("--det_db_thresh", type=float, default=0.2)
+    parser.add_argument("--det_db_box_thresh", type=float, default=0.45)
+    parser.add_argument("--det_db_unclip_ratio", type=float, default=1.4)
+    parser.add_argument("--use_gpu", action="store_true", help="Enable GPU inference")
+    parser.add_argument("--resize_mode", type=str, default="letterbox",
+                        choices=["letterbox", "stretch"],
+                        help="Resize strategy for fixed-size ONNX: letterbox (keep ratio+pad) or stretch (direct resize)")
+
+    # Single image mode
+    parser.add_argument("--image", type=str, default=None, help="Single image path")
+
+    # Evaluation mode
+    parser.add_argument("--label_file", type=str, 
+                        default='dataset/ocr_det_dataset_examples/val.txt',
+                        help="Label file (image_path<TAB>json_label per line)")
+    parser.add_argument("--dataset_root", type=str, 
+                        default="dataset/ocr_det_dataset_examples",
+                        help="Prefix directory for image paths in label file")
+
+    # Common
+    parser.add_argument("--visualize", action="store_true", help="Draw boxes on image")
+    parser.add_argument("--output", type=str, default=None,
+                        help="Save visualized image (implies --visualize)")
+    parser.add_argument("--verbose", action="store_true", help="Print per-image metrics")
+    parser.add_argument("--output_json", type=str, default=None,
+                        help="Save results to JSON file")
+
+    args = parser.parse_args()
+
+    det = PPOCRv6DetOnnx(
+        det_onnx=args.det_onnx,
+        det_limit_side_len=args.limit_side_len,
+        det_db_thresh=args.det_db_thresh,
+        det_db_box_thresh=args.det_db_box_thresh,
+        det_db_unclip_ratio=args.det_db_unclip_ratio,
+        use_gpu=args.use_gpu,
+        resize_mode=args.resize_mode,
+    )
+
+    # --- Single image mode ---
+    if args.image and not args.label_file:
+        img = cv2.imread(args.image)
+        if img is None:
+            raise FileNotFoundError(f"Cannot read: {args.image}")
+        boxes = det(img)
+        print(f"Detected {len(boxes)} text boxes:")
+        for i, box in enumerate(boxes):
+            print(f"  [{i}] {box.tolist()}")
+
+        do_viz = args.visualize or args.output
+        if do_viz:
+            vis = draw_det_result(img, boxes)
+            out_path = args.output or "det_result.jpg"
+            cv2.imwrite(out_path, vis)
+            print(f"Visualization saved to: {out_path}")
+
+        if args.output_json:
+            with open(args.output_json, "w") as f:
+                json.dump(
+                    {"image": args.image, "boxes": [b.tolist() for b in boxes]},
+                    f, indent=2,
+                )
+            print(f"Results saved to: {args.output_json}")
+        return
+
+    # --- Evaluation mode ---
+    if args.label_file:
+        metrics = evaluate(
+            det, args.label_file,
+            dataset_root=args.dataset_root,
+            verbose=args.verbose,
+        )
+
+        print()
+        print("=" * 60)
+        print("Evaluation Results")
+        print("=" * 60)
+        print(f"  Images:       {metrics['total_images']}")
+        print(f"  GT boxes:     {metrics['total_gt']}")
+        print(f"  DET boxes:    {metrics['total_det']}")
+        print(f"  Matched:      {metrics['det_matched']}")
+        print(f"  Precision:    {metrics['precision']:.4f} ({metrics['precision']*100:.2f}%)")
+        print(f"  Recall:       {metrics['recall']:.4f} ({metrics['recall']*100:.2f}%)")
+        print(f"  Hmean (F1):   {metrics['hmean']:.4f}")
+        print("=" * 60)
+
+        # Visualization for eval mode
+        do_viz = args.visualize or args.output
+        if do_viz:
+            out_dir = args.output if args.output else "det_eval_vis"
+            os.makedirs(out_dir, exist_ok=True)
+            for i, smp in enumerate(metrics["per_sample"]):
+                img = cv2.imread(smp["image"])
+                if img is None:
+                    continue
+                # Load GT boxes with matching info
+                with open(args.label_file, "r") as f:
+                    lines = f.readlines()
+                gt_label = []
+                for line in lines:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    parts = line.split("\t")
+                    if len(parts) < 2:
+                        continue
+                    if os.path.join(args.dataset_root, parts[0].strip()) == smp["image"]:
+                        gt_label = json.loads(parts[1])
+                        break
+
+                det_boxes = np.array(smp.get("det_boxes", []))
+                # Simple matching for visualization (re-run evaluate_image)
+                gt_info = []
+                for g in gt_label:
+                    pts = g.get("points", [])
+                    if not pts or len(pts) < 4:
+                        continue
+                    gt_info.append({
+                        "points": pts,
+                        "ignore": g.get("transcription", "") == "###",
+                    })
+                det_info = [{"points": d} for d in det_boxes.tolist()]
+
+                # Compute matches for coloring
+                matched_pairs = _compute_matched_pairs(gt_info, det_info)
+                vis = draw_det_result(img, det_boxes, gt_info, matched_pairs)
+                fname = os.path.basename(smp["image"])
+                cv2.imwrite(os.path.join(out_dir, fname), vis)
+
+            print(f"Visualization saved to: {out_dir}/")
+
+        if args.output_json:
+            out = {k: v for k, v in metrics.items() if k != "per_sample"}
+            out["per_sample"] = metrics["per_sample"]
+            with open(args.output_json, "w") as f:
+                json.dump(out, f, indent=2)
+            print(f"Results saved to: {args.output_json}")
+        return
+
+    parser.error("Either --image or --label_file must be provided.")
+
+
+def _compute_matched_pairs(gt_info, det_info, iou_thr=0.5):
+    """Compute matched GT-det pairs for visualization coloring."""
+    pairs = []
+    gt_pols = [g["points"] for g in gt_info if not g.get("ignore")]
+    det_pols = [d["points"] for d in det_info]
+    if not gt_pols or not det_pols:
+        return pairs
+
+    iou_mat = np.empty([len(gt_pols), len(det_pols)])
+    for g_i, g_pts in enumerate(gt_pols):
+        for d_i, d_pts in enumerate(det_pols):
+            try:
+                int_area = _get_intersection(d_pts, g_pts)
+                union_area = _get_union(d_pts, g_pts)
+                iou_mat[g_i, d_i] = int_area / union_area if union_area > 0 else 0
+            except Exception:
+                iou_mat[g_i, d_i] = 0
+
+    gt_used = set()
+    det_used = set()
+    # Greedy matching by descending IoU
+    flat = []
+    for g_i in range(len(gt_pols)):
+        for d_i in range(len(det_pols)):
+            flat.append((iou_mat[g_i, d_i], g_i, d_i))
+    flat.sort(key=lambda x: x[0], reverse=True)
+    for iou, g_i, d_i in flat:
+        if iou > iou_thr and g_i not in gt_used and d_i not in det_used:
+            pairs.append({"gt": g_i, "det": d_i})
+            gt_used.add(g_i)
+            det_used.add(d_i)
+    return pairs
+
+
+if __name__ == "__main__":
+    main()

run_rec_ax.py

@@ -0,0 +1,377 @@
+#!/usr/bin/env python3
+"""
+PP-OCRv6 Recognition AX Inference (one-by-one, batch=1 only)
+
+Dependencies:
+    numpy, opencv-python, axengine, pyyaml, tqdm
+
+Usage:
+    # Single image inference
+    python ppocrv6_rec_ax-one.py --rec_onnx rec.axmodel --char_dict inference.yml --image crop.png
+
+    # Batch evaluation
+    python ppocrv6_rec_ax-one.py --rec_onnx rec.axmodel --char_dict inference.yml \\
+        --label_file labels.txt --dataset_root ./crops/ \\
+        --output_json result.json --verbose
+"""
+
+import argparse
+import math
+import os
+from typing import List, Optional, Tuple, Union
+
+import cv2
+import numpy as np
+import axengine as ax
+import yaml
+from tqdm import tqdm
+
+
+# ============================================================================
+# 1. Utilities
+# ============================================================================
+
+def _edit_distance(pred: str, target: str) -> Tuple[int, float]:
+    m, n = len(pred), len(target)
+    if m == 0:
+        return n, 1.0
+    if n == 0:
+        return m, 1.0
+    dp = list(range(n + 1))
+    for i in range(1, m + 1):
+        prev = dp[0]
+        dp[0] = i
+        for j in range(1, n + 1):
+            temp = dp[j]
+            if pred[i - 1] == target[j - 1]:
+                dp[j] = prev
+            else:
+                dp[j] = 1 + min(prev, dp[j], dp[j - 1])
+            prev = temp
+    distance = dp[n]
+    normalized = distance / max(m, n)
+    return distance, normalized
+
+
+def _load_char_dict(source: Union[str, List[str]]) -> List[str]:
+    if isinstance(source, list):
+        return list(source)
+    ext = os.path.splitext(source)[1].lower()
+    if ext in (".yml", ".yaml"):
+        with open(source, "r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f)
+        dic = cfg.get("PostProcess", {}).get("character_dict", [])
+        if not dic:
+            raise ValueError(f"No PostProcess.character_dict found in {source}")
+        return dic
+    elif ext == ".txt":
+        with open(source, "r", encoding="utf-8") as f:
+            return [line.strip("\n\r") for line in f.readlines()]
+    else:
+        raise ValueError(
+            f"Unsupported char_dict source: {source}. Use .yml, .txt, or list."
+        )
+
+
+def _resize_norm_img(
+    img: np.ndarray,
+    image_shape: Tuple[int, int, int] = (3, 48, 320),
+) -> np.ndarray:
+    imgC, imgH, imgW = image_shape
+    h, w = img.shape[:2]
+    max_wh_ratio = imgW * 1.0 / imgH
+    ratio = w * 1.0 / h
+    max_wh_ratio = max(max_wh_ratio, ratio)
+    max_wh_ratio = min(max_wh_ratio, imgW / imgH)
+    target_w = int(imgH * max_wh_ratio)
+
+    if math.ceil(imgH * ratio) > target_w:
+        resized_w = target_w
+    else:
+        resized_w = int(math.ceil(imgH * ratio))
+
+    resized = cv2.resize(img, (resized_w, imgH))
+    resized = resized.astype("float32")
+    resized = resized.transpose((2, 0, 1)) 
+    # resized /= 255.0
+    # resized -= 0.5
+    # resized /= 0.5
+    padded = np.zeros((imgC, imgH, target_w), dtype=np.float32)
+    padded[:, :, 0:resized_w] = resized
+    return padded
+
+
+# ============================================================================
+# 2. CTC Decoder
+# ============================================================================
+
+class _CTCLabelDecode:
+    """CTC greedy decoder for recognition output."""
+
+    def __init__(self, character_list: List[str], use_space_char: bool = True):
+        self.character_str = list(character_list)
+        if use_space_char:
+            self.character_str.append(" ")
+        dict_character = ["blank"] + self.character_str
+        self.character = dict_character
+        self.dict = {char: i for i, char in enumerate(dict_character)}
+
+    def decode(
+        self,
+        text_index: np.ndarray,
+        text_prob: Optional[np.ndarray] = None,
+        is_remove_duplicate: bool = True,
+    ) -> List[Tuple[str, float]]:
+        result_list = []
+        batch_size = len(text_index)
+        for batch_idx in range(batch_size):
+            selection = np.ones(len(text_index[batch_idx]), dtype=bool)
+            if is_remove_duplicate:
+                selection[1:] = text_index[batch_idx][1:] != text_index[batch_idx][:-1]
+            selection &= text_index[batch_idx] != 0
+            char_list = [
+                self.character[int(tid)]
+                for tid in text_index[batch_idx][selection]
+            ]
+            if text_prob is not None:
+                conf_list = text_prob[batch_idx][selection]
+            else:
+                conf_list = np.ones(len(selection), dtype=np.float32)
+            if len(conf_list) == 0:
+                conf_list = np.array([0.0], dtype=np.float32)
+            text = "".join(char_list)
+            result_list.append((text, float(np.mean(conf_list))))
+        return result_list
+
+    def __call__(self, preds: np.ndarray) -> List[Tuple[str, float]]:
+        preds_idx = preds.argmax(axis=2)
+        preds_prob = preds.max(axis=2)
+        return self.decode(preds_idx, preds_prob, is_remove_duplicate=True)
+
+
+# ============================================================================
+# 3. Recognition Engine (one-by-one)
+# ============================================================================
+
+class PPOCRv6RecOne:
+    """Recognition engine for batch=1 AX model.
+    
+    Flow: load image → preprocess single → inference → decode.
+    """
+
+    def __init__(
+        self,
+        rec_model: str,
+        char_dict: Union[str, List[str]],
+        rec_image_shape: Tuple[int, int, int] = (3, 48, 320),
+    ):
+        self.rec_image_shape = rec_image_shape
+        self.session = ax.InferenceSession(rec_model)
+        self.input_name = self.session.get_inputs()[0].name
+        char_list = _load_char_dict(char_dict)
+        self._decoder = _CTCLabelDecode(char_list, use_space_char=True)
+
+    def _preprocess_one(self, img: np.ndarray) -> np.ndarray:
+        tensor = _resize_norm_img(img, self.rec_image_shape)
+        return np.expand_dims(tensor, axis=0).astype(np.float32)
+
+    def infer_one(self, img: np.ndarray) -> Tuple[str, float]:
+        inp = self._preprocess_one(img)
+        out = self.session.run(None, {self.input_name: inp})[0]
+        results = self._decoder(out)
+        return results[0] if results else ("", 0.0)
+
+    def __call__(
+        self, images: List[np.ndarray]
+    ) -> List[Tuple[str, float]]:
+        results = []
+        for img in tqdm(images, desc="Inference", unit="sample"):
+            results.append(self.infer_one(img))
+        return results
+
+    def predict_image(self, path: str) -> Tuple[str, float]:
+        im = cv2.imread(path)
+        if im is None:
+            raise FileNotFoundError(f"Cannot read: {path}")
+        return self.infer_one(im)
+
+
+# ============================================================================
+# 4. Evaluation (one-by-one)
+# ============================================================================
+
+def evaluate(
+    ocr: PPOCRv6RecOne,
+    label_file: str,
+    dataset_root: str = "",
+    ignore_space: bool = True,
+    verbose: bool = False,
+) -> dict:
+    images = []
+    targets = []
+
+    with open(label_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+            img_path = os.path.join(dataset_root, parts[0].strip())
+            images.append(img_path)
+            targets.append(parts[1].strip())
+
+    total = len(images)
+    if total == 0:
+        print("[WARN] No samples found in label file.")
+        return {"acc": 0.0, "norm_edit_dis": 0.0, "total": 0, "correct": 0, "per_sample": []}
+
+    correct = 0
+    total_edit_dis = 0.0
+    per_sample = []
+
+    for i in tqdm(range(total), desc="Evaluating", unit="sample"):
+        p = images[i]
+        gt = targets[i]
+        im = cv2.imread(p)
+        if im is None:
+            print(f"[WARN] Cannot read {p}, skipping.")
+            pred, conf = ("", 0.0)
+        else:
+            pred, conf = ocr.infer_one(im)
+
+        pred_clean = pred.replace(" ", "") if ignore_space else pred
+        gt_clean = gt.replace(" ", "") if ignore_space else gt
+        dist, norm_dist = _edit_distance(pred_clean, gt_clean)
+        total_edit_dis += norm_dist
+        is_correct = pred_clean == gt_clean
+        if is_correct:
+            correct += 1
+
+        sample = {
+            "image": p,
+            "pred": pred,
+            "gt": gt,
+            "confidence": round(conf, 4),
+            "correct": is_correct,
+            "edit_distance": int(dist),
+            "norm_edit_dis": round(norm_dist, 4),
+        }
+        per_sample.append(sample)
+
+        if verbose:
+            status = " OK" if is_correct else "MIS"
+            print(
+                f"[{status}] pred={pred!r:<30} gt={gt!r:<30} "
+                f"conf={conf:.4f} edit={int(dist)} ndis={norm_dist:.4f}"
+            )
+
+    acc = correct / total
+    norm_edit_dis = 1.0 - total_edit_dis / total
+
+    return {
+        "acc": round(acc, 6),
+        "norm_edit_dis": round(norm_edit_dis, 6),
+        "total": total,
+        "correct": correct,
+        "per_sample": per_sample,
+    }
+
+
+# ============================================================================
+# 5. CLI
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="PP-OCRv6 Recognition AX (one-by-one) – inference & evaluation"
+    )
+    parser.add_argument(
+        "--rec_onnx", type=str,
+        default="axmodel/ax650/rec_npu3.axmodel",
+        help="Path to recognition AX model",
+    )
+    parser.add_argument(
+        "--char_dict", type=str,
+        default="onnx/rec_inference.yml",
+        help="Character dictionary: .yml (PostProcess.character_dict), .txt, or comma-list",
+    )
+    parser.add_argument("--rec_image_shape", type=str, default="3,48,320",
+                        help="Recognition input shape C,H,W (comma separated)")
+
+    parser.add_argument("--image", type=str, default=None, help="Single crop image path")
+
+    parser.add_argument("--label_file", type=str,
+                        default='dataset/ocr_rec_dataset_examples/val.txt',
+                        help="Label file (image_path<TAB>gt_text per line)")
+    parser.add_argument("--dataset_root", type=str,
+                        default="dataset/ocr_rec_dataset_examples",
+                        help="Prefix directory for image paths in label file")
+
+    parser.add_argument("--ignore_space", action="store_true", default=True,
+                        help="Ignore spaces when comparing (default: True)")
+    parser.add_argument("--verbose", action="store_true", help="Print per-sample results")
+    parser.add_argument("--output_json", type=str, default=None,
+                        help="Save results to JSON file")
+
+    args = parser.parse_args()
+
+    char_dict_src = args.char_dict
+    if char_dict_src.startswith("[") or ("," in char_dict_src and not os.path.exists(char_dict_src)):
+        char_dict = [c.strip() for c in char_dict_src.split(",") if c.strip()]
+    else:
+        char_dict = char_dict_src
+
+    image_shape = tuple(int(v) for v in args.rec_image_shape.split(","))
+    if len(image_shape) != 3:
+        raise ValueError("--rec_image_shape requires 3 comma-separated integers")
+
+    ocr = PPOCRv6RecOne(
+        rec_model=args.rec_onnx,
+        char_dict=char_dict,
+        rec_image_shape=image_shape,
+    )
+
+    if args.image:
+        text, conf = ocr.predict_image(args.image)
+        print(f"text={text!r}  confidence={conf:.4f}")
+        if args.output_json:
+            import json
+            with open(args.output_json, "w", encoding="utf-8") as f:
+                json.dump({"text": text, "confidence": conf}, f, ensure_ascii=False, indent=2)
+        return
+
+    if args.label_file:
+        metrics = evaluate(
+            ocr,
+            args.label_file,
+            dataset_root=args.dataset_root,
+            ignore_space=args.ignore_space,
+            verbose=args.verbose,
+        )
+
+        print()
+        print("=" * 60)
+        print("Evaluation Results")
+        print("=" * 60)
+        print(f"  Total samples:         {metrics['total']}")
+        print(f"  Correct (exact match): {metrics['correct']}")
+        print(f"  Accuracy:              {metrics['acc']:.4f} ({metrics['acc']*100:.2f}%)")
+        print(f"  Norm Edit Distance:    {metrics['norm_edit_dis']:.4f}")
+        print("=" * 60)
+
+        if args.output_json:
+            import json
+            out = {k: v for k, v in metrics.items() if k != "per_sample"}
+            out["per_sample"] = metrics["per_sample"]
+            with open(args.output_json, "w", encoding="utf-8") as f:
+                json.dump(out, f, ensure_ascii=False, indent=2)
+            print(f"\nResults saved to: {args.output_json}")
+        return
+
+    parser.error("Either --image or --label_file must be provided.")
+
+
+if __name__ == "__main__":
+    main()

run_rec_onnx.py

@@ -0,0 +1,494 @@
+#!/usr/bin/env python3
+"""
+PP-OCRv6 Recognition ONNX Inference & Evaluation (standalone, zero Paddle dependency)
+
+Dependencies:
+    numpy, opencv-python, onnxruntime, pyyaml
+
+Usage:
+    # Single image inference
+    python ppocrv6_rec_onnx.py --rec_onnx rec.onnx --char_dict inference.yml --image crop.png
+
+    # Batch evaluation
+    python ppocrv6_rec_onnx.py --rec_onnx rec.onnx --char_dict inference.yml \\
+        --label_file labels.txt --dataset_root ./crops/ \\
+        --batch_size 8 --output_json result.json --verbose
+"""
+
+import argparse
+import math
+import os
+from typing import List, Optional, Tuple, Union
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+import yaml
+
+
+# ============================================================================
+# 1. Utilities
+# ============================================================================
+
+def _edit_distance(pred: str, target: str) -> Tuple[int, float]:
+    """Compute Levenshtein edit distance (pure Python, no extra deps).
+
+    Returns:
+        (distance, normalized_distance) where normalized ∈ [0, 1].
+    """
+    m, n = len(pred), len(target)
+    if m == 0:
+        return n, 1.0
+    if n == 0:
+        return m, 1.0
+
+    dp = list(range(n + 1))
+    for i in range(1, m + 1):
+        prev = dp[0]
+        dp[0] = i
+        for j in range(1, n + 1):
+            temp = dp[j]
+            if pred[i - 1] == target[j - 1]:
+                dp[j] = prev
+            else:
+                dp[j] = 1 + min(prev, dp[j], dp[j - 1])
+            prev = temp
+
+    distance = dp[n]
+    normalized = distance / max(m, n)
+    return distance, normalized
+
+
+def _load_char_dict(source: Union[str, List[str]]) -> List[str]:
+    """Load character dictionary from .yml, .txt, or list."""
+    if isinstance(source, list):
+        return list(source)
+    ext = os.path.splitext(source)[1].lower()
+    if ext in (".yml", ".yaml"):
+        with open(source, "r", encoding="utf-8") as f:
+            cfg = yaml.safe_load(f)
+        dic = cfg.get("PostProcess", {}).get("character_dict", [])
+        if not dic:
+            raise ValueError(f"No PostProcess.character_dict found in {source}")
+        return dic
+    elif ext == ".txt":
+        with open(source, "r", encoding="utf-8") as f:
+            return [line.strip("\n\r") for line in f.readlines()]
+    else:
+        raise ValueError(
+            f"Unsupported char_dict source: {source}. Use .yml, .txt, or list."
+        )
+
+
+def _resize_norm_img(
+    img: np.ndarray,
+    image_shape: Tuple[int, int, int] = (3, 48, 320),
+    max_wh_ratio: Optional[float] = None,
+) -> np.ndarray:
+    """Resize and normalize a cropped text image for recognition.
+
+    Args:
+        img: BGR crop image (H, W, 3).
+        image_shape: (C, H, W) target shape.
+        max_wh_ratio: precomputed max width/height ratio for batch. If None, derived from img.
+    """
+    imgC, imgH, imgW = image_shape
+    if max_wh_ratio is None:
+        max_wh_ratio = imgW * 1.0 / imgH
+        h, w = img.shape[:2]
+        ratio = w * 1.0 / h
+        max_wh_ratio = max(max_wh_ratio, ratio)
+
+    max_wh_ratio = min(max_wh_ratio, imgW / imgH)
+    target_w = int(imgH * max_wh_ratio)
+    h, w = img.shape[:2]
+    ratio = w * 1.0 / h
+    if math.ceil(imgH * ratio) > target_w:
+        resized_w = target_w
+    else:
+        resized_w = int(math.ceil(imgH * ratio))
+
+    resized = cv2.resize(img, (resized_w, imgH))
+    resized = resized.astype("float32")
+    resized = resized.transpose((2, 0, 1)) / 255.0
+    resized -= 0.5
+    resized /= 0.5
+    padded = np.zeros((imgC, imgH, target_w), dtype=np.float32)
+    padded[:, :, 0:resized_w] = resized
+    return padded
+
+
+# ============================================================================
+# 2. CTC Decoder
+# ============================================================================
+
+class _CTCLabelDecode:
+    """CTC greedy decoder for recognition output."""
+
+    def __init__(self, character_list: List[str], use_space_char: bool = True):
+        self.character_str = list(character_list)
+        if use_space_char:
+            self.character_str.append(" ")
+        dict_character = ["blank"] + self.character_str
+        self.character = dict_character
+        self.dict = {char: i for i, char in enumerate(dict_character)}
+
+    def decode(
+        self,
+        text_index: np.ndarray,
+        text_prob: Optional[np.ndarray] = None,
+        is_remove_duplicate: bool = True,
+    ) -> List[Tuple[str, float]]:
+        result_list = []
+        batch_size = len(text_index)
+        for batch_idx in range(batch_size):
+            selection = np.ones(len(text_index[batch_idx]), dtype=bool)
+            if is_remove_duplicate:
+                selection[1:] = text_index[batch_idx][1:] != text_index[batch_idx][:-1]
+            selection &= text_index[batch_idx] != 0  # ignore blank
+            char_list = [
+                self.character[int(tid)]
+                for tid in text_index[batch_idx][selection]
+            ]
+            if text_prob is not None:
+                conf_list = text_prob[batch_idx][selection]
+            else:
+                conf_list = np.ones(len(selection), dtype=np.float32)
+            if len(conf_list) == 0:
+                conf_list = np.array([0.0], dtype=np.float32)
+            text = "".join(char_list)
+            result_list.append((text, float(np.mean(conf_list))))
+        return result_list
+
+    def __call__(self, preds: np.ndarray) -> List[Tuple[str, float]]:
+        preds_idx = preds.argmax(axis=2)
+        preds_prob = preds.max(axis=2)
+        return self.decode(preds_idx, preds_prob, is_remove_duplicate=True)
+
+
+# ============================================================================
+# 3. Recognition Engine
+# ============================================================================
+
+class PPOCRv6RecOnnx:
+
+    def __init__(
+        self,
+        rec_onnx: str,
+        char_dict: Union[str, List[str]],
+        rec_image_shape: Tuple[int, int, int] = (3, 48, 320),
+        rec_batch_num: int = 6,
+        use_gpu: bool = False,
+        onnx_providers: Optional[List[str]] = None,
+    ):
+        self.rec_image_shape = rec_image_shape
+        self.rec_batch_num = rec_batch_num
+
+        # ONNX session
+        if onnx_providers is None:
+            onnx_providers = (
+                ["CUDAExecutionProvider", "CPUExecutionProvider"]
+                if use_gpu
+                else ["CPUExecutionProvider"]
+            )
+
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        self.session = ort.InferenceSession(
+            rec_onnx, sess_options=sess_options, providers=onnx_providers
+        )
+        self.input_name = self.session.get_inputs()[0].name
+
+        # CTC decoder
+        char_list = _load_char_dict(char_dict)
+        self._decoder = _CTCLabelDecode(char_list, use_space_char=True)
+
+    # ---- pre / post ----
+
+    def _preprocess(
+        self, img_list: List[np.ndarray]
+    ) -> List[np.ndarray]:
+        """Convert a list of crops into batch tensors (grouped by self.rec_batch_num)."""
+        num = len(img_list)
+        width_list = [im.shape[1] / float(im.shape[0]) for im in img_list]
+        indices = np.argsort(np.array(width_list))
+
+        batches = []
+        index_maps = []  # each element: list of original indices in this batch
+
+        for beg in range(0, num, self.rec_batch_num):
+            end = min(num, beg + self.rec_batch_num)
+            imgC, imgH, imgW = self.rec_image_shape
+            max_wh_ratio = imgW / imgH
+            for ino in range(beg, end):
+                orig_idx = indices[ino]
+                h, w = img_list[orig_idx].shape[:2]
+                max_wh_ratio = max(max_wh_ratio, w / h)
+
+            norm_list = []
+            idx_list = []
+            for ino in range(beg, end):
+                orig_idx = indices[ino]
+                norm = _resize_norm_img(
+                    img_list[orig_idx],
+                    self.rec_image_shape,
+                    max_wh_ratio=max_wh_ratio,
+                )
+                norm_list.append(np.expand_dims(norm, axis=0))
+                idx_list.append(orig_idx)
+
+            if norm_list:
+                batches.append(np.concatenate(norm_list, axis=0).astype(np.float32))
+            index_maps.append(idx_list)
+        return batches, index_maps
+
+    def _postprocess(
+        self,
+        batch_outputs: List[np.ndarray],
+        index_maps: List[List[int]],
+        total_num: int,
+    ) -> List[Tuple[str, float]]:
+        results = [("", 0.0)] * total_num
+        # Decode each batch separately — different batches may have different T.
+        for batch_preds, idx_list in zip(batch_outputs, index_maps):
+            texts = self._decoder(batch_preds)
+            for i, orig_idx in enumerate(idx_list):
+                results[orig_idx] = texts[i]
+        return results
+
+    # ---- public API ----
+
+    def __call__(
+        self, img: Union[np.ndarray, List[np.ndarray]]
+    ) -> List[Tuple[str, float]]:
+        if isinstance(img, np.ndarray):
+            img = [img]
+        if not img:
+            return []
+        batches, index_maps = self._preprocess(img)
+        outputs = []
+        for batch in batches:
+            out = self.session.run(None, {self.input_name: batch})
+            outputs.append(out[0])
+        return self._postprocess(outputs, index_maps, len(img))
+
+    def predict_image(self, path: str) -> Tuple[str, float]:
+        im = cv2.imread(path)
+        if im is None:
+            raise FileNotFoundError(f"Cannot read: {path}")
+        return self.__call__(im)[0]
+
+
+# ============================================================================
+# 4. Evaluation
+# ============================================================================
+
+def evaluate(
+    ocr: PPOCRv6RecOnnx,
+    label_file: str,
+    dataset_root: str = "",
+    ignore_space: bool = True,
+    verbose: bool = False,
+) -> dict:
+    """Evaluate recognition accuracy against a ground-truth label file.
+
+    Label file format (one per line, tab-separated)::
+
+        rel/path/to/crop.png<TAB>ground truth text
+
+    The full image path is ``os.path.join(dataset_root, rel_path)``.
+
+    Args:
+        ocr: PPOCRv6RecOnnx instance.
+        label_file: path to tab-separated label file.
+        dataset_root: prefix directory for image paths in label file.
+        ignore_space: strip spaces before comparing.
+        verbose: print per-sample prediction details.
+
+    Returns:
+        dict with keys: ``acc``, ``norm_edit_dis``, ``total``, ``correct``,
+        ``per_sample`` (list of per-sample details).
+    """
+    images = []
+    targets = []
+
+    with open(label_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+            img_path = os.path.join(dataset_root, parts[0].strip())
+            images.append(img_path)
+            targets.append(parts[1].strip())
+
+    total = len(images)
+    if total == 0:
+        print("[WARN] No samples found in label file.")
+        return {"acc": 0.0, "norm_edit_dis": 0.0, "total": 0, "correct": 0, "per_sample": []}
+
+    # Load all images
+    imgs = []
+    for p in images:
+        im = cv2.imread(p)
+        if im is None:
+            print(f"[WARN] Cannot read {p}, skipping.")
+            imgs.append(np.zeros((32, 100, 3), dtype=np.uint8))
+        else:
+            imgs.append(im)
+
+    # Batch inference
+    rec_results = ocr(imgs)
+
+    correct = 0
+    total_edit_dis = 0.0
+    per_sample = []
+
+    for i, ((pred, conf), gt) in enumerate(zip(rec_results, targets)):
+        pred_clean = pred.replace(" ", "") if ignore_space else pred
+        gt_clean = gt.replace(" ", "") if ignore_space else gt
+        dist, norm_dist = _edit_distance(pred_clean, gt_clean)
+        total_edit_dis += norm_dist
+        is_correct = pred_clean == gt_clean
+        if is_correct:
+            correct += 1
+
+        sample = {
+            "image": images[i],
+            "pred": pred,
+            "gt": gt,
+            "confidence": round(conf, 4),
+            "correct": is_correct,
+            "edit_distance": int(dist),
+            "norm_edit_dis": round(norm_dist, 4),
+        }
+        per_sample.append(sample)
+
+        if verbose:
+            status = " OK" if is_correct else "MIS"
+            print(
+                f"[{status}] pred={pred!r:<30} gt={gt!r:<30} "
+                f"conf={conf:.4f} edit={int(dist)} ndis={norm_dist:.4f}"
+            )
+
+    acc = correct / total
+    norm_edit_dis = 1.0 - total_edit_dis / total
+
+    return {
+        "acc": round(acc, 6),
+        "norm_edit_dis": round(norm_edit_dis, 6),
+        "total": total,
+        "correct": correct,
+        "per_sample": per_sample,
+    }
+
+
+# ============================================================================
+# 5. CLI
+# ============================================================================
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="PP-OCRv6 Recognition ONNX – inference & evaluation"
+    )
+    # Model
+    parser.add_argument(
+        "--rec_onnx", type=str,
+        default="onnx/rec_inference_static_sim.onnx",
+        help="Path to recognition ONNX model",
+    )
+    parser.add_argument(
+        "--char_dict", type=str,
+        default="onnx/rec_inference.yml",
+        help="Character dictionary: .yml (PostProcess.character_dict), .txt, or comma-list",
+    )
+    parser.add_argument("--batch_size", type=int, default=1, help="Recognition batch size")
+    parser.add_argument("--use_gpu", action="store_true", help="Enable GPU inference")
+    parser.add_argument("--rec_image_shape", type=str, default="3,48,320",
+                        help="Recognition input shape C,H,W (comma separated)")
+
+    # Single image mode
+    parser.add_argument("--image", type=str, default=None, help="Single crop image path")
+
+    # Evaluation mode
+    parser.add_argument("--label_file", type=str, 
+                        default='dataset/ocr_rec_dataset_examples/val.txt',
+                        help="Label file (image_path<TAB>gt_text per line)")
+    parser.add_argument("--dataset_root", type=str, 
+                        default="dataset/ocr_rec_dataset_examples",
+                        help="Prefix directory for image paths in label file")
+
+    # Common
+    parser.add_argument("--ignore_space", action="store_true", default=True,
+                        help="Ignore spaces when comparing (default: True)")
+    parser.add_argument("--verbose", action="store_true", help="Print per-sample results")
+    parser.add_argument("--output_json", type=str, default=None,
+                        help="Save results to JSON file")
+
+    args = parser.parse_args()
+
+    # Build engine
+    char_dict_src = args.char_dict
+    if char_dict_src.startswith("[") or ("," in char_dict_src and not os.path.exists(char_dict_src)):
+        char_dict = [c.strip() for c in char_dict_src.split(",") if c.strip()]
+    else:
+        char_dict = char_dict_src
+
+    image_shape = tuple(int(v) for v in args.rec_image_shape.split(","))
+    if len(image_shape) != 3:
+        raise ValueError("--rec_image_shape requires 3 comma-separated integers")
+
+    ocr = PPOCRv6RecOnnx(
+        rec_onnx=args.rec_onnx,
+        char_dict=char_dict,
+        rec_image_shape=image_shape,
+        rec_batch_num=args.batch_size,
+        use_gpu=args.use_gpu,
+    )
+
+    # Single image mode
+    if args.image:
+        text, conf = ocr.predict_image(args.image)
+        print(f"text={text!r}  confidence={conf:.4f}")
+        if args.output_json:
+            import json
+            with open(args.output_json, "w", encoding="utf-8") as f:
+                json.dump({"text": text, "confidence": conf}, f, ensure_ascii=False, indent=2)
+        return
+
+    # Evaluation mode
+    if args.label_file:
+        metrics = evaluate(
+            ocr,
+            args.label_file,
+            dataset_root=args.dataset_root,
+            ignore_space=args.ignore_space,
+            verbose=args.verbose,
+        )
+
+        print()
+        print("=" * 60)
+        print("Evaluation Results")
+        print("=" * 60)
+        print(f"  Total samples:         {metrics['total']}")
+        print(f"  Correct (exact match): {metrics['correct']}")
+        print(f"  Accuracy:              {metrics['acc']:.4f} ({metrics['acc']*100:.2f}%)")
+        print(f"  Norm Edit Distance:    {metrics['norm_edit_dis']:.4f}")
+        print("=" * 60)
+
+        if args.output_json:
+            import json
+            out = {k: v for k, v in metrics.items() if k != "per_sample"}
+            out["per_sample"] = metrics["per_sample"]
+            with open(args.output_json, "w", encoding="utf-8") as f:
+                json.dump(out, f, ensure_ascii=False, indent=2)
+            print(f"\nResults saved to: {args.output_json}")
+        return
+
+    parser.error("Either --image or --label_file must be provided.")
+
+
+if __name__ == "__main__":
+    main()