CV / PPOCR

PPOCR

End-to-end text detection and recognition using RKNN PPOCR-Det and PPOCR-Rec.

23 Downloads

Präzision

RKNN

Wähle das Gerät, das du verwendest. Die Einrichtungsanleitung und Dokumentation werden entsprechend aktualisiert.

Plattform

Inferenz-Engine

Erste Schritte

Bereitstellen

sudo docker run --rm --privileged --net=host \
  -e PYTHONUNBUFFERED=1 -e RKNN_LOG_LEVEL=0 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-ppocr:latest \
  python web_service.py --platform rk3576 --model_dir /app/model --host 0.0.0.0 --port 8000

REST API

Verwende die REST API für die Inferenz. Kopiere die folgenden Befehle.

Curl

curl http://localhost:8080/v1/chat/completions -d '{
  "model": "ppocr-rknn",
  "messages": [{"role": "user", "content": "Hello"}]
}'

Python

import requests

resp = requests.post(
    "http://localhost:8080/v1/chat/completions",
    json={"model": "ppocr-rknn", "messages": [{"role": "user", "content": "Hello"}]},
)
print(resp.json())

Modelldetails

Schnellstart

1. Docker installieren

Führen Sie auf dem Entwicklungsboard die folgenden Befehle aus, um Docker zu installieren:

bash

# Docker
curl -fsSL https://get.docker.com -o get-docker.sh
# Aliyun
sudo sh get-docker.sh --mirror Aliyun
# systemd
sudo systemctl enable docker
sudo systemctl start docker

2. Projekt ausführen (ein Befehl, Vorschau in zwei Modi)

Dieser End-to-End-OCR-Dienst stammt aus reComputer-RK-CV. Er erkennt Textpolygone, sortiert sie in Lesereihenfolge, entzerrt jeden Ausschnitt perspektivisch und erkennt jede Textzeile.

Modellinformationen

Komponente	Datei
Textdetektor	`model/ppocr_det.rknn`
Texterkenner	`model/ppocr_rec.rknn`
Zeichenwörterbuch	`model/ppocr_keys_v1.txt`
Beschriftungsschrift	`model/simfang.ttf`
Ausgabe	Text, Konfidenz, Viereckkoordinaten, Ausschnitte und Latenz

PPOCR unterstützt nur Standbilder. Der Upstream-Dienst enthält bewusst keine Kamera-, lokale Video- oder MP4-Analyse-Steuerung.

Schritt A: Images abrufen

bash

sudo docker pull ghcr.io/seeed-projects/recomputer-rk-cv/rk3588-ppocr:latest
sudo docker pull ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-ppocr:latest

Schritt B: Mit einem Klick ausführen

Für RK3576:

bash

sudo docker run --rm --privileged --net=host \
  -e PYTHONUNBUFFERED=1 -e RKNN_LOG_LEVEL=0 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3576-ppocr:latest \
  python web_service.py --platform rk3576 --model_dir /app/model \
  --host 0.0.0.0 --port 8000

Für RK3588:

bash

sudo docker run --rm --privileged --net=host \
  -e PYTHONUNBUFFERED=1 -e RKNN_LOG_LEVEL=0 \
  -v /proc/device-tree/compatible:/proc/device-tree/compatible:ro \
  ghcr.io/seeed-projects/recomputer-rk-cv/rk3588-ppocr:latest \
  python web_service.py --platform rk3588 --model_dir /app/model \
  --host 0.0.0.0 --port 8000

Öffnen Sie http://<BOARD_IP>:8000 oder /docs.

🔌 API-Dokumentation

1. OCR-Schnittstelle (Predict)

Endpunkt: POST /api/models/ppocr/predict

Anfrageparameter (Multipart/Form-Data):

Laden Sie file hoch; verfügbar sind det_threshold, box_threshold, unclip_ratio, drop_score, max_results und include_crops.

Anwendungsbeispiele:

bash

curl -X POST "http://<BOARD_IP>:8000/api/models/ppocr/predict" \
  -F "file=@document.jpg" -F "drop_score=0.5" \
  -F "include_crops=false"

Optionale Felder sind det_threshold, box_threshold, unclip_ratio, drop_score, max_results und include_crops. Weitere Endpunkte liefern Zustand, Konfiguration, das neueste strukturierte Ergebnis, das neueste annotierte JPEG und interaktive OpenAPI-Dokumentation.

Feld	Standard	Beschreibung
`det_threshold`	`0.3`	Pixelkarten-Erkennungsschwelle von 0 bis 1.
`box_threshold`	`0.6`	Minimaler DB-Textbox-Wert.
`unclip_ratio`	`1.5`	Polygonerweiterungsverhältnis von 0.1 bis 5.
`drop_score`	`0.5`	Minimale Erkennungskonfidenz im kombinierten Text.
`max_results`	`100`	Maximale Anzahl an Regionen für die Erkennung.
`include_crops`	`false`	Base64-JPEG-Ausschnitte in Ergebniszeilen einschließen.

Antwortformat (JSON):

json

{
  "success": true,
  "model": "ppocr",
  "result": {
    "text": "Recognized first line\nRecognized second line",
    "lines": [
      {
        "index": 1,
        "text": "Recognized first line",
        "confidence": 0.9621,
        "accepted": true,
        "box": [[42, 31], [286, 29], [287, 72], [43, 74]]
      }
    ],
    "count": 2,
    "timing_ms": {"detection": 54.2, "recognition": 71.4, "total": 129.8}
  }
}

Die Erkennungsqualität beeinflusst die Texterkennung direkt. Sehr kleiner, unscharfer, gekrümmter, vertikaler, kontrastarmer oder stark gedrehter Text kann fehlen; die einfache Lesereihenfolge eignet sich möglicherweise nicht für komplexe mehrspaltige Dokumente. include_crops=true vergrößert die Antwort und ist hauptsächlich für die Web-Ergebnisansicht gedacht. Detektor und Erkenner sind Pipeline-Stufen und müssen mit Zeichenwörterbuch und Perspektivausschnitt kompatibel bleiben.

2. Schnittstelle zur Systemkonfiguration (Config)

GET /api/config / POST /api/config.

3. Befehlszeilenargumente

Argument	Standard	Beschreibung
`--platform`	Erforderlich	`rk3576` oder `rk3588`.
`--model_dir`	`model`	Modelle, Wörterbuch, Schrift und Beispielbild.
`--image`	Kein Wert	Standbild, das vor dem Serverstart analysiert wird.
`--output`	Kein Wert	Pfad für annotiertes JPG/PNG von `--image`.
`--no_server`	Aus	Nach Verarbeitung von `--image` beenden.
`--host` / `--port`	`0.0.0.0` / `8000`	Dienstadresse und Port.

So analysieren Sie ein eingebundenes Bild, speichern die Annotation, geben JSON aus und beenden:

bash

python web_service.py --platform rk3576 --model_dir model \
  --image /data/document.jpg --output /data/document_result.jpg --no_server

🛠️ Entwicklerleitfaden (Empfehlungen für den Produktionseinsatz)

Lokal bauen

bash

docker build -f docker/rk3576/ppocr.dockerfile \
  -t rk3576-ppocr:local src/rk3576_ppocr

docker build -f docker/rk3588/ppocr.dockerfile \
  -t rk3588-ppocr:local src/rk3588_ppocr

Eingaben und Ausgaben

Input: still image. Output: ordered text lines, confidence scores, quadrilaterals, and annotated image.