| |
| """Compare action types, coordinates, numeric inputs, and control sequences.""" |
|
|
| from decimal import Decimal, InvalidOperation |
| import json |
| import math |
| import re |
|
|
|
|
| TYPE_NUMBER_PATTERN = re.compile( |
| r"[+-]?(?:(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)" |
| ) |
|
|
|
|
| def numeric_type_signature(value): |
| """Normalize numeric spelling while preserving all keyboard controls.""" |
| if not isinstance(value, str): |
| return None |
| normalized = value.replace("\r\n", "\n").replace("\r", "\n") |
| matches = list(TYPE_NUMBER_PATTERN.finditer(normalized)) |
| if not matches: |
| return None |
| numbers = [] |
| separators = [] |
| cursor = 0 |
| try: |
| for match in matches: |
| separators.append(normalized[cursor:match.start()]) |
| number = Decimal(match.group(0)) |
| if not number.is_finite(): |
| return None |
| numbers.append(number) |
| cursor = match.end() |
| except InvalidOperation: |
| return None |
| separators.append(normalized[cursor:]) |
| return tuple(numbers), tuple(separators) |
|
|
|
|
| def parameter_coordinates(value): |
| """Decode a coordinate pair independently of the predicted action tag.""" |
| candidate = value |
| if isinstance(candidate, str): |
| try: |
| candidate = json.loads(candidate.strip()) |
| except Exception: |
| return None |
| if not isinstance(candidate, (list, tuple)) or len(candidate) != 2: |
| return None |
| try: |
| result = [float(candidate[0]), float(candidate[1])] |
| except (TypeError, ValueError): |
| return None |
| if not all(math.isfinite(item) for item in result): |
| return None |
| return result |
|
|
|
|
| def compare_to_reference(generated, expected, record=None, |
| screen_size=(1920, 1080)): |
| """Compare two parsed actions using the canonical CAD-Drawer protocol.""" |
| result = { |
| "action_match": generated.action == expected.action, |
| "parameter_match": False, |
| "step_success": False, |
| "full_match": False, |
| } |
|
|
| |
| |
| if expected.action in ("click", "double_click"): |
| generated_coordinates = parameter_coordinates(generated.parameters) |
| if generated_coordinates is None: |
| return result |
| dx = generated_coordinates[0] - expected.parameters[0] |
| dy = generated_coordinates[1] - expected.parameters[1] |
| result["normalized_l2"] = round(math.hypot(dx, dy), 8) |
| result["pixel_l2_at_1920x1080"] = round(math.hypot( |
| dx * float(screen_size[0]), dy * float(screen_size[1])), 3) |
|
|
| bounds = None |
| if record is not None: |
| values = [record.get(name) for name in ( |
| "x_min_norm", "x_max_norm", "y_min_norm", "y_max_norm")] |
| if all(value is not None for value in values): |
| bounds = [float(value) for value in values] |
| if bounds is not None: |
| x_min, x_max, y_min, y_max = bounds |
| result["parameter_match"] = ( |
| x_min <= generated_coordinates[0] <= x_max and |
| y_min <= generated_coordinates[1] <= y_max |
| ) |
| result["target_bbox_norm"] = bounds |
| else: |
| result["parameter_match"] = math.hypot( |
| dx * float(screen_size[0]), |
| dy * float(screen_size[1]), |
| ) <= 5.0 |
| elif expected.action == "type": |
| generated_signature = numeric_type_signature(generated.parameters) |
| expected_signature = numeric_type_signature(expected.parameters) |
| if generated_signature is not None and expected_signature is not None: |
| result["parameter_match"] = ( |
| generated_signature == expected_signature) |
| result["parameter_match_mode"] = ( |
| "numeric_value_and_control_sequence") |
| else: |
| generated_text = ( |
| generated.parameters.replace("\r\n", "\n").replace("\r", "\n") |
| if isinstance(generated.parameters, str) else None) |
| expected_text = ( |
| expected.parameters.replace("\r\n", "\n").replace("\r", "\n") |
| if isinstance(expected.parameters, str) else None) |
| result["parameter_match"] = generated_text == expected_text |
| result["parameter_match_mode"] = "exact_control_text" |
| else: |
| result["parameter_match"] = ( |
| generated.parameters == expected.parameters) |
|
|
| result["step_success"] = ( |
| result["action_match"] and result["parameter_match"]) |
| result["full_match"] = result["step_success"] |
| return result |
|
|
