File size: 6,025 Bytes
15d1f1d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
164
165
166
167
168
169
170
171
172
#!/usr/bin/env python3
"""Release candidate: fragment-safe views and hidden-only Curve bounds.

This add-only final supersedes ``eval_geometric052_rc5j``.  The host cannot
update an existing file, so the conservative visible-first Curve contract is
published under an explicit final entry point.

Two scoped repairs are stacked on RC5I:

* uniquely contained disconnected prediction fragments may be reassociated
  with one transformed semantic reference box; outside or ambiguous fragments
  remain explicit extras;
* Curve-CD/F1 retains its legacy visible-only bounds bit-for-bit whenever
  those bounds exist.  Only a hidden-only target/prediction falls back to
  analytic bounds of the non-degenerate LINE/CIRCLE/ARC primitives that Curve
  actually samples.

There is no path/hash identity shortcut and no change to global alignment,
sampling density, Curve thresholds, or downstream reward formulae.
"""

from __future__ import annotations

import math
import threading
from pathlib import Path
from typing import Any, Mapping, Sequence

import numpy as np

try:
    from . import eval_geometric052_rc5i as RC5I
    from . import view_entity_matching_v52_rc5j_fragment_candidate as MATCH
except ImportError:  # direct evaluator import
    import eval_geometric052_rc5i as RC5I
    import view_entity_matching_v52_rc5j_fragment_candidate as MATCH


METRIC_VERSION = "v5.2-rc5j-final"
SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc5j-final"
ENGINEERING_THRESHOLDS = dict(RC5I.ENGINEERING_THRESHOLDS)
PHYSICAL_SUPPORTED_SEMANTICS = RC5I.PHYSICAL_SUPPORTED_SEMANTICS
MAX_MATCHED_OFFSET_DISPERSION_FRACTION = (
    RC5I.MAX_MATCHED_OFFSET_DISPERSION_FRACTION
)

RC3 = RC5I.RC3
BASE = RC5I.BASE
CURVE = BASE.CURVE
_PATCH_LOCK = threading.RLock()


def _hidden_fallback_entity_bounds(
    entities: Mapping[str, Any],
) -> tuple[np.ndarray, np.ndarray] | None:
    """Return legacy visible bounds, else sampled all-channel analytic bounds."""

    visible_bounds = BASE.EV5._safe_bbox(entities)
    if visible_bounds is not None:
        return visible_bounds

    records = BASE.EV5._primitive_records(entities)
    sampled: list[Mapping[str, Any]] = []
    for record in records:
        family = str(record.get("family") or "")
        primitive = record.get("primitive")
        if not isinstance(primitive, Sequence) or isinstance(primitive, (str, bytes)):
            continue
        try:
            if family == "lines":
                length = math.hypot(
                    float(primitive[2]) - float(primitive[0]),
                    float(primitive[3]) - float(primitive[1]),
                )
            elif family == "circles":
                length = 2.0 * math.pi * abs(float(primitive[2]))
            elif family == "arcs":
                radius = abs(float(primitive[2]))
                sweep_degrees = (
                    float(primitive[4]) - float(primitive[3])
                ) % 360.0
                if sweep_degrees <= 1.0e-12:
                    sweep_degrees = 360.0
                length = radius * math.radians(sweep_degrees)
            else:
                continue
        except (IndexError, TypeError, ValueError):
            continue
        if math.isfinite(length) and length > 1.0e-12:
            sampled.append(record)
    if not sampled:
        return None
    lows = np.stack(
        [np.asarray(record["low"], dtype=float) for record in sampled]
    )
    highs = np.stack(
        [np.asarray(record["high"], dtype=float) for record in sampled]
    )
    if not np.isfinite(lows).all() or not np.isfinite(highs).all():
        return None
    return np.min(lows, axis=0), np.max(highs, axis=0)


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]:
    with _PATCH_LOCK:
        original_match = RC3.MATCH
        original_curve_bounds = CURVE._entity_bounds
        RC3.MATCH = MATCH
        CURVE._entity_bounds = _hidden_fallback_entity_bounds
        try:
            result = RC5I.score_dxf_pair(
                pred,
                gt,
                sidecar=sidecar,
                category=category,
                **kwargs,
            )
        finally:
            CURVE._entity_bounds = original_curve_bounds
            RC3.MATCH = original_match

    result["schema_version"] = SCHEMA_VERSION
    result["metric_version"] = METRIC_VERSION
    result.setdefault("metric_definition", {}).update(
        {
            "fragment_reassociation_policy": {
                "partition": (
                    "unique_complete_bbox_containment_after_coarse_shared_transform"
                ),
                "outside_or_ambiguous_fragments": "retained_as_explicit_extras",
                "activation": "strict_shape_layout_objective_improvement",
                "path_or_hash_identity_used": False,
            },
            "curve_bounds_policy": {
                "families": ["LINE", "CIRCLE", "ARC"],
                "visibility": "legacy_visible_first_hidden_only_fallback",
                "bounds": (
                    "legacy_visible_bounds_else_analytic_extrema_of_all_"
                    "nonzero_arc_length_primitives"
                ),
                "global_alignment_changed": False,
                "curve_sampling_or_thresholds_changed": False,
            },
        }
    )
    result.setdefault("diagnostics", {})["rc5j_repairs"] = {
        "fragment_context_builder": MATCH.SCHEMA_VERSION,
        "curve_bounds_hidden_fallback_only": True,
        "path_or_hash_identity_used": False,
    }
    release = result.get("diagnostics", {}).get("release_status")
    if isinstance(release, dict):
        release["candidate"] = METRIC_VERSION
    return result


__all__ = [
    "ENGINEERING_THRESHOLDS",
    "MAX_MATCHED_OFFSET_DISPERSION_FRACTION",
    "METRIC_VERSION",
    "PHYSICAL_SUPPORTED_SEMANTICS",
    "SCHEMA_VERSION",
    "_hidden_fallback_entity_bounds",
    "score_dxf_pair",
]