Datasets:
Download code/src/pvr_eval/agent/ocr_tools.py from wenjieshu/solveedit_benchmark_2728: direct link, hf CLI and curl.
- Browser
- Download file 6.82 kB
-
https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/agent/ocr_tools.py
- Command line
-
hf download hf://datasets/wenjieshu/solveedit_benchmark_2728/code/src/pvr_eval/agent/ocr_tools.py
-
curl -L -o ocr_tools.py https://huggingface.co/datasets/wenjieshu/solveedit_benchmark_2728/resolve/main/code/src/pvr_eval/agent/ocr_tools.py
6.82 kB
| """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, | |
| } | |