File size: 2,936 Bytes
f1ba785
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
"""ONNX-adjunct Tesseract beam producer for whitelisted numeric crops."""
from __future__ import annotations

from .arabic_tesseract_engine import (
    POLARITY_RETRY_MEAN_CONF,
    bytes_to_bgr,
    extract_structured_numeric_tokens,
    invert_polarity,
    mean_token_confidence,
    noir_filter_preprocess,
    tokens_to_text,
)
from .contracts import BeamCandidate, SemanticClass


def _tokens_to_beam(

    tokens: list[dict],

    text: str,

    variant: str,

) -> BeamCandidate | None:
    if not text:
        return None
    confidences = [max(0.0, min(1.0, float(item["confidence"]) / 100.0)) for item in tokens]
    if not confidences:
        confidences = [0.5] * len(text)
    elif len(confidences) < len(text):
        mean = sum(confidences) / len(confidences)
        confidences = confidences + [mean] * (len(text) - len(confidences))
    else:
        confidences = confidences[: len(text)]
    mean_prob = sum(confidences) / len(confidences)
    min_prob = min(confidences)
    return BeamCandidate(
        text=text,
        probability=mean_prob,
        min_character_probability=min_prob,
        beam_margin=0.15,
        character_confidences=tuple(confidences),
        character_confidence_sources=tuple("engine" for _ in confidences),
        preprocessing_variant=variant,
    )


class TesseractNumericRecognizer:
    version = "tesseract-numeric-v1"

    @staticmethod
    def available() -> bool:
        try:
            import cv2  # noqa: F401
            import pytesseract

            pytesseract.get_tesseract_version()
            return True
        except Exception:
            return False

    def recognize(self, image_bytes: bytes, semantic_class: SemanticClass) -> list[BeamCandidate]:
        if not self.available():
            return []
        try:
            bgr = bytes_to_bgr(image_bytes)
        except ValueError:
            return []
        beams: list[BeamCandidate] = []
        processed = noir_filter_preprocess(bgr)
        tokens = extract_structured_numeric_tokens(
            bgr, semantic_class=semantic_class, processed=processed
        )
        text = tokens_to_text(tokens, semantic_class)
        primary = _tokens_to_beam(tokens, text, "tesseract_adaptive")
        if primary:
            beams.append(primary)
        if mean_token_confidence(tokens) < POLARITY_RETRY_MEAN_CONF:
            inverted = invert_polarity(processed)
            retry_tokens = extract_structured_numeric_tokens(
                bgr, semantic_class=semantic_class, processed=inverted
            )
            retry_text = tokens_to_text(retry_tokens, semantic_class)
            retry = _tokens_to_beam(retry_tokens, retry_text, "tesseract_polarity_inverted")
            if retry and retry.text not in {item.text for item in beams}:
                beams.append(retry)
        return beams