| """Read printed Abkhaz text lines with the four-alphabet reader. |
| |
| python read_lines.py model line1.png line2.png … |
| each image is ONE printed line; every line is read freely |
| |
| python read_lines.py model --block line1.png line2.png … |
| the images are the lines of ONE text block (a column, a paragraph): the block is read |
| in one alphabet, chosen from what its lines show — the way the Foundation's app reads. |
| A block earns an old alphabet from several of its words, so give it the whole block; |
| a single old-alphabet line is better read freely (without --block) |
| |
| Needs torch, numpy, Pillow and `ocr_nets.py` from this folder. CPU is fine: a line takes |
| milliseconds. The reader was trained on lines cut tightly around the printed text (a few |
| pixels of paper around the letters), grey or colour scans of 25–80 px line height. |
| """ |
| import json |
| import os |
| import sys |
|
|
| import numpy as np |
| import torch |
| from PIL import Image |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| from ocr_nets import CRNN, REC_HEIGHT, ctc_greedy, load_script_masks, lock_block |
|
|
|
|
| def load(model_dir): |
| chars = json.loads(open(os.path.join(model_dir, "charset.json"), encoding="utf-8").read()) |
| itos = ["\0"] + list(chars) |
| model = CRNN(len(itos)) |
| model.load_state_dict(torch.load(os.path.join(model_dir, "best.pt"), map_location="cpu")) |
| model.eval() |
| return model, itos, load_script_masks(model_dir, itos) |
|
|
|
|
| def prepare(path): |
| """A line image → float array [48, W]: grey, 48 px high, ink high and paper low.""" |
| im = Image.open(path).convert("L") |
| w = max(8, min(1000, round(im.width * REC_HEIGHT / max(1, im.height)))) |
| im = im.resize((w, REC_HEIGHT), Image.BILINEAR) |
| return 1.0 - np.asarray(im, dtype="float32") / 255.0 |
|
|
|
|
| def read(model, itos, paths): |
| """Logits per line, [T, C] each — the input of both decoders below.""" |
| arrays = [prepare(p) for p in paths] |
| width = max(a.shape[1] for a in arrays) |
| batch = torch.zeros(len(arrays), 1, REC_HEIGHT, width) |
| for i, a in enumerate(arrays): |
| batch[i, 0, :, :a.shape[1]] = torch.from_numpy(a) |
| with torch.inference_mode(): |
| return model(batch) |
|
|
|
|
| def main(): |
| args = sys.argv[1:] |
| block = "--block" in args |
| args = [a for a in args if a != "--block"] |
| if len(args) < 2: |
| sys.exit(__doc__) |
| model, itos, masks = load(args[0]) |
| paths = args[1:] |
| logits = read(model, itos, paths) |
| if block and masks: |
| alphabet, lines, vote = lock_block([logits[i] for i in range(len(paths))], itos, masks) |
| print(f"block alphabet: {alphabet}") |
| for p, (text, conf, alph) in zip(paths, lines): |
| print(f"{os.path.basename(p)}\t{alph}\t{text}") |
| else: |
| for p, text in zip(paths, ctc_greedy(logits, itos)): |
| print(f"{os.path.basename(p)}\t{text}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
