File size: 6,824 Bytes
b8ea052
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
"""Check-scoped OCR execution helpers for typed PVR tool calls."""

from __future__ import annotations

import json
from pathlib import Path
from typing import Any, Callable

from PIL import Image


def parse_json_list(value: Any) -> list[Any]:
    if isinstance(value, list):
        return value
    try:
        parsed = json.loads(str(value or "[]"))
    except Exception:
        return []
    return parsed if isinstance(parsed, list) else []


def rect_from_value(value: Any) -> list[float] | None:
    if isinstance(value, dict):
        value = value.get("bbox") or value.get("rect") or (
            [value.get("x0"), value.get("y0"), value.get("x1"), value.get("y1")]
            if {"x0", "y0", "x1", "y1"} <= set(value)
            else None
        )
    if not isinstance(value, (list, tuple)) or len(value) != 4:
        return None
    try:
        return [float(item) for item in value]
    except Exception:
        return None


def resolve_region_rects(
    contract: dict[str, Any],
    region_ids: list[str],
    image_size: tuple[int, int],
    region_overrides: dict[str, Any] | None = None,
) -> tuple[list[dict[str, Any]], list[str]]:
    """Resolve contract geometry first, then typed detector proposals."""

    width, height = image_size
    zones = contract.get("zones") if isinstance(contract.get("zones"), dict) else {}
    planned: dict[str, Any] = {}
    for check in contract.get("atomic_checks", []):
        params = check.get("params") if isinstance(check, dict) else {}
        for region in (params or {}).get("planned_regions", []) or []:
            if isinstance(region, dict) and (region.get("region_id") or region.get("id")):
                planned[str(region.get("region_id") or region.get("id"))] = region
    resolved, unresolved = [], []
    for region_id in region_ids:
        raw = zones.get(region_id, planned.get(region_id))
        rect = rect_from_value(raw)
        if rect is None:
            rect = rect_from_value((region_overrides or {}).get(region_id))
        if rect is None:
            unresolved.append(region_id)
            continue
        if max(abs(value) for value in rect) <= 1.0:
            rect = [rect[0] * width, rect[1] * height, rect[2] * width, rect[3] * height]
        x0, y0, x1, y1 = rect
        rect = [max(0.0, min(width, x0)), max(0.0, min(height, y0)), max(0.0, min(width, x1)), max(0.0, min(height, y1))]
        if rect[2] <= rect[0] or rect[3] <= rect[1]:
            unresolved.append(region_id)
            continue
        resolved.append({"region_id": region_id, "bbox_xyxy": rect})
    return resolved, unresolved


def ocr_layout_region_ids(contract: dict[str, Any]) -> set[str]:
    """Return regions whose geometry is intentionally discovered by OCR.

    These regions cannot be required as an OCR input crop: doing so creates a
    circular dependency (OCR needs the label box before OCR may run).  A dense
    full-frame OCR pass is the objective region proposer for this method.
    """

    result: set[str] = set()
    for check in contract.get("atomic_checks", []):
        params = check.get("params") if isinstance(check, dict) else {}
        for region in (params or {}).get("planned_regions", []) or []:
            if not isinstance(region, dict) or str(region.get("proposal_method") or "") != "ocr_layout":
                continue
            region_id = str(region.get("region_id") or region.get("id") or "")
            if region_id:
                result.add(region_id)
    return result


def normalize_rapidocr_result(result: Any, *, dx: float = 0.0, dy: float = 0.0, min_confidence: float = 0.0) -> list[dict[str, Any]]:
    raw_items = result[0] if isinstance(result, tuple) else result
    rows = []
    for raw in raw_items or []:
        if not isinstance(raw, (list, tuple)) or len(raw) < 3:
            continue
        polygon, value, confidence = raw[0], str(raw[1]), float(raw[2])
        if confidence < min_confidence:
            continue
        points = []
        for point in polygon or []:
            if isinstance(point, (list, tuple)) and len(point) >= 2:
                points.append([float(point[0]) + dx, float(point[1]) + dy])
        if not points:
            continue
        xs, ys = [point[0] for point in points], [point[1] for point in points]
        rows.append(
            {
                "text": value,
                "confidence": confidence,
                "box": points,
                "bbox_xyxy": [min(xs), min(ys), max(xs), max(ys)],
            }
        )
    return rows


def execute_ocr_call(
    call: dict[str, str],
    *,
    backend: Callable[[Image.Image], Any],
    min_confidence: float = 0.1,
    region_overrides: dict[str, Any] | None = None,
) -> dict[str, Any]:
    role = call.get("image_role", "pred")
    if role not in {"input", "pred"}:
        return {"status": "unsupported", "reason": f"unsupported_image_role:{role}", "items": []}
    image_path = Path(call.get(role, ""))
    if not image_path.is_file():
        return {"status": "error", "reason": "image_not_found", "image_path": str(image_path), "items": []}
    contract_path = Path(call.get("contract_path", ""))
    contract = json.loads(contract_path.read_text(encoding="utf-8")) if contract_path.is_file() else {}
    region_ids = [str(item) for item in parse_json_list(call.get("region_ids")) if str(item)]
    with Image.open(image_path).convert("RGB") as image:
        regions, unresolved = resolve_region_rects(contract, region_ids, image.size, region_overrides)
        layout_regions = ocr_layout_region_ids(contract)
        unresolved_non_ocr = [region_id for region_id in unresolved if region_id not in layout_regions]
        if region_ids and unresolved_non_ocr:
            return {
                "status": "insufficient",
                "reason": "unresolved_ocr_regions",
                "region_ids": region_ids,
                "unresolved_region_ids": unresolved_non_ocr,
                "resolved_regions": regions,
                "items": [],
            }
        scopes = regions or [{"region_id": "full_image", "bbox_xyxy": [0.0, 0.0, float(image.width), float(image.height)]}]
        items: list[dict[str, Any]] = []
        for scope in scopes:
            x0, y0, x1, y1 = scope["bbox_xyxy"]
            crop = image.crop((int(round(x0)), int(round(y0)), int(round(x1)), int(round(y1))))
            for item in normalize_rapidocr_result(backend(crop), dx=x0, dy=y0, min_confidence=min_confidence):
                items.append({**item, "region_id": scope["region_id"]})
    return {
        "status": "ok" if items else "no_text",
        "reason": "ocr_layout_full_frame_scan" if unresolved and not regions else "ocr_completed",
        "region_ids": region_ids,
        "resolved_regions": scopes,
        "items": items,
    }