| |
| |
| """ |
| eval_geometric02.py -- v2 evaluation for the EDP "image -> ezdxf code" task. |
| |
| WHY v2 (vs eval_geometric.py): |
| The old metric named its levels L0/L1/L2/L3, which COLLIDES with the dataset |
| difficulty tiers (labels.csv `tier` = L1/L2/L3). v2 reorganises the metric |
| strictly around the THREE conceptual axes the task actually cares about, with |
| names that can never be confused with dataset difficulty: |
| |
| U Usability (生成可用性) : can the prediction be turned into a drawing at all? |
| format -> compile -> run -> dxf_readable -> non-degenerate |
| G Geometry (几何正确性) : are the shapes right? |
| HIT-RATIO side : lines / hidden (F1@tau) + circles / arcs (matched F1) |
| ACCURACY side : nearest-neighbour dist (mm) for lines/hidden, |
| center dist (mm) + radius MAPE for circles/arcs |
| A Annotation (标注正确性) : are the dimensions right? |
| value match (unit-normalised + tolerance, radius<->diameter |
| equivalence) + placement |
| |
| KEY FIXES over v1 (carried in from the metric review): |
| * ONE shared Procrustes alignment (translate+scale, no rotation) reused by every |
| geometry / annotation sub-metric -> cross-metric comparability. |
| * Line geometry headline is F1@tau (tau normalised by part size), NOT raw Chamfer |
| with exp(-d/1mm) which saturated to ~0 and killed all signal. |
| * Dimension text is unit-normalised (strip %%c / %%C / Ø / R / spaces) and matched |
| by RELATIVE tolerance, not exact string equality; radius<->diameter equivalence. |
| * Usability adds a non-degenerate check (entities>0 & sane bbox) so an "empty but |
| runnable" drawing cannot score as usable. (matters a lot for RL reward hacking) |
| * Every prediction gets ONE end-to-end scalar `overall` in [0,1] via a gated |
| formula (usable -> then geometry & annotation), suitable to reuse as an RL reward. |
| |
| Usage: |
| python eval_geometric02.py \ |
| --pred /root/autodl-tmp/EDP_code/eval/sft_pred_test_full.jsonl \ |
| --gt-dir /root/autodl-tmp/EDP_code/code_datasets/gt_dxf_test \ |
| --pred-dxf-dir /root/autodl-tmp/EDP_code/eval/pred_dxf_full \ |
| --out /root/autodl-tmp/EDP_code/eval/scores_v2_full.jsonl \ |
| --summary /root/autodl-tmp/EDP_code/eval/summary_v2_full.json |
| """ |
| import os, re, sys, json, argparse, subprocess, tempfile |
| from collections import Counter, defaultdict |
| import numpy as np |
| import ezdxf |
| from scipy.spatial.distance import cdist |
| from scipy.optimize import linear_sum_assignment |
|
|
| CODE_PAT = re.compile(r"```python\s*\n(.*?)```", re.DOTALL) |
|
|
| |
| |
| TAU_FRACS = (0.005, 0.01, 0.02) |
| TAU_HEADLINE_IDX = 1 |
|
|
| |
| DIM_ABS_TOL = 0.5 |
| DIM_REL_TOL = 0.01 |
|
|
| |
| |
| |
| |
| |
| EPS_CENTER_FRAC = 0.03 |
| CIRCLE_RTOL = 0.02 |
| ARC_RTOL = 0.03 |
| ARC_ANGLE_IOU_MIN = 0.50 |
| ARC_DEGENERATE_ANGLE_TOL_DEG = 0.01 |
|
|
| |
| W_GEOM = 0.5 |
| W_ANNO = 0.5 |
| USABLE_BASE = 0.3 |
|
|
| |
| |
| |
| |
| |
| |
| |
| GATE_FLOOR = 0.25 |
|
|
|
|
| |
| |
| |
|
|
| def extract_code(text): |
| m = CODE_PAT.search(text or "") |
| return m.group(1) if m else (text or "").strip() |
|
|
|
|
| def compile_ok(code): |
| try: |
| compile(code, "<pred>", "exec"); return True |
| except SyntaxError: |
| return False |
|
|
|
|
| def run_code_to_dxf(code, out_path, timeout=30): |
| """Run prediction code as subprocess -> DXF. Returns (ok, err_msg).""" |
| fd, py = tempfile.mkstemp(suffix=".py", prefix="pred02_") |
| os.close(fd) |
| try: |
| with open(py, "w", encoding="utf-8") as f: |
| f.write(code) |
| p = subprocess.run([sys.executable, py, out_path], |
| capture_output=True, text=True, timeout=timeout) |
| if p.returncode != 0: |
| err = (p.stderr or p.stdout or "").strip().splitlines() |
| return False, err[-1] if err else "non-zero exit" |
| if not os.path.exists(out_path): |
| return False, "ran but no DXF produced" |
| return True, None |
| except subprocess.TimeoutExpired: |
| return False, f"timeout >{timeout}s" |
| except Exception as e: |
| return False, f"{type(e).__name__}: {e}" |
| finally: |
| if os.path.exists(py): |
| os.remove(py) |
|
|
|
|
| def extract_entities(dxf_path): |
| """Read a DXF -> structured entity lists (or None if unreadable). |
| lines: (x1,y1,x2,y2, layer) |
| circles: (cx,cy,r, layer) |
| arcs: (cx,cy,r,a1,a2, layer) |
| dims: (dimtype_int, text, layer, defpoint_x, defpoint_y, bind_x, bind_y) |
| """ |
| try: |
| doc = ezdxf.readfile(dxf_path) |
| except Exception: |
| return None |
| msp = doc.modelspace() |
| lines, circles, arcs, dims = [], [], [], [] |
| for e in msp: |
| et = e.dxftype() |
| layer = e.dxf.layer if e.dxf.hasattr("layer") else "0" |
| if et == "LINE": |
| lines.append((e.dxf.start.x, e.dxf.start.y, |
| e.dxf.end.x, e.dxf.end.y, layer)) |
| elif et == "CIRCLE": |
| circles.append((e.dxf.center.x, e.dxf.center.y, e.dxf.radius, layer)) |
| elif et == "ARC": |
| arcs.append((e.dxf.center.x, e.dxf.center.y, e.dxf.radius, |
| e.dxf.start_angle, e.dxf.end_angle, layer)) |
| elif et == "DIMENSION": |
| dt = e.dxf.dimtype if e.dxf.hasattr("dimtype") else 0 |
| txt = e.dxf.text if e.dxf.hasattr("text") else "" |
| dpx = e.dxf.defpoint.x if e.dxf.hasattr("defpoint") else 0.0 |
| dpy = e.dxf.defpoint.y if e.dxf.hasattr("defpoint") else 0.0 |
| dt_base = dt & 0x0F |
| if dt_base in (0, 1) and e.dxf.hasattr("defpoint2") and e.dxf.hasattr("defpoint3"): |
| bpx = (e.dxf.defpoint2.x + e.dxf.defpoint3.x) / 2 |
| bpy = (e.dxf.defpoint2.y + e.dxf.defpoint3.y) / 2 |
| elif dt_base in (3, 4) and e.dxf.hasattr("defpoint4"): |
| bpx, bpy = e.dxf.defpoint4.x, e.dxf.defpoint4.y |
| else: |
| bpx, bpy = dpx, dpy |
| dims.append((dt, txt, layer, dpx, dpy, bpx, bpy)) |
| return {"lines": lines, "circles": circles, "arcs": arcs, "dims": dims} |
|
|
|
|
| def dim_type_name(dt): |
| base = dt & 0x0F |
| return {0: "linear", 1: "aligned", 2: "angular", 3: "diameter", |
| 4: "radius", 5: "angular3", 6: "ordinate"}.get(base, f"type{base}") |
|
|
|
|
| def parse_dim_value(text): |
| """Unit-normalise a dimension label -> (family, float_value|None, raw). |
| Strips AutoCAD control tokens (%%c, %%C, %%d), Ø, R, diameter/radius glyphs, |
| whitespace; returns family in {'diameter','radius','linear'} inferred from |
| the prefix, and the numeric value if parseable.""" |
| raw = text or "" |
| s = raw.strip().replace(" ", "") |
| family = "linear" |
| low = s.lower() |
| if low.startswith("%%c") or s.startswith("\u00d8") or s.startswith("\u2205"): |
| family = "diameter" |
| elif low.startswith("r") and not low.startswith("r0e"): |
| family = "radius" |
| |
| cleaned = re.sub(r"%%[a-zA-Z]", "", s) |
| cleaned = cleaned.replace("\u00d8", "").replace("\u2205", "") |
| cleaned = re.sub(r"^[Rr]", "", cleaned) |
| m = re.search(r"[-+]?\d*\.?\d+", cleaned) |
| val = float(m.group(0)) if m else None |
| return family, val, raw |
|
|
|
|
| def _ccw_span(start_deg, end_deg): |
| """Counter-clockwise DXF arc span in degrees, normalised to [0, 360).""" |
| return float((end_deg - start_deg) % 360.0) |
|
|
|
|
| def _angle_distance(first_deg, second_deg): |
| """Smallest absolute distance between two directions in degrees.""" |
| return abs(float((first_deg - second_deg + 180.0) % 360.0 - 180.0)) |
|
|
|
|
| def _arc_angle_quality(a1p, a2p, a1g, a2g): |
| """Circular interval IoU, with tolerance for quantised near-zero arcs.""" |
| span_p = _ccw_span(a1p, a2p) |
| span_g = _ccw_span(a1g, a2g) |
| if max(span_p, span_g) <= ARC_DEGENERATE_ANGLE_TOL_DEG: |
| return float( |
| _angle_distance(a1p, a1g) <= ARC_DEGENERATE_ANGLE_TOL_DEG |
| ) |
| if min(span_p, span_g) <= ARC_DEGENERATE_ANGLE_TOL_DEG: |
| return 0.0 |
|
|
| start_p = float(a1p % 360.0) |
| end_p = start_p + span_p |
| start_g = float(a1g % 360.0) |
| overlap = 0.0 |
| for shift in (-360.0, 0.0, 360.0): |
| shifted_start = start_g + shift |
| shifted_end = shifted_start + span_g |
| overlap = max( |
| overlap, |
| max(0.0, min(end_p, shifted_end) - max(start_p, shifted_start)), |
| ) |
| union = span_p + span_g - overlap |
| return float(overlap / union) if union > 1e-12 else 0.0 |
|
|
|
|
| def _arc_geometry_points(cx, cy, radius, start_deg, end_deg, *, midpoint=False): |
| """Points that bound the visible DXF arc rather than its full support circle.""" |
| start = float(start_deg % 360.0) |
| span = _ccw_span(start_deg, end_deg) |
| angles = [start, start + span] |
| for cardinal in (0.0, 90.0, 180.0, 270.0): |
| relative = (cardinal - start) % 360.0 |
| if relative <= span + 1e-9: |
| angles.append(start + relative) |
| if midpoint and span > 1e-12: |
| angles.append(start + span / 2.0) |
| return [ |
| ( |
| cx + radius * np.cos(np.deg2rad(angle)), |
| cy + radius * np.sin(np.deg2rad(angle)), |
| ) |
| for angle in angles |
| ] |
|
|
|
|
| def bbox_diagonal(ent): |
| """Diagonal length of the visible-geometry bounding box (mm). 0 if empty.""" |
| xs, ys = [], [] |
| for x1, y1, x2, y2, layer in ent["lines"]: |
| xs += [x1, x2]; ys += [y1, y2] |
| for cx, cy, r, layer in ent["circles"]: |
| xs += [cx - r, cx + r]; ys += [cy - r, cy + r] |
| for cx, cy, r, a1, a2, layer in ent["arcs"]: |
| for x, y in _arc_geometry_points(cx, cy, r, a1, a2): |
| xs.append(x); ys.append(y) |
| if not xs: |
| return 0.0 |
| return float(np.hypot(max(xs) - min(xs), max(ys) - min(ys))) |
|
|
|
|
| |
| |
| |
|
|
| def n_entities(ent): |
| if ent is None: |
| return 0 |
| return len(ent["lines"]) + len(ent["circles"]) + len(ent["arcs"]) + len(ent["dims"]) |
|
|
|
|
| def score_usability(pred_code, pred_dxf_path, ent_pred): |
| """生成可用性. Gated ladder + non-degenerate check. |
| Returns dict with binary sub-flags AND a continuous `score` in [0,1] so RL |
| gets a smooth ramp instead of a 0/1 cliff. |
| """ |
| has_code = bool(pred_code and pred_code.strip()) |
| compiles = compile_ok(pred_code) if has_code else False |
| runs = os.path.isfile(pred_dxf_path) and ent_pred is not None |
| readable = ent_pred is not None |
| |
| ne = n_entities(ent_pred) |
| diag = bbox_diagonal(ent_pred) if ent_pred is not None else 0.0 |
| non_degenerate = readable and ne >= 3 and 1.0 <= diag <= 1e5 |
|
|
| if not has_code: |
| score = 0.0 |
| elif not compiles: |
| score = 0.1 |
| elif not runs or not readable: |
| score = 0.2 |
| elif not non_degenerate: |
| score = 0.25 |
| else: |
| score = 1.0 |
| return { |
| "format_ok": has_code, |
| "compile_ok": compiles, |
| "run_ok": runs, |
| "dxf_readable": readable, |
| "non_degenerate": non_degenerate, |
| "n_entities": ne, |
| "bbox_diag": round(diag, 3), |
| "all_ok": bool(has_code and compiles and runs and readable and non_degenerate), |
| "score": score, |
| } |
|
|
|
|
| |
| |
| |
|
|
| def _procrustes_ts(src, dst): |
| """Align src to dst with translation + isotropic scale (NO rotation) via |
| 2-iteration nearest-neighbour ICP. Returns (src_centroid, dst_centroid, scale) |
| so the SAME transform can be reapplied to any other point set: |
| aligned = scale * (pts - src_centroid) + dst_centroid |
| """ |
| if len(src) == 0 or len(dst) == 0: |
| return np.zeros(2), np.zeros(2), 1.0 |
| cur = src.copy() |
| s_total, src_c0 = 1.0, src.mean(axis=0) |
| dst_c_final = src.mean(axis=0) |
| for _ in range(2): |
| D = cdist(cur, dst) |
| matched = dst[D.argmin(axis=1)] |
| c_src = cur.mean(axis=0) |
| c_dst = matched.mean(axis=0) |
| sc = cur - c_src |
| dc = matched - c_dst |
| sn = np.sqrt((sc ** 2).sum()) |
| dn = np.sqrt((dc ** 2).sum()) |
| s = dn / sn if sn > 1e-9 else 1.0 |
| cur = s * sc + c_dst |
| s_total *= s |
| dst_c_final = c_dst |
| |
| |
| return src_c0, dst_c_final, float(s_total) |
|
|
|
|
| def transform_points(pts, src_c, dst_c, scale): |
| if len(pts) == 0: |
| return pts |
| return scale * (pts - src_c) + dst_c |
|
|
|
|
| def collect_alignment_points(ent): |
| """Visible reference points, using drawn arc points instead of remote centres.""" |
| pts = set() |
| for x1, y1, x2, y2, layer in ent["lines"]: |
| if "hidden" not in layer.lower(): |
| pts.add((round(x1, 2), round(y1, 2))) |
| pts.add((round(x2, 2), round(y2, 2))) |
| for cx, cy, r, layer in ent["circles"]: |
| if "hidden" not in layer.lower(): |
| pts.add((round(cx, 2), round(cy, 2))) |
| for cx, cy, r, a1, a2, layer in ent["arcs"]: |
| if "hidden" not in layer.lower(): |
| for x, y in _arc_geometry_points(cx, cy, r, a1, a2, midpoint=True): |
| pts.add((round(x, 2), round(y, 2))) |
| return np.array(sorted(pts)) if pts else np.empty((0, 2)) |
|
|
|
|
| def shared_alignment(ent_pred, ent_gt): |
| """ONE Procrustes transform (translate+scale) from ALL visible pred geometry |
| to ALL visible GT geometry. Reused by every G/A sub-metric for comparability. |
| Returns (src_c, dst_c, scale).""" |
| src = collect_alignment_points(ent_pred) |
| dst = collect_alignment_points(ent_gt) |
| return _procrustes_ts(src, dst) |
|
|
|
|
| |
| |
| |
|
|
| def line_vertices(lines): |
| pts = set() |
| for x1, y1, x2, y2, layer in lines: |
| pts.add((round(x1, 2), round(y1, 2))) |
| pts.add((round(x2, 2), round(y2, 2))) |
| return np.array(sorted(pts)) if pts else np.empty((0, 2)) |
|
|
|
|
| def f1_at_tau(src_pts, dst_pts, tau): |
| """Bidirectional point F1 at radius tau (mm). |
| precision = frac of pred pts with a GT pt within tau |
| recall = frac of GT pts with a pred pt within tau |
| Both empty -> 1.0 ; one empty -> 0.0.""" |
| if len(src_pts) == 0 and len(dst_pts) == 0: |
| return 1.0, 1.0, 1.0 |
| if len(src_pts) == 0 or len(dst_pts) == 0: |
| return 0.0, 0.0, 0.0 |
| D = cdist(src_pts, dst_pts) |
| prec = float((D.min(axis=1) <= tau).mean()) |
| rec = float((D.min(axis=0) <= tau).mean()) |
| f1 = 2 * prec * rec / (prec + rec) if (prec + rec) > 0 else 0.0 |
| return prec, rec, f1 |
|
|
|
|
| def chamfer_stats(src_pts, dst_pts): |
| """Symmetric nearest-neighbour distance stats (mm) between two point sets. |
| Reports the PRECISION side of the metric (mm accuracy) that F1@tau cannot: |
| how far off the matched geometry actually is, not just the hit ratio. |
| Returns (mean, median, p90) of the symmetric nearest-neighbour distances.""" |
| if len(src_pts) == 0 or len(dst_pts) == 0: |
| return None, None, None |
| D = cdist(src_pts, dst_pts) |
| d = np.concatenate([D.min(axis=1), D.min(axis=0)]) |
| return (round(float(d.mean()), 4), round(float(np.median(d)), 4), |
| round(float(np.percentile(d, 90)), 4)) |
|
|
|
|
| def _line_f1_block(pred_lines, gt_lines, src_c, dst_c, scale, gt_diag): |
| """Align pred line vertices with the SHARED transform, then F1@tau ladder.""" |
| pv = line_vertices(pred_lines) |
| gv = line_vertices(gt_lines) |
| if len(pv) == 0 and len(gv) == 0: |
| return {"present": False, "f1": 1.0, "n_pred": 0, "n_gt": 0, |
| "f1_at": {}, "headline_tau_mm": None, |
| "nn_dist_mean_mm": None, "nn_dist_median_mm": None, |
| "nn_dist_p90_mm": None} |
| pva = transform_points(pv, src_c, dst_c, scale) if len(pv) else pv |
| diag = gt_diag if gt_diag > 1e-6 else 1.0 |
| f1_at = {} |
| for frac in TAU_FRACS: |
| tau = frac * diag |
| _, _, f1 = f1_at_tau(pva, gv, tau) |
| f1_at[f"{frac:.3f}"] = round(f1, 4) |
| headline_frac = TAU_FRACS[TAU_HEADLINE_IDX] |
| nn_mean, nn_median, nn_p90 = chamfer_stats(pva, gv) |
| return { |
| "present": True, |
| "f1": f1_at[f"{headline_frac:.3f}"], |
| "f1_at": f1_at, |
| "headline_tau_mm": round(headline_frac * diag, 4), |
| |
| "nn_dist_mean_mm": nn_mean, |
| "nn_dist_median_mm": nn_median, |
| "nn_dist_p90_mm": nn_p90, |
| "n_pred": int(len(pv)), "n_gt": int(len(gv)), |
| } |
|
|
|
|
| def score_geometry(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag): |
| """几何正确性: visible lines + hidden lines (F1@tau) and circles + arcs (matched F1). |
| Returns per-family dicts + a single `score` in [0,1] (mean of present families).""" |
| vis_p = [l for l in ent_pred["lines"] if "hidden" not in l[-1].lower()] |
| vis_g = [l for l in ent_gt["lines"] if "hidden" not in l[-1].lower()] |
| hid_p = [l for l in ent_pred["lines"] if "hidden" in l[-1].lower()] |
| hid_g = [l for l in ent_gt["lines"] if "hidden" in l[-1].lower()] |
|
|
| lines = _line_f1_block(vis_p, vis_g, src_c, dst_c, scale, gt_diag) |
| hidden = _line_f1_block(hid_p, hid_g, src_c, dst_c, scale, gt_diag) |
| circles = _match_circles(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag) |
| arcs = _match_arcs(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag) |
|
|
| |
| parts = [] |
| parts.append(("lines", lines["f1"], 1.0)) |
| if hidden["present"] or hid_g or hid_p: |
| parts.append(("hidden", hidden["f1"], 0.5)) |
| if circles["n_gt"] or circles["n_pred"]: |
| parts.append(("circles", circles["match_f1"], 1.0)) |
| if arcs["n_gt"] or arcs["n_pred"]: |
| parts.append(("arcs", arcs["match_f1"], 1.0)) |
| wsum = sum(w for _, _, w in parts) |
| score = sum(v * w for _, v, w in parts) / wsum if wsum > 0 else 0.0 |
| return {"lines": lines, "hidden": hidden, "circles": circles, "arcs": arcs, |
| "score": round(score, 4)} |
|
|
|
|
| def _match_circles(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag): |
| """Hungarian match on aligned centers; matched if center<=eps AND radius rel err<=rtol. |
| eps is size-normalised: EPS_CENTER_FRAC * gt_diag (min 0.5mm floor).""" |
| eps = max(0.5, EPS_CENTER_FRAC * gt_diag) |
| rtol = CIRCLE_RTOL |
| pc = [(cx, cy, r) for cx, cy, r, layer in ent_pred["circles"] if "hidden" not in layer.lower()] |
| gc = [(cx, cy, r) for cx, cy, r, layer in ent_gt["circles"] if "hidden" not in layer.lower()] |
| n_p, n_g = len(pc), len(gc) |
| if n_p == 0 and n_g == 0: |
| return {"match_f1": 1.0, "matched": 0, "n_pred": 0, "n_gt": 0, |
| "radius_mape": 0.0, "center_dist_mean_mm": None} |
| if n_p == 0 or n_g == 0: |
| return {"match_f1": 0.0, "matched": 0, "n_pred": n_p, "n_gt": n_g, |
| "radius_mape": 0.0, "center_dist_mean_mm": None} |
| pcen = transform_points(np.array([(x, y) for x, y, r in pc]), src_c, dst_c, scale) |
| pradii = [abs(scale) * radius for _, _, radius in pc] |
| cost = np.full((n_p, n_g), 1e6) |
| cd = np.zeros((n_p, n_g)) |
| for i in range(n_p): |
| for j in range(n_g): |
| d = np.hypot(pcen[i][0] - gc[j][0], pcen[i][1] - gc[j][1]) |
| cd[i][j] = d |
| rr = abs(pradii[i] - gc[j][2]) / gc[j][2] if gc[j][2] > 1e-9 else 1e6 |
| cost[i][j] = d + 100.0 * rr |
| ri, ci = linear_sum_assignment(cost) |
| matched, rerrs, cdists = 0, [], [] |
| for a, b in zip(ri, ci): |
| if cd[a][b] <= eps: |
| gr = gc[b][2] |
| if gr > 1e-9 and abs(pradii[a] - gr) / gr <= rtol: |
| matched += 1 |
| rerrs.append(abs(pradii[a] - gr) / gr) |
| cdists.append(cd[a][b]) |
| prec, rec = matched / max(n_p, 1), matched / max(n_g, 1) |
| f1 = 2 * prec * rec / (prec + rec) if (prec + rec) > 0 else 0.0 |
| return {"match_f1": round(f1, 4), "matched": matched, "n_pred": n_p, "n_gt": n_g, |
| "radius_mape": round(float(np.mean(rerrs)), 6) if rerrs else 0.0, |
| "center_dist_mean_mm": round(float(np.mean(cdists)), 4) if cdists else None} |
|
|
|
|
| def _match_arcs(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag): |
| eps = max(0.5, EPS_CENTER_FRAC * gt_diag) |
| rtol = ARC_RTOL |
| pa = [(cx, cy, r, a1, a2) for cx, cy, r, a1, a2, layer in ent_pred["arcs"] if "hidden" not in layer.lower()] |
| ga = [(cx, cy, r, a1, a2) for cx, cy, r, a1, a2, layer in ent_gt["arcs"] if "hidden" not in layer.lower()] |
| n_p, n_g = len(pa), len(ga) |
| if n_p == 0 and n_g == 0: |
| return {"match_f1": 1.0, "matched": 0, "n_pred": 0, "n_gt": 0, |
| "radius_mape": 0.0, "center_dist_mean_mm": None} |
| if n_p == 0 or n_g == 0: |
| return {"match_f1": 0.0, "matched": 0, "n_pred": n_p, "n_gt": n_g, |
| "radius_mape": 0.0, "center_dist_mean_mm": None} |
| pcen = transform_points(np.array([(x, y) for x, y, r, a1, a2 in pa]), src_c, dst_c, scale) |
| pradii = [abs(scale) * radius for _, _, radius, _, _ in pa] |
| cost = np.full((n_p, n_g), 1e6) |
| cd = np.zeros((n_p, n_g)) |
| for i in range(n_p): |
| for j in range(n_g): |
| d = np.hypot(pcen[i][0] - ga[j][0], pcen[i][1] - ga[j][1]) |
| cd[i][j] = d |
| rr = abs(pradii[i] - ga[j][2]) / ga[j][2] if ga[j][2] > 1e-9 else 1e6 |
| angle_quality = _arc_angle_quality( |
| pa[i][3], pa[i][4], ga[j][3], ga[j][4] |
| ) |
| cost[i][j] = d + 100.0 * rr + 100.0 * (1.0 - angle_quality) |
| ri, ci = linear_sum_assignment(cost) |
| matched, rerrs, cdists = 0, [], [] |
| for a, b in zip(ri, ci): |
| if cd[a][b] <= eps: |
| gr = ga[b][2] |
| angle_quality = _arc_angle_quality( |
| pa[a][3], pa[a][4], ga[b][3], ga[b][4] |
| ) |
| if ( |
| gr > 1e-9 |
| and abs(pradii[a] - gr) / gr <= rtol |
| and angle_quality >= ARC_ANGLE_IOU_MIN |
| ): |
| matched += 1 |
| rerrs.append(abs(pradii[a] - gr) / gr) |
| cdists.append(cd[a][b]) |
| prec, rec = matched / max(n_p, 1), matched / max(n_g, 1) |
| f1 = 2 * prec * rec / (prec + rec) if (prec + rec) > 0 else 0.0 |
| return {"match_f1": round(f1, 4), "matched": matched, "n_pred": n_p, "n_gt": n_g, |
| "radius_mape": round(float(np.mean(rerrs)), 6) if rerrs else 0.0, |
| "center_dist_mean_mm": round(float(np.mean(cdists)), 4) if cdists else None} |
|
|
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| DENSE_SIGMA_FRAC = 0.02 |
| |
| |
| |
| DENSE_RADIUS_RHO = 0.05 |
|
|
|
|
| def _dense_pr_f1(prec, rec): |
| return float(2 * prec * rec / (prec + rec)) if (prec + rec) > 0 else 0.0 |
|
|
|
|
| def _dense_lines(pred_lines, gt_lines, src_c, dst_c, scale, gt_diag): |
| """Soft line score: instead of counting hits within tau, each point earns |
| exp(-d/sigma) for its nearest neighbour. Soft precision/recall -> soft F1. |
| Full credit at d=0, smoothly decaying, so improving d always raises reward.""" |
| pv = line_vertices(pred_lines) |
| gv = line_vertices(gt_lines) |
| if len(pv) == 0 and len(gv) == 0: |
| return 1.0 |
| if len(pv) == 0 or len(gv) == 0: |
| return 0.0 |
| pva = transform_points(pv, src_c, dst_c, scale) |
| sigma = max(1e-6, DENSE_SIGMA_FRAC * (gt_diag if gt_diag > 1e-6 else 1.0)) |
| D = cdist(pva, gv) |
| soft_prec = float(np.exp(-D.min(axis=1) / sigma).mean()) |
| soft_rec = float(np.exp(-D.min(axis=0) / sigma).mean()) |
| return _dense_pr_f1(soft_prec, soft_rec) |
|
|
|
|
| def _dense_circles(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag, key="circles"): |
| """Soft matched-F1 for circles/arcs, including aligned radius and arc angle.""" |
| pred_raw = [e for e in ent_pred[key] if "hidden" not in e[-1].lower()] |
| gt_raw = [e for e in ent_gt[key] if "hidden" not in e[-1].lower()] |
| pc = [(e[0], e[1], e[2]) for e in pred_raw] |
| gc = [(e[0], e[1], e[2]) for e in gt_raw] |
| n_p, n_g = len(pc), len(gc) |
| if n_p == 0 and n_g == 0: |
| return 1.0 |
| if n_p == 0 or n_g == 0: |
| return 0.0 |
| pcen = transform_points(np.array([(x, y) for x, y, r in pc]), src_c, dst_c, scale) |
| pradii = [abs(scale) * radius for _, _, radius in pc] |
| sigma = max(1e-6, DENSE_SIGMA_FRAC * (gt_diag if gt_diag > 1e-6 else 1.0)) |
| cost = np.zeros((n_p, n_g)) |
| qual = np.zeros((n_p, n_g)) |
| for i in range(n_p): |
| for j in range(n_g): |
| d = np.hypot(pcen[i][0] - gc[j][0], pcen[i][1] - gc[j][1]) |
| rr = abs(pradii[i] - gc[j][2]) / gc[j][2] if gc[j][2] > 1e-9 else 9.9 |
| q = np.exp(-d / sigma) * np.exp(-rr / DENSE_RADIUS_RHO) |
| if key == "arcs": |
| q *= _arc_angle_quality( |
| pred_raw[i][3], pred_raw[i][4], gt_raw[j][3], gt_raw[j][4] |
| ) |
| qual[i][j] = q |
| cost[i][j] = -q |
| ri, ci = linear_sum_assignment(cost) |
| got = float(sum(qual[a][b] for a, b in zip(ri, ci))) |
| return _dense_pr_f1(got / n_p, got / n_g) |
|
|
|
|
| def dense_geometry_score(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag): |
| """Continuous geometry score in [0,1] for RL reward (NOT the eval metric). |
| Same family decomposition/weights as score_geometry, but every family uses |
| a smooth distance-decay so the reward surface has a usable gradient.""" |
| vis_p = [l for l in ent_pred["lines"] if "hidden" not in l[-1].lower()] |
| vis_g = [l for l in ent_gt["lines"] if "hidden" not in l[-1].lower()] |
| hid_p = [l for l in ent_pred["lines"] if "hidden" in l[-1].lower()] |
| hid_g = [l for l in ent_gt["lines"] if "hidden" in l[-1].lower()] |
|
|
| parts = [("lines", _dense_lines(vis_p, vis_g, src_c, dst_c, scale, gt_diag), 1.0)] |
| if hid_g or hid_p: |
| parts.append(("hidden", _dense_lines(hid_p, hid_g, src_c, dst_c, scale, gt_diag), 0.5)) |
| if _has_family(ent_pred, ent_gt, "circles"): |
| parts.append(("circles", _dense_circles(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag, "circles"), 1.0)) |
| if _has_family(ent_pred, ent_gt, "arcs"): |
| parts.append(("arcs", _dense_circles(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag, "arcs"), 1.0)) |
| wsum = sum(w for _, _, w in parts) |
| return float(sum(v * w for _, v, w in parts) / wsum) if wsum > 0 else 0.0 |
|
|
|
|
| def _has_family(ent_pred, ent_gt, key): |
| def vis(ents): |
| return [e for e in ents if "hidden" not in e[-1].lower()] |
| return bool(vis(ent_pred[key]) or vis(ent_gt[key])) |
|
|
|
|
| |
| |
| |
|
|
| def _dim_family_value(dim_tuple): |
| """(family, value) for a parsed dim, preferring the TYPE flag over text glyphs. |
| A radius label 'R21' and a diameter label '%%c42' on the same feature are made |
| comparable by normalising both to the same 'measured length': radius*2 == diameter. |
| We keep the raw value but expose a `normed` diameter-equivalent for equivalence.""" |
| dt, txt = dim_tuple[0], dim_tuple[1] |
| tname = dim_type_name(dt) |
| fam_txt, val, _ = parse_dim_value(txt) |
| |
| family = tname if tname in ("linear", "aligned", "diameter", "radius") else fam_txt |
| return family, val |
|
|
|
|
| def _values_equivalent(fam_p, val_p, fam_g, val_g): |
| """True if two dims denote the same measurement within tolerance, treating |
| radius<->diameter as equivalent (compare on diameter-equivalent length).""" |
| if val_p is None or val_g is None: |
| return False |
|
|
| def dia_equiv(fam, v): |
| return v * 2.0 if fam == "radius" else v |
|
|
| |
| lin = {"linear", "aligned"} |
| cir = {"diameter", "radius"} |
| if fam_p in lin and fam_g in lin: |
| a, b = val_p, val_g |
| elif fam_p in cir and fam_g in cir: |
| a, b = dia_equiv(fam_p, val_p), dia_equiv(fam_g, val_g) |
| else: |
| return False |
| return abs(a - b) <= max(DIM_ABS_TOL, DIM_REL_TOL * abs(b)) |
|
|
|
|
| def _match_dims_by_binding(ent_pred, ent_gt, src_c, dst_c, scale): |
| """Hungarian 1-1 pairing of dims by aligned binding-point proximity.""" |
| pd, gd = ent_pred["dims"], ent_gt["dims"] |
| if not pd or not gd: |
| return [] |
| pb = transform_points(np.array([(d[5], d[6]) for d in pd]), src_c, dst_c, scale) |
| gb = np.array([(d[5], d[6]) for d in gd]) |
| cost = cdist(pb, gb) |
| ri, ci = linear_sum_assignment(cost) |
| return [(int(a), int(b), float(cost[a][b])) for a, b in zip(ri, ci)] |
|
|
|
|
| def score_annotation(ent_pred, ent_gt, src_c, dst_c, scale): |
| """标注正确性: value correctness (unit-normalised + tolerance + R/Ø equivalence) |
| matched by binding geometry, plus placement distance for value-matched dims. |
| Returns per-type recall + a single `score` in [0,1] (value F1).""" |
| pd, gd = ent_pred["dims"], ent_gt["dims"] |
| n_p, n_g = len(pd), len(gd) |
| if n_p == 0 and n_g == 0: |
| return {"score": 1.0, "value_f1": 1.0, "value_recall": 1.0, "value_precision": 1.0, |
| "matched": 0, "n_pred": 0, "n_gt": 0, "by_type": {}, |
| "placement_mean_mm": 0.0, "n_placement": 0} |
| pairs = _match_dims_by_binding(ent_pred, ent_gt, src_c, dst_c, scale) |
|
|
| by_type = defaultdict(lambda: {"matched": 0, "gt": 0, "pred": 0}) |
| for d in gd: |
| by_type[_dim_family_value(d)[0]]["gt"] += 1 |
| for d in pd: |
| by_type[_dim_family_value(d)[0]]["pred"] += 1 |
|
|
| matched = 0 |
| place_dists = [] |
| for pi, gi, _bind in pairs: |
| fam_p, val_p = _dim_family_value(pd[pi]) |
| fam_g, val_g = _dim_family_value(gd[gi]) |
| if _values_equivalent(fam_p, val_p, fam_g, val_g): |
| matched += 1 |
| by_type[fam_g]["matched"] += 1 |
| |
| pa = transform_points(np.array([[pd[pi][3], pd[pi][4]]]), src_c, dst_c, scale)[0] |
| place_dists.append(float(np.hypot(pa[0] - gd[gi][3], pa[1] - gd[gi][4]))) |
|
|
| recall = matched / max(n_g, 1) |
| precision = matched / max(n_p, 1) |
| f1 = 2 * recall * precision / (recall + precision) if (recall + precision) > 0 else 0.0 |
| by_type_out = {t: {"recall": round(v["matched"] / v["gt"], 4) if v["gt"] else 1.0, |
| "matched": v["matched"], "gt": v["gt"], "pred": v["pred"]} |
| for t, v in by_type.items()} |
| return {"score": round(f1, 4), "value_f1": round(f1, 4), |
| "value_recall": round(recall, 4), "value_precision": round(precision, 4), |
| "matched": matched, "n_pred": n_p, "n_gt": n_g, "by_type": by_type_out, |
| "placement_mean_mm": round(float(np.mean(place_dists)), 4) if place_dists else 0.0, |
| "n_placement": len(place_dists)} |
|
|
|
|
| |
| |
| |
|
|
| def geometry_soft_gate(gs): |
| """Soft gate in [GATE_FLOOR, 1] as a function of the geometry score. |
| Used to make annotation credit conditional on geometry being correct, |
| realising the progressive U -> G -> A relationship without hard-zeroing A.""" |
| return GATE_FLOOR + (1.0 - GATE_FLOOR) * max(0.0, min(1.0, gs)) |
|
|
|
|
| def compute_overall(u, g, a): |
| """Single end-to-end scalar in [0,1], progressively gated: U -> G -> A. |
| Not usable -> the usability ramp (<=0.25). |
| Usable non-degenerate -> USABLE_BASE + (1-USABLE_BASE) * quality, where |
| quality = (W_GEOM*G + W_ANNO * gate(G) * A) / (W_GEOM + W_ANNO) |
| i.e. annotation is only credited to the extent geometry is correct. |
| This is the value we recommend reusing directly as an RL reward.""" |
| if not u["all_ok"]: |
| return round(u["score"], 4) |
| gs = g["score"] if g is not None else 0.0 |
| a_s = a["score"] if a is not None else 0.0 |
| gated_a = geometry_soft_gate(gs) * a_s |
| quality = (W_GEOM * gs + W_ANNO * gated_a) / (W_GEOM + W_ANNO) |
| return round(USABLE_BASE + (1.0 - USABLE_BASE) * quality, 4) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--pred", required=True, help="predictions JSONL (infer_testset output)") |
| ap.add_argument("--gt-dir", required=True, help="GT DXF directory (gt_dxf_test)") |
| ap.add_argument("--pred-dxf-dir", default=None, help="where to write prediction DXFs") |
| ap.add_argument("--out", required=True, help="per-sample scores JSONL") |
| ap.add_argument("--summary", default=None, help="aggregate summary JSON") |
| ap.add_argument("--timeout", type=int, default=30, help="code run timeout (s)") |
| ap.add_argument("--limit", type=int, default=0) |
| args = ap.parse_args() |
|
|
| if args.pred_dxf_dir is None: |
| args.pred_dxf_dir = args.pred.replace(".jsonl", "_dxf") |
| os.makedirs(args.pred_dxf_dir, exist_ok=True) |
| gt_dir = os.path.abspath(args.gt_dir) |
| fout = open(args.out, "w", encoding="utf-8") |
|
|
| |
| u_flags = Counter() |
| u_scores, g_scores, a_scores, overalls = [], [], [], [] |
| g_lines, g_hidden, g_circ, g_arc = [], [], [], [] |
| |
| g_lines_nn, g_hidden_nn = [], [] |
| g_circ_cdist, g_circ_rmape = [], [] |
| g_arc_cdist, g_arc_rmape = [], [] |
| a_recalls, a_f1s = [], [] |
| a_by_type = defaultdict(lambda: {"recall_sum": 0.0, "count": 0}) |
| place_dists = [] |
| n_total = n_scored = 0 |
|
|
| for line in open(args.pred, encoding="utf-8"): |
| line = line.strip() |
| if not line: |
| continue |
| d = json.loads(line) |
| pid = d.get("id", "unknown") |
| n_total += 1 |
| if args.limit and n_total > args.limit: |
| n_total -= 1 |
| break |
|
|
| pred_code = d.get("prediction_code") or extract_code(d.get("prediction", "")) |
| pred_dxf = os.path.join(args.pred_dxf_dir, f"{pid}_pred.dxf") |
| if not os.path.isfile(pred_dxf): |
| run_code_to_dxf(pred_code, pred_dxf, timeout=args.timeout) |
|
|
| ent_pred = extract_entities(pred_dxf) if os.path.isfile(pred_dxf) else None |
| gt_dxf = os.path.join(gt_dir, f"{pid}.dxf") |
| ent_gt = extract_entities(gt_dxf) if os.path.isfile(gt_dxf) else None |
|
|
| u = score_usability(pred_code, pred_dxf, ent_pred) |
| for k in ("format_ok", "compile_ok", "run_ok", "dxf_readable", "non_degenerate", "all_ok"): |
| if u[k]: |
| u_flags[k] += 1 |
| u_scores.append(u["score"]) |
|
|
| sample = {"id": pid, "usability": u} |
| g = a = None |
| if ent_pred is not None and ent_gt is not None: |
| n_scored += 1 |
| src_c, dst_c, scale = shared_alignment(ent_pred, ent_gt) |
| gt_diag = bbox_diagonal(ent_gt) |
| g = score_geometry(ent_pred, ent_gt, src_c, dst_c, scale, gt_diag) |
| a = score_annotation(ent_pred, ent_gt, src_c, dst_c, scale) |
| sample["geometry"] = g |
| sample["annotation"] = a |
| g_scores.append(g["score"]); a_scores.append(a["score"]) |
| g_lines.append(g["lines"]["f1"]) |
| if g["lines"].get("nn_dist_mean_mm") is not None: |
| g_lines_nn.append(g["lines"]["nn_dist_mean_mm"]) |
| if g["hidden"]["present"]: |
| g_hidden.append(g["hidden"]["f1"]) |
| if g["hidden"].get("nn_dist_mean_mm") is not None: |
| g_hidden_nn.append(g["hidden"]["nn_dist_mean_mm"]) |
| if g["circles"]["n_gt"] or g["circles"]["n_pred"]: |
| g_circ.append(g["circles"]["match_f1"]) |
| if g["circles"].get("center_dist_mean_mm") is not None: |
| g_circ_cdist.append(g["circles"]["center_dist_mean_mm"]) |
| if g["circles"]["matched"]: |
| g_circ_rmape.append(g["circles"]["radius_mape"]) |
| if g["arcs"]["n_gt"] or g["arcs"]["n_pred"]: |
| g_arc.append(g["arcs"]["match_f1"]) |
| if g["arcs"].get("center_dist_mean_mm") is not None: |
| g_arc_cdist.append(g["arcs"]["center_dist_mean_mm"]) |
| if g["arcs"]["matched"]: |
| g_arc_rmape.append(g["arcs"]["radius_mape"]) |
| a_recalls.append(a["value_recall"]); a_f1s.append(a["value_f1"]) |
| for t, v in a["by_type"].items(): |
| a_by_type[t]["recall_sum"] += v["recall"]; a_by_type[t]["count"] += 1 |
| if a["n_placement"] > 0: |
| place_dists.append(a["placement_mean_mm"]) |
|
|
| overall = compute_overall(u, g, a) |
| sample["overall"] = overall |
| overalls.append(overall) |
| fout.write(json.dumps(sample, ensure_ascii=False) + "\n") |
|
|
| status = "OK" if u["all_ok"] else "--" |
| print(f" [{n_total}] {pid} {status} | overall={overall:.3f} | " |
| f"G={g['score'] if g else 'NA'} A={a['score'] if a else 'NA'}") |
|
|
| fout.close() |
|
|
| def mean(x): |
| return round(float(np.mean(x)), 4) if x else None |
|
|
| summary = { |
| "n_total": n_total, |
| "n_scored": n_scored, |
| "overall_mean": mean(overalls), |
| "Usability": { |
| "pass_rates": {k: round(v / max(1, n_total), 4) for k, v in u_flags.items()}, |
| "score_mean": mean(u_scores), |
| }, |
| "Geometry": { |
| "score_mean": mean(g_scores), |
| |
| "lines_f1_mean": mean(g_lines), |
| "hidden_f1_mean": mean(g_hidden), |
| "hidden_n_samples": len(g_hidden), |
| "circle_match_f1_mean": mean(g_circ), |
| "arc_match_f1_mean": mean(g_arc), |
| |
| "lines_nn_dist_mean_mm": mean(g_lines_nn), |
| "hidden_nn_dist_mean_mm": mean(g_hidden_nn), |
| "circle_center_dist_mean_mm": mean(g_circ_cdist), |
| "circle_radius_mape_mean": mean(g_circ_rmape), |
| "arc_center_dist_mean_mm": mean(g_arc_cdist), |
| "arc_radius_mape_mean": mean(g_arc_rmape), |
| }, |
| "Annotation": { |
| "score_mean": mean(a_scores), |
| "value_f1_mean": mean(a_f1s), |
| "value_recall_mean": mean(a_recalls), |
| "by_type": {t: {"recall_mean": round(v["recall_sum"] / max(1, v["count"]), 4), |
| "count": v["count"]} for t, v in a_by_type.items()}, |
| "placement_mean_mm": mean(place_dists), |
| "placement_n_samples": len(place_dists), |
| }, |
| } |
| print("\n" + "=" * 60) |
| print(json.dumps(summary, indent=2, ensure_ascii=False)) |
| if args.summary: |
| with open(args.summary, "w", encoding="utf-8") as f: |
| json.dump(summary, f, indent=2, ensure_ascii=False) |
| print(f"\nsummary written to: {args.summary}") |
| print(f"per-sample scores: {args.out}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
