wenjieshu's picture
Add files using upload-large-folder tool
b8ea052 verified
Raw History Blame Contribute Delete
28.8 kB
"""Conservative, check-scoped computer-vision evidence executors.
These helpers deliberately produce measurements, not check scores. A tool
status of ``ok`` means that the stated measurement was available; it does not
mean that an atomic question passed. When a generic parser request lacks the
structured facts needed to make an objective measurement, the executor emits
``unsupported`` or ``insufficient`` instead of guessing from prose.
"""
from __future__ import annotations
import json
from pathlib import Path
from typing import Any, Iterable, Mapping
import numpy as np
from PIL import Image
from pvr_eval.agent.human_pose_executor import run_human_pose_estimation
from pvr_eval.agent.preservation_local_correspondence import run_local_correspondence
CV_TOOL_TYPES = frozenset(
{
"image_registration",
"change_analysis",
"route_parser",
"visual_attribute_parser",
"state_parser",
"human_pose_parser",
"local_correspondence",
}
)
_COLOR_KEYS = ("line_color", "wire_color", "route_color", "expected_color", "target_color", "color")
_SUPPORTED_COLORS = frozenset(
{"red", "orange", "yellow", "green", "cyan", "blue", "purple", "pink", "black", "white", "gray", "grey", "brown"}
)
def _json_value(value: Any, default: Any) -> Any:
if value in (None, ""):
return default
if not isinstance(value, str):
return value
try:
return json.loads(value)
except (TypeError, ValueError):
return default
def _strings(value: Any) -> list[str]:
decoded = _json_value(value, value)
if isinstance(decoded, str):
return [item for item in decoded.split("|") if item]
if isinstance(decoded, (list, tuple, set)):
return [str(item) for item in decoded if str(item)]
return []
def _base_payload(call: Mapping[str, Any], tool: str) -> dict[str, Any]:
return {
"call_id": str(call.get("call_id", "")),
"cache_key": str(call.get("cache_key", "")),
"case_key": str(call.get("case_key", "")),
"check_ids": _strings(call.get("check_ids", [])),
"image_role": str(call.get("image_role", "")),
"tool": tool,
"status": "unsupported",
"backend": "pvr_cv_tools_v1",
"metrics": {},
"thresholds": {},
"limitations": ["evidence_only_no_pass_fail_score"],
}
def _result(
call: Mapping[str, Any],
*,
tool: str,
status: str,
metrics: Mapping[str, Any] | None = None,
thresholds: Mapping[str, Any] | None = None,
limitations: Iterable[str] = (),
backend: str = "pvr_cv_tools_v1",
) -> dict[str, Any]:
payload = _base_payload(call, tool)
payload.update(
{
"status": status,
"backend": backend,
"metrics": dict(metrics or {}),
"thresholds": dict(thresholds or {}),
"limitations": list(dict.fromkeys([*payload["limitations"], *limitations])),
}
)
return payload
def error_payload(call: Mapping[str, Any], exc: Exception) -> dict[str, Any]:
tool = str(call.get("tool", ""))
payload = _result(call, tool=tool, status="error", limitations=("tool_execution_failed",))
payload["error_type"] = type(exc).__name__
payload["error_message"] = str(exc)
return payload
def _params(call: Mapping[str, Any], check_params: Mapping[str, Any] | None) -> dict[str, Any]:
direct = _json_value(call.get("params", {}), {})
merged = dict(direct) if isinstance(direct, dict) else {}
if isinstance(check_params, Mapping):
merged.update(check_params)
rule = merged.get("decision_rule")
if isinstance(rule, Mapping) and isinstance(rule.get("parameters"), Mapping):
# The resolved compiler stores thresholds here. Keep top-level values
# authoritative when an explicit adapter has already normalized them.
merged = {**dict(rule["parameters"]), **merged}
return merged
def _load_rgb(path: str | Path) -> np.ndarray:
with Image.open(path) as image:
return np.asarray(image.convert("RGB"), dtype=np.uint8)
def _resize_rgb(rgb: np.ndarray, size: tuple[int, int]) -> np.ndarray:
return np.asarray(Image.fromarray(rgb).resize(size, Image.Resampling.BILINEAR), dtype=np.uint8)
def _pair_paths(call: Mapping[str, Any]) -> tuple[Path, Path]:
if str(call.get("image_role", "")) != "input_pred":
raise ValueError("paired CV tool requires image_role=input_pred")
return Path(str(call["input"])), Path(str(call["pred"]))
def _single_path(call: Mapping[str, Any]) -> Path:
role = str(call.get("image_role", "pred"))
if role not in {"input", "pred"}:
raise ValueError(f"single-image CV tool does not support image_role={role!r}")
return Path(str(call[role]))
def _gray_features(rgb: np.ndarray) -> np.ndarray:
gray = np.dot(rgb.astype(np.float32) / 255.0, np.array([0.299, 0.587, 0.114], dtype=np.float32))
# Gradients reduce the influence of global color and brightness changes.
gx = np.zeros_like(gray)
gy = np.zeros_like(gray)
gx[:, 1:] = np.diff(gray, axis=1)
gy[1:, :] = np.diff(gray, axis=0)
feature = np.hypot(gx, gy)
feature -= float(feature.mean())
return feature
def _phase_translation(reference: np.ndarray, moving: np.ndarray) -> tuple[float, float, dict[str, float]]:
fa = np.fft.fft2(reference)
fb = np.fft.fft2(moving)
cross = fa * np.conj(fb)
magnitude = np.abs(cross)
cross /= np.maximum(magnitude, 1e-12)
correlation = np.fft.ifft2(cross).real
peak_y, peak_x = np.unravel_index(int(np.argmax(correlation)), correlation.shape)
height, width = correlation.shape
shift_y = float(peak_y - height if peak_y > height // 2 else peak_y)
shift_x = float(peak_x - width if peak_x > width // 2 else peak_x)
peak = float(correlation[peak_y, peak_x])
exclusion = correlation.copy()
radius = 3
ys = [(peak_y + offset) % height for offset in range(-radius, radius + 1)]
xs = [(peak_x + offset) % width for offset in range(-radius, radius + 1)]
exclusion[np.ix_(ys, xs)] = -np.inf
sidelobe = float(np.max(exclusion)) if np.isfinite(exclusion).any() else 0.0
median = float(np.median(correlation))
mad = float(np.median(np.abs(correlation - median)))
robust_z = (peak - median) / max(1e-9, 1.4826 * mad)
# Keep cache JSON standards-compliant even for a perfect impulse peak.
peak_to_sidelobe = (peak + 1e-9) / (max(0.0, sidelobe) + 1e-9)
return shift_x, shift_y, {
"phase_peak": peak,
"phase_sidelobe_peak": sidelobe,
"peak_to_sidelobe_ratio": peak_to_sidelobe,
"phase_peak_robust_z": robust_z,
}
def run_image_registration(call: Mapping[str, Any], params: Mapping[str, Any]) -> dict[str, Any]:
input_path, pred_path = _pair_paths(call)
input_rgb, pred_rgb = _load_rgb(input_path), _load_rgb(pred_path)
input_h, input_w = input_rgb.shape[:2]
pred_h, pred_w = pred_rgb.shape[:2]
input_aspect = input_w / max(1, input_h)
pred_aspect = pred_w / max(1, pred_h)
aspect_delta = abs(input_aspect - pred_aspect) / max(input_aspect, 1e-9)
max_dimension = int(params.get("registration_max_dimension", 512))
scale = min(1.0, max_dimension / max(input_h, input_w))
work_w = max(32, int(round(input_w * scale)))
work_h = max(32, int(round(input_h * scale)))
ref = _gray_features(_resize_rgb(input_rgb, (work_w, work_h)))
moving = _gray_features(_resize_rgb(pred_rgb, (work_w, work_h)))
texture_std = min(float(ref.std()), float(moving.std()))
thresholds = {
"min_texture_gradient_std": float(params.get("min_texture_gradient_std", 0.015)),
"min_peak_to_sidelobe_ratio": float(params.get("min_peak_to_sidelobe_ratio", 1.25)),
"min_phase_peak_robust_z": float(params.get("min_phase_peak_robust_z", 8.0)),
"min_overlap_fraction": float(params.get("min_registration_overlap", 0.70)),
"max_aspect_ratio_relative_delta": float(params.get("max_aspect_ratio_relative_delta", 0.03)),
}
shift_x_work, shift_y_work, phase = _phase_translation(ref, moving)
shift_x = shift_x_work / scale
shift_y = shift_y_work / scale
overlap = max(0.0, input_w - abs(shift_x)) * max(0.0, input_h - abs(shift_y)) / max(1.0, input_w * input_h)
metrics: dict[str, Any] = {
"input_size_wh": [input_w, input_h],
"pred_size_wh": [pred_w, pred_h],
"working_size_wh": [work_w, work_h],
"aspect_ratio_relative_delta": aspect_delta,
"texture_gradient_std": texture_std,
"translation_pred_to_input_px": [shift_x, shift_y],
"translation_matrix_pred_to_input": [[1.0, 0.0, shift_x], [0.0, 1.0, shift_y], [0.0, 0.0, 1.0]],
"overlap_fraction": overlap,
**phase,
}
limitations = ["translation_only_no_rotation_scale_or_homography"]
supported_geometry = aspect_delta <= thresholds["max_aspect_ratio_relative_delta"]
reliable = (
supported_geometry
and texture_std >= thresholds["min_texture_gradient_std"]
and phase["peak_to_sidelobe_ratio"] >= thresholds["min_peak_to_sidelobe_ratio"]
and phase["phase_peak_robust_z"] >= thresholds["min_phase_peak_robust_z"]
and overlap >= thresholds["min_overlap_fraction"]
)
if not supported_geometry:
limitations.append("aspect_ratio_mismatch_requires_non_translation_registration")
if texture_std < thresholds["min_texture_gradient_std"]:
limitations.append("insufficient_visual_texture_for_registration")
if not reliable:
limitations.append("registration_not_reliable_enough_for_automatic_scoring")
return _result(
call,
tool="image_registration",
status="ok" if reliable else "insufficient",
metrics=metrics,
thresholds=thresholds,
limitations=limitations,
backend="numpy_phase_correlation_translation_v1",
)
def _rect_to_pixels(value: Any, width: int, height: int) -> tuple[int, int, int, int] | None:
if isinstance(value, Mapping):
if "geometry" in value:
return _rect_to_pixels(value["geometry"], width, height)
if "bbox" in value:
return _rect_to_pixels(value["bbox"], width, height)
if "rect" in value:
return _rect_to_pixels(value["rect"], width, height)
if {"x0", "y0", "x1", "y1"} <= set(value):
value = [value["x0"], value["y0"], value["x1"], value["y1"]]
elif {"x", "y", "width", "height"} <= set(value):
value = [value["x"], value["y"], float(value["x"]) + float(value["width"]), float(value["y"]) + float(value["height"])]
elif isinstance(value.get("points"), list) and value["points"]:
points = value["points"]
try:
xs = [float(point[0]) for point in points]
ys = [float(point[1]) for point in points]
except (TypeError, ValueError, IndexError):
return None
value = [min(xs), min(ys), max(xs), max(ys)]
else:
return None
if not isinstance(value, (list, tuple)) or len(value) != 4:
return None
try:
x0, y0, x1, y1 = [float(item) for item in value]
except (TypeError, ValueError):
return None
if max(abs(x0), abs(y0), abs(x1), abs(y1)) <= 1.0:
x0, x1 = x0 * width, x1 * width
y0, y1 = y0 * height, y1 * height
x0, x1 = sorted((max(0, min(width, int(round(x0)))), max(0, min(width, int(round(x1))))))
y0, y1 = sorted((max(0, min(height, int(round(y0)))), max(0, min(height, int(round(y1))))))
return (x0, y0, x1, y1) if x1 > x0 and y1 > y0 else None
def _region_ids(call: Mapping[str, Any], params: Mapping[str, Any]) -> list[str]:
result = _strings(call.get("region_ids", []))
for key in ("zone", "zone_id", "target_zone", "source_zone", "forbidden_zone", "target_region", "corridor"):
value = params.get(key)
if isinstance(value, str) and value:
result.append(value)
for key in ("invariant_zones", "target_zones", "forbidden_zones", "exclude_zones", "required_nodes"):
value = params.get(key)
if isinstance(value, list):
result.extend(str(item) for item in value if isinstance(item, (str, int)))
return list(dict.fromkeys(result))
def _resolved_regions(
call: Mapping[str, Any], params: Mapping[str, Any], regions: Mapping[str, Any] | None, width: int, height: int
) -> tuple[dict[str, tuple[int, int, int, int]], list[str]]:
candidates: dict[str, Any] = dict(regions or {})
planned = params.get("planned_regions", [])
if isinstance(planned, list):
for item in planned:
if isinstance(item, Mapping):
region_id = str(item.get("region_id") or item.get("id") or "")
if region_id:
candidates.setdefault(region_id, item)
resolved: dict[str, tuple[int, int, int, int]] = {}
missing: list[str] = []
for region_id in _region_ids(call, params):
rect = _rect_to_pixels(candidates.get(region_id), width, height)
if rect is None:
missing.append(region_id)
else:
resolved[region_id] = rect
return resolved, missing
def _translate_rgb(rgb: np.ndarray, shift_x: float, shift_y: float, output_shape: tuple[int, int]) -> tuple[np.ndarray, np.ndarray]:
from scipy import ndimage
height, width = output_shape
if rgb.shape[:2] != output_shape:
rgb = _resize_rgb(rgb, (width, height))
shifted = np.stack(
[ndimage.shift(rgb[..., channel].astype(np.float32), shift=(shift_y, shift_x), order=1, mode="constant", cval=np.nan) for channel in range(3)],
axis=2,
)
valid = np.isfinite(shifted).all(axis=2)
return np.nan_to_num(shifted, nan=0.0), valid
def _change_metrics(input_rgb: np.ndarray, aligned_pred: np.ndarray, mask: np.ndarray, threshold: float) -> dict[str, Any]:
pixels = int(mask.sum())
if pixels <= 0:
return {"pixel_count": 0}
diff = np.abs(input_rgb.astype(np.float32) - aligned_pred.astype(np.float32)) / 255.0
per_pixel = diff.mean(axis=2)[mask]
return {
"pixel_count": pixels,
"rgb_mae": float(per_pixel.mean()),
"rgb_rmse": float(np.sqrt(np.mean(per_pixel**2))),
"changed_fraction": float((per_pixel >= threshold).mean()),
"difference_p95": float(np.quantile(per_pixel, 0.95)),
}
def run_change_analysis(
call: Mapping[str, Any],
params: Mapping[str, Any],
regions: Mapping[str, Any] | None,
dependencies: Mapping[str, Mapping[str, Any]],
) -> dict[str, Any]:
input_path, pred_path = _pair_paths(call)
input_rgb, pred_rgb = _load_rgb(input_path), _load_rgb(pred_path)
height, width = input_rgb.shape[:2]
dependency_ids = _strings(call.get("depends_on", []))
registration = next((dependencies[item] for item in dependency_ids if item in dependencies), None)
threshold = float(params.get("change_pixel_threshold", 24.0 / 255.0))
thresholds = {"changed_pixel_mean_rgb_fraction": threshold, "registration_status_required": "ok"}
limitations: list[str] = []
shift_x = shift_y = 0.0
registration_ok = False
if isinstance(registration, Mapping):
translation = registration.get("metrics", {}).get("translation_pred_to_input_px", [])
if isinstance(translation, list) and len(translation) == 2:
shift_x, shift_y = float(translation[0]), float(translation[1])
registration_ok = registration.get("status") == "ok"
else:
limitations.append("missing_registration_dependency")
if not registration_ok:
limitations.append("change_metrics_not_safe_for_automatic_scoring_without_reliable_registration")
aligned, valid = _translate_rgb(pred_rgb, shift_x, shift_y, (height, width))
resolved, missing = _resolved_regions(call, params, regions, width, height)
if missing:
limitations.append("unresolved_regions:" + "|".join(missing))
global_metrics = _change_metrics(input_rgb, aligned, valid, threshold)
region_metrics: dict[str, Any] = {}
for region_id, (x0, y0, x1, y1) in resolved.items():
mask = np.zeros((height, width), dtype=bool)
mask[y0:y1, x0:x1] = True
region_metrics[region_id] = {"bbox_xyxy": [x0, y0, x1, y1], **_change_metrics(input_rgb, aligned, valid & mask, threshold)}
if not resolved:
limitations.append("no_resolved_regions_global_metrics_only")
metrics = {
"registration_call_id": str(registration.get("call_id", "")) if isinstance(registration, Mapping) else "",
"applied_translation_pred_to_input_px": [shift_x, shift_y],
"global": global_metrics,
"regions": region_metrics,
}
status = "ok" if registration_ok and (resolved or not _region_ids(call, params)) else "insufficient"
return _result(
call,
tool="change_analysis",
status=status,
metrics=metrics,
thresholds=thresholds,
limitations=limitations,
backend="registered_rgb_difference_v1",
)
def _explicit_colors(params: Mapping[str, Any]) -> list[str]:
values: list[Any] = []
for key in _COLOR_KEYS:
if key in params:
values.append(params[key])
if "colors" in params:
values.extend(params["colors"] if isinstance(params["colors"], list) else [params["colors"]])
result = []
for value in values:
color = str(value).lower().strip()
if color in _SUPPORTED_COLORS:
result.append("gray" if color == "grey" else color)
return list(dict.fromkeys(result))
def _rgb_to_hsv(rgb: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
arr = rgb.astype(np.float32) / 255.0
r, g, b = arr[..., 0], arr[..., 1], arr[..., 2]
maximum, minimum = arr.max(axis=2), arr.min(axis=2)
delta = maximum - minimum
hue = np.zeros_like(maximum)
active = delta > 1e-6
rmax, gmax, bmax = active & (maximum == r), active & (maximum == g), active & (maximum == b)
hue[rmax] = (60.0 * ((g[rmax] - b[rmax]) / delta[rmax])) % 360.0
hue[gmax] = 60.0 * ((b[gmax] - r[gmax]) / delta[gmax] + 2.0)
hue[bmax] = 60.0 * ((r[bmax] - g[bmax]) / delta[bmax] + 4.0)
saturation = np.zeros_like(maximum)
nonzero = maximum > 1e-6
saturation[nonzero] = delta[nonzero] / maximum[nonzero]
return hue, saturation, maximum
def _color_mask(rgb: np.ndarray, color: str) -> tuple[np.ndarray, dict[str, Any]]:
h, s, v = _rgb_to_hsv(rgb)
ranges: dict[str, tuple[tuple[float, float], ...]] = {
"red": ((345, 360), (0, 15)), "orange": ((15, 42),), "yellow": ((42, 72),),
"green": ((72, 165),), "cyan": ((165, 205),), "blue": ((205, 260),),
"purple": ((260, 300),), "pink": ((300, 345),), "brown": ((10, 45),),
}
if color == "black":
return v <= 0.22, {"value_max": 0.22}
if color == "white":
return (s <= 0.18) & (v >= 0.78), {"saturation_max": 0.18, "value_min": 0.78}
if color == "gray":
return (s <= 0.20) & (v > 0.22) & (v < 0.78), {"saturation_max": 0.20, "value_range": [0.22, 0.78]}
sat_min, val_min = (0.28, 0.12) if color == "brown" else (0.30, 0.20)
hue_mask = np.zeros(h.shape, dtype=bool)
for low, high in ranges[color]:
hue_mask |= (h >= low) & (h <= high)
mask = hue_mask & (s >= sat_min) & (v >= val_min)
if color == "brown":
mask &= v <= 0.65
return mask, {"hue_ranges_degrees": [list(item) for item in ranges[color]], "saturation_min": sat_min, "value_min": val_min}
def _mask_stats(mask: np.ndarray, roi: tuple[int, int, int, int] | None = None) -> dict[str, Any]:
from scipy import ndimage
if roi is None:
x0, y0, x1, y1 = 0, 0, mask.shape[1], mask.shape[0]
else:
x0, y0, x1, y1 = roi
selected = np.zeros_like(mask, dtype=bool)
selected[y0:y1, x0:x1] = True
clipped = mask & selected
labels, count = ndimage.label(clipped)
areas = [int((labels == index).sum()) for index in range(1, count + 1)]
area = int(clipped.sum())
return {
"bbox_xyxy": [x0, y0, x1, y1],
"roi_pixel_count": int(selected.sum()),
"mask_pixel_count": area,
"mask_fraction": area / max(1, int(selected.sum())),
"component_count": int(count),
"largest_component_area_px": max(areas, default=0),
}
def _color_region_metrics(
rgb: np.ndarray, colors: list[str], resolved: Mapping[str, tuple[int, int, int, int]]
) -> tuple[dict[str, Any], dict[str, Any]]:
metrics: dict[str, Any] = {}
thresholds: dict[str, Any] = {}
for color in colors:
mask, color_thresholds = _color_mask(rgb, color)
thresholds[color] = color_thresholds
metrics[color] = {
"global": _mask_stats(mask),
"regions": {region_id: _mask_stats(mask, rect) for region_id, rect in resolved.items()},
}
return metrics, thresholds
def run_route_parser(
call: Mapping[str, Any], params: Mapping[str, Any], regions: Mapping[str, Any] | None
) -> dict[str, Any]:
rgb = _load_rgb(_single_path(call))
height, width = rgb.shape[:2]
colors = _explicit_colors(params)
if not colors:
return _result(
call,
tool="route_parser",
status="unsupported",
limitations=("route_color_or_typed_route_segmentation_model_not_specified", "semantic_route_identity_not_inferred_from_question_text"),
)
resolved, missing = _resolved_regions(call, params, regions, width, height)
metrics, color_thresholds = _color_region_metrics(rgb, colors, resolved)
limitations = ["color_mask_is_not_semantic_route_identity", "connectivity_and_endpoint_decisions_require_downstream_checker"]
if missing:
limitations.append("unresolved_regions:" + "|".join(missing))
status = "ok" if not missing else "insufficient"
return _result(
call,
tool="route_parser",
status=status,
metrics={"colors": metrics, "resolved_region_count": len(resolved)},
thresholds={"color_masks": color_thresholds},
limitations=limitations,
backend="explicit_hsv_route_mask_v1",
)
def run_visual_attribute_parser(
call: Mapping[str, Any], params: Mapping[str, Any], regions: Mapping[str, Any] | None
) -> dict[str, Any]:
rgb = _load_rgb(_single_path(call))
height, width = rgb.shape[:2]
colors = _explicit_colors(params)
if not colors:
return _result(
call,
tool="visual_attribute_parser",
status="unsupported",
limitations=("only_explicit_color_attributes_have_an_objective_parser", "symbols_glyphs_orientation_and_semantic_attributes_require_dedicated_models"),
)
resolved, missing = _resolved_regions(call, params, regions, width, height)
metrics, color_thresholds = _color_region_metrics(rgb, colors, resolved)
limitations = ["color_fraction_does_not_establish_object_identity"]
if missing:
limitations.append("unresolved_regions:" + "|".join(missing))
if not resolved:
limitations.append("no_resolved_region_global_color_statistics_only")
status = "ok" if resolved and not missing else "insufficient"
return _result(
call,
tool="visual_attribute_parser",
status=status,
metrics={"colors": metrics, "resolved_region_count": len(resolved)},
thresholds={"color_masks": color_thresholds},
limitations=limitations,
backend="explicit_hsv_attribute_mask_v1",
)
def _structured_cells(params: Mapping[str, Any]) -> list[dict[str, Any]]:
for key in ("expected_cells", "cells", "slots", "expected_slots", "cell_states"):
value = params.get(key)
if isinstance(value, list) and all(isinstance(item, Mapping) for item in value):
return [dict(item) for item in value]
return []
def run_state_parser(
call: Mapping[str, Any], params: Mapping[str, Any], regions: Mapping[str, Any] | None
) -> dict[str, Any]:
rgb = _load_rgb(_single_path(call))
height, width = rgb.shape[:2]
cells = _structured_cells(params)
if not cells:
return _result(
call,
tool="state_parser",
status="unsupported",
limitations=("generic_visual_state_has_no_universal_parser", "requires_explicit_cells_with_geometry_and_objective_attribute_schema"),
)
external_regions = dict(regions or {})
cell_metrics: list[dict[str, Any]] = []
unresolved: list[str] = []
color_thresholds: dict[str, Any] = {}
for index, cell in enumerate(cells):
cell_id = str(cell.get("cell") or cell.get("slot") or cell.get("id") or index)
geometry = cell.get("roi") or cell.get("bbox") or cell.get("rect") or external_regions.get(cell_id)
rect = _rect_to_pixels(geometry, width, height)
color = str(cell.get("expected_color") or cell.get("color") or "").lower().strip()
if color == "grey":
color = "gray"
if rect is None or color not in _SUPPORTED_COLORS:
unresolved.append(cell_id)
cell_metrics.append({"cell_id": cell_id, "status": "insufficient", "reason": "missing_geometry_or_supported_explicit_color"})
continue
mask, thresholds = _color_mask(rgb, color)
color_thresholds[color] = thresholds
cell_metrics.append({"cell_id": cell_id, "status": "measured", "expected_color": color, **_mask_stats(mask, rect)})
limitations = ["cell_color_fraction_does_not_infer_semantic_occupancy_or_object_identity"]
if unresolved:
limitations.append("unresolved_cells:" + "|".join(unresolved))
measured = len(cells) - len(unresolved)
status = "ok" if measured == len(cells) else "insufficient"
return _result(
call,
tool="state_parser",
status=status,
metrics={"cells": cell_metrics, "measured_cell_count": measured, "requested_cell_count": len(cells)},
thresholds={"color_masks": color_thresholds},
limitations=limitations,
backend="explicit_cell_color_parser_v1",
)
def execute_cv_call(
call: Mapping[str, Any],
*,
check_params: Mapping[str, Any] | None = None,
regions: Mapping[str, Any] | None = None,
dependencies: Mapping[str, Mapping[str, Any]] | None = None,
runtime_resources: Mapping[str, Any] | None = None,
) -> dict[str, Any]:
"""Execute one typed CV call and return provenance-rich evidence only."""
tool = str(call.get("tool", ""))
if tool not in CV_TOOL_TYPES:
raise ValueError(f"unsupported CV tool type: {tool}")
parsed_params = _params(call, check_params)
if tool == "image_registration":
return run_image_registration(call, parsed_params)
if tool == "change_analysis":
return run_change_analysis(call, parsed_params, regions, dependencies or {})
if tool == "route_parser":
return run_route_parser(call, parsed_params, regions)
if tool == "visual_attribute_parser":
return run_visual_attribute_parser(call, parsed_params, regions)
if tool == "human_pose_parser":
result = run_human_pose_estimation(
_single_path(call),
params=parsed_params,
weights_path=(runtime_resources or {}).get("human_pose_weights"),
)
return _result(
call,
tool=tool,
status=str(result.get("status") or "error"),
metrics=result.get("metrics") if isinstance(result.get("metrics"), Mapping) else {},
thresholds=result.get("thresholds") if isinstance(result.get("thresholds"), Mapping) else {},
limitations=result.get("limitations") if isinstance(result.get("limitations"), Iterable) else (),
backend=str(result.get("backend") or "pvr.human_pose_executor.v1"),
)
if tool == "local_correspondence":
input_path, pred_path = _pair_paths(call)
result = run_local_correspondence(
input_path,
pred_path,
params=parsed_params,
dependencies=dependencies or {},
)
return _result(
call,
tool=tool,
status=str(result.get("status") or "error"),
metrics=result.get("metrics") if isinstance(result.get("metrics"), Mapping) else {},
thresholds=result.get("thresholds") if isinstance(result.get("thresholds"), Mapping) else {},
limitations=result.get("limitations") if isinstance(result.get("limitations"), Iterable) else (),
backend=str(result.get("backend") or "pvr.local_correspondence_executor.v1"),
)
return run_state_parser(call, parsed_params, regions)