PaddleRecognizer

Import

import { PaddleRecognizer } from '@stabrise/scaledp/ocr'

Group

Recognise

Reads

image, boxes

Writes

document

Needs

ppu-paddle-ocr

PaddleTextRecognizer detects and recognises in a single pass, so boxes from a separate detector never reach it. This stage does the opposite: it reads exactly the boxes it is handed, cropping and straightening each one — the PaddleOCR counterpart to TesseractRecognizer.

import { Pipeline } from '@stabrise/scaledp'
import { PdfToImage } from '@stabrise/scaledp/pdf'
import { DbnetOnnxDetector, PaddleRecognizer } from '@stabrise/scaledp/ocr'

const rows = await new Pipeline([
    new PdfToImage(),
    new DbnetOnnxDetector({ outputCol: 'boxes' }),
    new PaddleRecognizer({ inputCols: ['image', 'boxes'] }),
]).transform(file)

Document.type is 'paddle-recognizer'. A missing box column produces a helpful OcrError in exception rather than an empty result.

Only the recognition model is downloaded

A preset pairs a detection model, a recognition model and a character dictionary. This stage never detects, so it fetches only the last two. The cache keys are shared with PaddleTextDetector and PaddleTextRecognizer, so a pipeline that also uses one of those pays for each file once.

The preset is still what picks the script: the same list, and the same choice as everywhere else in the library.

boxLevel decides how fine the output boxes are

'word' is the default, matching TesseractRecognizer, so swapping the engine does not change how finely the page comes back.

Getting there takes more work than it does with Tesseract, which reports word rects of its own. PaddleOCR reads a crop into one undivided string with no geometry inside it, so the words have to be recovered — but the line is read first, whole, and only then split.

Splitting reconciles two independent readings of the same line: the words the model reported, and the ink gaps a vertical projection of the crop finds — any blank column run at least wordGapRatio of the crop's height wide. The text says what the words are; the spans say where. When the counts agree, which is the ordinary case, they zip together and every box is measured geometry.

When they disagree, the ink decides how many boxes there are and the text decides what is in them. No box is ever invented:

• More spans than words — the ink gapped where the model read no space. Adjacent spans merge, smallest gap first, until the counts meet.
• More words than spans — the model read a space the ink does not show. The extra words are joined back onto the spans they fall on, so one block of ink gives one box carrying all of its words.

Spans are mapped back through the crop's own transform, rotation included, so a word inside a skewed line comes back skewed the same way. Every word carries its line's score, because that is the only score computed — the model scored the line, not its parts.

'region' keeps one box per region the detector found, carrying everything read inside it. The recognition is identical either way, so this changes only how the result is cut up; it is the right choice for a script that does not separate words with spaces — Chinese, Japanese and Thai have no gaps to cut on, and word mode will return one box per line there anyway.

The recognition model runs on WebGPU as well as WASM: the library fetches the .onnx twin of ppu's .ort models, which WebGPU can load. See Execution providers.

Straightening

The crop is a perspective warp onto the box's own axes, which is what makes a skewed line readable at all — PaddleOCR's own cropping is axis-aligned, so handing it a rotated box would read that box's envelope instead.

padding defaults to 5, which is what ScaleDP hardcodes. scaleFactor resizes the page before cropping and scales the box to index into it — useful for small text. The boxes reported back are the originals, in the space they arrived in.

detectLineOrientation defaults off here

TesseractRecognizer defaults it to true; this stage defaults it to false. PaddleOCR already turns a crop that is markedly taller than it is wide, so only the 180° case is missing — and catching it costs a separate ~9 MB model that an ordinary page never needs.

Turn it on for scans that come in upside down. It uses the same model as LineOrientationDetector, so putting that stage in front as well would run it twice.

Letting the page choose the model

presetCol takes the recognition model from a column, per page, instead of the fixed preset — put a TesseractScriptDetector in front and the model follows the script it found. preset stays as the fallback for pages it could not classify. See PaddleTextRecognizer for the full shape.

Parameters