| |
| """Binding-aware native-DIMENSION spam gate for v5.2-rc5g-final. |
| |
| RC5G inherits a historical naming error: EV43 groups native dimensions by |
| semantic family and displayed value in order to balance drawing-scale votes, |
| then v5/v5.1 reuses ``n_dimensions - n_groups`` as a *true duplicate* count. |
| Legitimate equal dimensions in different views therefore can hard-zero an |
| otherwise perfect drawing. |
| |
| RC5H deliberately leaves the EV43 scale-consistency grouping untouched. It |
| only replaces the anti-hack identity used by the binary structure gate: |
| |
| * LINEAR/ALIGNED dimensions are duplicates only when their unordered measured |
| endpoint pair is the same (within drawing-relative coordinate quantisation); |
| * DIAMETER/RADIUS dimensions are compared through a common circle centre, |
| radius, and diameter-equivalent displayed value; |
| * a reference signature must bind to actual drawing geometry. An unresolved |
| or detached dimension is never certified as a true duplicate merely because |
| its displayed value happens to match another annotation. |
| |
| The module is an add-only candidate wrapper around |
| ``eval_geometric052_rc5g_final``. It updates the top-level anti-hack record, |
| both structure components, both formal rewards, and the offline benchmark. |
| No continuous component definition is changed. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import copy |
| import math |
| from collections import defaultdict |
| from pathlib import Path |
| from typing import Any, Mapping, Sequence |
|
|
| try: |
| from . import eval_geometric052_rc5g_final as RC5G_FINAL |
| except ImportError: |
| import eval_geometric052_rc5g_final as RC5G_FINAL |
|
|
|
|
| METRIC_VERSION = "v5.2-rc5h" |
| SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc5h" |
| ENGINEERING_THRESHOLDS = dict(RC5G_FINAL.ENGINEERING_THRESHOLDS) |
| PHYSICAL_SUPPORTED_SEMANTICS = RC5G_FINAL.PHYSICAL_SUPPORTED_SEMANTICS |
| MAX_MATCHED_OFFSET_DISPERSION_FRACTION = ( |
| RC5G_FINAL.MAX_MATCHED_OFFSET_DISPERSION_FRACTION |
| ) |
|
|
| RC3 = RC5G_FINAL.RC5G.RC5F.RC5.RC3 |
| BASE = RC3.BASE |
|
|
| COORDINATE_QUANTISATION_FRACTION = 1.0e-5 |
| COORDINATE_QUANTISATION_ABS = 1.0e-6 |
| GEOMETRY_BINDING_FRACTION = 5.0e-4 |
| DISPLAY_VALUE_QUANTISATION_REL = 1.0e-6 |
| DISPLAY_VALUE_QUANTISATION_ABS = 1.0e-6 |
| TRUE_DUPLICATE_GATE_RATIO = 0.50 |
|
|
|
|
| def _finite_number(value: Any) -> float | None: |
| if isinstance(value, bool) or not isinstance(value, (int, float)): |
| return None |
| number = float(value) |
| return number if math.isfinite(number) else None |
|
|
|
|
| def _finite_point(value: Any) -> tuple[float, float] | None: |
| if ( |
| not isinstance(value, Sequence) |
| or isinstance(value, (str, bytes)) |
| or len(value) < 2 |
| ): |
| return None |
| first, second = _finite_number(value[0]), _finite_number(value[1]) |
| if first is None or second is None: |
| return None |
| return first, second |
|
|
|
|
| def _normalised_family(value: Any) -> str | None: |
| family = str(value or "").casefold() |
| if family in {"linear", "aligned"}: |
| return "linear" |
| if family in {"diameter", "radius"}: |
| return "circular" |
| return None |
|
|
|
|
| def _normalised_display_value(dimension: Mapping[str, Any]) -> float | None: |
| value = _finite_number(dimension.get("display_value")) |
| if value is None: |
| return None |
| family = str(dimension.get("family") or "").casefold() |
| if family == "radius": |
| value *= 2.0 |
| return abs(value) |
|
|
|
|
| def _drawing_diagonal(entities: Mapping[str, Any]) -> float: |
| """Return a finite geometry-only scale; DIMENSION placement is ignored.""" |
|
|
| try: |
| bounds = BASE.EV5._safe_bbox(entities) |
| if bounds is not None: |
| low, high = bounds |
| dx = float(high[0]) - float(low[0]) |
| dy = float(high[1]) - float(low[1]) |
| diagonal = math.hypot(dx, dy) |
| if math.isfinite(diagonal) and diagonal > 0.0: |
| return max(diagonal, 1.0) |
| except (AttributeError, IndexError, TypeError, ValueError): |
| pass |
|
|
| points: list[tuple[float, float]] = [] |
| for dimension in entities.get("dims", []): |
| if not isinstance(dimension, Mapping): |
| continue |
| refs = dimension.get("ref_points") |
| if not isinstance(refs, Mapping): |
| continue |
| for raw in refs.values(): |
| point = _finite_point(raw) |
| if point is not None: |
| points.append(point) |
| if not points: |
| return 1.0 |
| xs, ys = zip(*points) |
| diagonal = math.hypot(max(xs) - min(xs), max(ys) - min(ys)) |
| return max(diagonal, 1.0) if math.isfinite(diagonal) else 1.0 |
|
|
|
|
| def _coordinate_key(point: tuple[float, float], tolerance: float) -> tuple[int, int]: |
| return int(round(point[0] / tolerance)), int(round(point[1] / tolerance)) |
|
|
|
|
| def _value_key(value: float) -> tuple[int, int]: |
| tolerance = max( |
| DISPLAY_VALUE_QUANTISATION_ABS, |
| DISPLAY_VALUE_QUANTISATION_REL * max(abs(value), 1.0), |
| ) |
| |
| |
| band = int(math.floor(math.log10(tolerance))) |
| return band, int(round(value / tolerance)) |
|
|
|
|
| def _point_segment_distance( |
| point: tuple[float, float], line: Sequence[Any] |
| ) -> float | None: |
| if len(line) < 4: |
| return None |
| ax, ay = _finite_number(line[0]), _finite_number(line[1]) |
| bx, by = _finite_number(line[2]), _finite_number(line[3]) |
| if None in {ax, ay, bx, by}: |
| return None |
| dx, dy = float(bx) - float(ax), float(by) - float(ay) |
| denominator = dx * dx + dy * dy |
| if denominator <= 1.0e-18: |
| return math.dist(point, (float(ax), float(ay))) |
| fraction = ( |
| (point[0] - float(ax)) * dx + (point[1] - float(ay)) * dy |
| ) / denominator |
| fraction = min(1.0, max(0.0, fraction)) |
| return math.hypot( |
| point[0] - (float(ax) + fraction * dx), |
| point[1] - (float(ay) + fraction * dy), |
| ) |
|
|
|
|
| def _distance_to_geometry( |
| point: tuple[float, float], entities: Mapping[str, Any] |
| ) -> float: |
| distances: list[float] = [] |
| for line in entities.get("lines", []): |
| if isinstance(line, Sequence) and not isinstance(line, (str, bytes)): |
| distance = _point_segment_distance(point, line) |
| if distance is not None and math.isfinite(distance): |
| distances.append(distance) |
| for family in ("circles", "arcs"): |
| for item in entities.get(family, []): |
| if ( |
| not isinstance(item, Sequence) |
| or isinstance(item, (str, bytes)) |
| or len(item) < 3 |
| ): |
| continue |
| cx, cy, radius = ( |
| _finite_number(item[0]), |
| _finite_number(item[1]), |
| _finite_number(item[2]), |
| ) |
| if cx is None or cy is None or radius is None: |
| continue |
| radial = math.dist(point, (cx, cy)) |
| distances.extend((abs(radial - abs(radius)), radial)) |
| return min(distances) if distances else math.inf |
|
|
|
|
| def _linear_signature( |
| dimension: Mapping[str, Any], |
| entities: Mapping[str, Any], |
| *, |
| coordinate_tolerance: float, |
| binding_tolerance: float, |
| ) -> tuple[tuple[Any, ...], dict[str, Any]] | None: |
| refs = dimension.get("ref_points") |
| if not isinstance(refs, Mapping): |
| return None |
| first = _finite_point(refs.get("defpoint2")) |
| second = _finite_point(refs.get("defpoint3")) |
| value = _normalised_display_value(dimension) |
| if first is None or second is None or value is None: |
| return None |
| distances = ( |
| _distance_to_geometry(first, entities), |
| _distance_to_geometry(second, entities), |
| ) |
| if any( |
| not math.isfinite(distance) or distance > binding_tolerance |
| for distance in distances |
| ): |
| return None |
| endpoints = tuple( |
| sorted( |
| ( |
| _coordinate_key(first, coordinate_tolerance), |
| _coordinate_key(second, coordinate_tolerance), |
| ) |
| ) |
| ) |
| signature = ("linear", _value_key(value), endpoints) |
| detail = { |
| "family": "linear", |
| "normalised_display_value": BASE._round(value), |
| "geometry": { |
| "kind": "unordered_reference_endpoint_pair", |
| "endpoints": [ |
| [ |
| BASE._round(key[0] * coordinate_tolerance), |
| BASE._round(key[1] * coordinate_tolerance), |
| ] |
| for key in endpoints |
| ], |
| }, |
| "binding_max_distance": BASE._round(max(distances)), |
| } |
| return signature, detail |
|
|
|
|
| def _circular_primitives( |
| entities: Mapping[str, Any], |
| ) -> list[tuple[float, float, float]]: |
| result: list[tuple[float, float, float]] = [] |
| for family in ("circles", "arcs"): |
| for item in entities.get(family, []): |
| if ( |
| not isinstance(item, Sequence) |
| or isinstance(item, (str, bytes)) |
| or len(item) < 3 |
| ): |
| continue |
| cx, cy, radius = ( |
| _finite_number(item[0]), |
| _finite_number(item[1]), |
| _finite_number(item[2]), |
| ) |
| if cx is None or cy is None or radius is None or abs(radius) <= 1.0e-12: |
| continue |
| result.append((cx, cy, abs(radius))) |
| return result |
|
|
|
|
| def _circular_signature( |
| dimension: Mapping[str, Any], |
| entities: Mapping[str, Any], |
| *, |
| coordinate_tolerance: float, |
| binding_tolerance: float, |
| ) -> tuple[tuple[Any, ...], dict[str, Any]] | None: |
| refs = dimension.get("ref_points") |
| if not isinstance(refs, Mapping): |
| return None |
| defpoint = _finite_point(refs.get("defpoint")) |
| defpoint4 = _finite_point(refs.get("defpoint4")) |
| value = _normalised_display_value(dimension) |
| if defpoint is None or defpoint4 is None or value is None: |
| return None |
| distance = math.dist(defpoint, defpoint4) |
| if not math.isfinite(distance) or distance <= 1.0e-12: |
| return None |
| raw_family = str(dimension.get("family") or "").casefold() |
| if raw_family == "radius": |
| inferred_center = defpoint |
| inferred_radius = distance |
| elif raw_family == "diameter": |
| inferred_center = ( |
| 0.5 * (defpoint[0] + defpoint4[0]), |
| 0.5 * (defpoint[1] + defpoint4[1]), |
| ) |
| inferred_radius = 0.5 * distance |
| else: |
| return None |
|
|
| candidates: list[tuple[float, tuple[float, float, float], float, float]] = [] |
| for primitive in _circular_primitives(entities): |
| center_error = math.dist(inferred_center, primitive[:2]) |
| radius_error = abs(inferred_radius - primitive[2]) |
| if center_error <= binding_tolerance and radius_error <= binding_tolerance: |
| candidates.append( |
| (center_error + radius_error, primitive, center_error, radius_error) |
| ) |
| if not candidates: |
| return None |
| _, primitive, center_error, radius_error = min(candidates, key=lambda row: row[0]) |
| center_key = _coordinate_key(primitive[:2], coordinate_tolerance) |
| radius_key = int(round(primitive[2] / coordinate_tolerance)) |
| signature = ("circular", _value_key(value), center_key, radius_key) |
| detail = { |
| "family": "circular", |
| "normalised_display_value": BASE._round(value), |
| "geometry": { |
| "kind": "certified_circular_center_radius", |
| "center": [ |
| BASE._round(center_key[0] * coordinate_tolerance), |
| BASE._round(center_key[1] * coordinate_tolerance), |
| ], |
| "radius": BASE._round(radius_key * coordinate_tolerance), |
| }, |
| "binding_center_error": BASE._round(center_error), |
| "binding_radius_error": BASE._round(radius_error), |
| } |
| return signature, detail |
|
|
|
|
| def dimension_duplicate_diagnostics( |
| entities: Mapping[str, Any], |
| ) -> dict[str, Any]: |
| """Return binding-aware true-duplicate diagnostics for native dimensions.""" |
|
|
| dimensions = [ |
| item for item in entities.get("dims", []) if isinstance(item, Mapping) |
| ] |
| diagonal = _drawing_diagonal(entities) |
| coordinate_tolerance = max( |
| COORDINATE_QUANTISATION_ABS, |
| COORDINATE_QUANTISATION_FRACTION * diagonal, |
| ) |
| binding_tolerance = max( |
| COORDINATE_QUANTISATION_ABS, |
| GEOMETRY_BINDING_FRACTION * diagonal, |
| ) |
| groups: defaultdict[tuple[Any, ...], list[tuple[int, dict[str, Any]]]] = ( |
| defaultdict(list) |
| ) |
| unresolved: list[int] = [] |
| supported = 0 |
| for index, dimension in enumerate(dimensions): |
| family = _normalised_family(dimension.get("family")) |
| if family is None: |
| unresolved.append(index) |
| continue |
| supported += 1 |
| if family == "linear": |
| row = _linear_signature( |
| dimension, |
| entities, |
| coordinate_tolerance=coordinate_tolerance, |
| binding_tolerance=binding_tolerance, |
| ) |
| else: |
| row = _circular_signature( |
| dimension, |
| entities, |
| coordinate_tolerance=coordinate_tolerance, |
| binding_tolerance=binding_tolerance, |
| ) |
| if row is None: |
| unresolved.append(index) |
| continue |
| signature, detail = row |
| groups[signature].append((index, detail)) |
|
|
| duplicate_groups: list[dict[str, Any]] = [] |
| duplicate_count = 0 |
| for rows in groups.values(): |
| if len(rows) < 2: |
| continue |
| duplicate_count += len(rows) - 1 |
| detail = copy.deepcopy(rows[0][1]) |
| detail.update( |
| { |
| "dimension_indices": [int(index) for index, _ in rows], |
| "count": len(rows), |
| "duplicate_extras": len(rows) - 1, |
| } |
| ) |
| duplicate_groups.append(detail) |
| duplicate_groups.sort(key=lambda row: row["dimension_indices"]) |
| ratio = duplicate_count / max(len(dimensions), 1) |
| return { |
| "policy": "binding_aware_geometry_signature_v1", |
| "n_dimensions": len(dimensions), |
| "n_supported_family": supported, |
| "n_bound_signatures": sum(len(rows) for rows in groups.values()), |
| "unresolved_dimension_count": len(unresolved), |
| "unresolved_dimension_indices": unresolved, |
| "true_duplicate_dimension_count": duplicate_count, |
| "true_duplicate_dimension_ratio": BASE._round(ratio), |
| "duplicate_groups": duplicate_groups, |
| "drawing_diagonal": BASE._round(diagonal), |
| "coordinate_quantisation_tolerance": BASE._round( |
| coordinate_tolerance, 9 |
| ), |
| "geometry_binding_tolerance": BASE._round(binding_tolerance, 9), |
| "unresolved_is_never_duplicate_by_value_alone": True, |
| "dimension_line_or_label_placement_is_ignored": True, |
| } |
|
|
|
|
| def _number(value: Any, default: float = 0.0) -> float: |
| number = _finite_number(value) |
| return number if number is not None else default |
|
|
|
|
| def _update_anti_hack( |
| anti_hack: Mapping[str, Any], diagnostics: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| result = copy.deepcopy(dict(anti_hack)) |
| old_count = _number(result.get("true_duplicate_dimension_count")) |
| old_ratio = _number(result.get("true_duplicate_dimension_ratio")) |
| true_count = int(diagnostics["true_duplicate_dimension_count"]) |
| true_ratio = float(diagnostics["true_duplicate_dimension_ratio"]) |
| unmatched_count = _number(result.get("unmatched_dimension_count")) |
| unmatched_ratio = _number(result.get("unmatched_dimension_ratio")) |
| spam_count = max(float(true_count), unmatched_count) |
| spam_ratio = max(true_ratio, unmatched_ratio) |
|
|
| result.update( |
| { |
| "same_semantic_value_repeat_count": old_count, |
| "same_semantic_value_repeat_ratio": BASE._round(old_ratio), |
| "same_semantic_value_repeat_scope": "scale_consistency_vote_balancing_only", |
| "true_duplicate_dimension_count": true_count, |
| "true_duplicate_dimension_ratio": BASE._round(true_ratio), |
| "dimension_spam_count": spam_count, |
| "dimension_spam_ratio": BASE._round(spam_ratio), |
| |
| |
| "duplicate_dimension_count": spam_count, |
| "duplicate_dimension_ratio": BASE._round(spam_ratio), |
| "true_duplicate_dimension_policy": diagnostics["policy"], |
| "true_duplicate_dimension_diagnostics": copy.deepcopy( |
| dict(diagnostics) |
| ), |
| } |
| ) |
| flags = [ |
| str(flag) |
| for flag in result.get("flags", []) |
| if str(flag) != "true_duplicate_dimension_spam" |
| ] |
| if true_ratio >= TRUE_DUPLICATE_GATE_RATIO: |
| flags.append("true_duplicate_dimension_spam") |
| result["flags"] = list(dict.fromkeys(flags)) |
| return result |
|
|
|
|
| def _corrected_structure( |
| original: Mapping[str, Any], |
| anti_hack: Mapping[str, Any], |
| diagnostics: Mapping[str, Any], |
| ) -> dict[str, Any]: |
| if not original.get("eligible") or not isinstance(original.get("details"), Mapping): |
| return copy.deepcopy(dict(original)) |
| details = copy.deepcopy(dict(original["details"])) |
| readable = bool(details.get("readable")) |
| nondegenerate = bool(details.get("nondegenerate")) |
| accounting_ok = bool(details.get("all_extra_clusters_accounted_for")) |
| unsupported = int(_number(details.get("unsupported_geometry_like"))) |
| predicted_inventory = int(_number(details.get("predicted_annotation_inventory"))) |
| severe_limit = int(_number(details.get("severe_annotation_spam_limit"))) |
| severe_spam = predicted_inventory > severe_limit |
| duplicate_ratio = _number(anti_hack.get("true_duplicate_dimension_ratio")) |
| valid = bool( |
| readable |
| and nondegenerate |
| and accounting_ok |
| and unsupported == 0 |
| and duplicate_ratio < TRUE_DUPLICATE_GATE_RATIO |
| and not severe_spam |
| ) |
| flags = [ |
| name |
| for name, active in ( |
| ("unreadable_or_degenerate", not (readable and nondegenerate)), |
| ("extra_cluster_accounting_incomplete", not accounting_ok), |
| ("unsupported_geometry_like", unsupported > 0), |
| ( |
| "true_duplicate_dimension_spam", |
| duplicate_ratio >= TRUE_DUPLICATE_GATE_RATIO, |
| ), |
| ("severe_dimension_or_text_spam", severe_spam), |
| ) |
| if active |
| ] |
| details.update( |
| { |
| "flags": flags, |
| "true_duplicate_dimension_count": int( |
| diagnostics["true_duplicate_dimension_count"] |
| ), |
| "true_duplicate_dimension_ratio": BASE._round(duplicate_ratio), |
| "true_duplicate_dimension_policy": diagnostics["policy"], |
| "same_semantic_value_repeat_count": anti_hack.get( |
| "same_semantic_value_repeat_count" |
| ), |
| "same_semantic_value_repeat_ratio": anti_hack.get( |
| "same_semantic_value_repeat_ratio" |
| ), |
| "semantic_value_groups_are_scale_only": True, |
| "unresolved_dimensions_are_fail_open_for_duplicate_identity": True, |
| } |
| ) |
| return BASE._component( |
| 1.0 if valid else 0.0, |
| True, |
| "ok" if valid else "independent_validity_or_anti_hack_gate_failed", |
| **details, |
| ) |
|
|
|
|
| def _rescore_downstream(result: dict[str, Any]) -> None: |
| components = result.get("components") |
| prompt = result.get("online_reward_prompt_masked") |
| prompt_components = prompt.get("components") if isinstance(prompt, Mapping) else None |
| if not isinstance(components, dict) or not isinstance(prompt_components, dict): |
| return |
| atomic = result.get("diagnostics", {}).get("atomic_geometry", {}) |
| if not isinstance(atomic, Mapping): |
| atomic = {} |
| result["verified_reward_full_gt"] = RC3._scoped_hierarchical_reward( |
| components, |
| atomic, |
| scope="offline_full_gt_executed_dxf", |
| ) |
| prompt_reward = RC3._scoped_hierarchical_reward( |
| prompt_components, |
| atomic, |
| scope="prompt_masked_actual_geometry", |
| ) |
| result["online_reward_prompt_masked"] = { |
| **prompt_reward, |
| "components": prompt_components, |
| } |
| result["benchmark"] = RC3._benchmark(components) |
| result["engineering_success"] = result["benchmark"]["engineering_success"] |
|
|
|
|
| def score_dxf_pair( |
| pred: str | Path, |
| gt: str | Path, |
| sidecar: Mapping[str, Any] | None = None, |
| category: str | None = None, |
| **kwargs: Any, |
| ) -> dict[str, Any]: |
| result = RC5G_FINAL.score_dxf_pair( |
| pred, |
| gt, |
| sidecar=sidecar, |
| category=category, |
| **kwargs, |
| ) |
| result["schema_version"] = SCHEMA_VERSION |
| result["metric_version"] = METRIC_VERSION |
| result.setdefault("metric_definition", {})[ |
| "true_duplicate_dimension_policy" |
| ] = { |
| "identity": "normalised_family_value_plus_bound_geometry_signature", |
| "linear_aligned_geometry": "unordered_quantised_defpoint2_defpoint3", |
| "diameter_radius_geometry": "certified_quantised_circle_center_radius", |
| "radius_value_is_converted_to_diameter_equivalent": True, |
| "ev43_semantic_value_groups": "scale_consistency_only", |
| "unresolved_binding_policy": "never_true_duplicate_by_value_alone", |
| "structure_gate_ratio": TRUE_DUPLICATE_GATE_RATIO, |
| "continuous_component_definitions_changed": False, |
| } |
|
|
| try: |
| raw_pred = BASE.EV5._extract_entities(Path(pred)) |
| except Exception as exc: |
| result.setdefault("diagnostics", {})["rc5h_dimension_identity"] = { |
| "applied": False, |
| "reason": "prediction_dimension_extraction_failed", |
| "exception_type": type(exc).__name__, |
| } |
| release = result.get("diagnostics", {}).get("release_status") |
| if isinstance(release, dict): |
| release["candidate"] = METRIC_VERSION |
| return result |
|
|
| diagnostics = dimension_duplicate_diagnostics(raw_pred) |
| result.setdefault("diagnostics", {})["rc5h_dimension_identity"] = { |
| "applied": True, |
| **copy.deepcopy(diagnostics), |
| } |
| anti_hack = _update_anti_hack(result.get("anti_hack", {}), diagnostics) |
| result["anti_hack"] = anti_hack |
|
|
| components = result.get("components") |
| if isinstance(components, dict) and isinstance(components.get("structure"), Mapping): |
| corrected = _corrected_structure( |
| components["structure"], anti_hack, diagnostics |
| ) |
| components["structure"] = corrected |
| prompt = result.get("online_reward_prompt_masked") |
| if isinstance(prompt, dict) and isinstance(prompt.get("components"), dict): |
| prompt["components"]["structure"] = copy.deepcopy(corrected) |
| _rescore_downstream(result) |
|
|
| release = result.get("diagnostics", {}).get("release_status") |
| if isinstance(release, dict): |
| release["candidate"] = METRIC_VERSION |
| return result |
|
|
|
|
| __all__ = [ |
| "COORDINATE_QUANTISATION_FRACTION", |
| "ENGINEERING_THRESHOLDS", |
| "MAX_MATCHED_OFFSET_DISPERSION_FRACTION", |
| "METRIC_VERSION", |
| "PHYSICAL_SUPPORTED_SEMANTICS", |
| "SCHEMA_VERSION", |
| "TRUE_DUPLICATE_GATE_RATIO", |
| "dimension_duplicate_diagnostics", |
| "score_dxf_pair", |
| ] |
|
|
