#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ 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 ladder (mm) for line F1@tau BEFORE size-normalisation reference. # We normalise tau by the GT drawing diagonal so it is scale-robust across parts. TAU_FRACS = (0.005, 0.01, 0.02) # 0.5% / 1% / 2% of the GT bbox diagonal TAU_HEADLINE_IDX = 1 # headline uses the 1% tau # dimension value tolerance: matched if |v_pred - v_gt| <= max(ABS, REL*|v_gt|) DIM_ABS_TOL = 0.5 # mm DIM_REL_TOL = 0.01 # 1% # circle/arc center-distance threshold, normalised by the GT drawing diagonal # (same size-robust idea as the line F1@tau). A circle counts as located if its # aligned center is within EPS_CENTER_FRAC * gt_diag of the GT center. This fixes # the old absolute 0.5mm threshold that rejected correctly-drawn circles whenever # the overall view layout was slightly translated/scaled. EPS_CENTER_FRAC = 0.03 # 3% of GT bbox diagonal CIRCLE_RTOL = 0.02 # radius relative tolerance (circles) ARC_RTOL = 0.03 # radius relative tolerance (arcs, a bit looser) ARC_ANGLE_IOU_MIN = 0.50 ARC_DEGENERATE_ANGLE_TOL_DEG = 0.01 # overall-score weights (within the "usable" branch); usable base is added on top. W_GEOM = 0.5 W_ANNO = 0.5 USABLE_BASE = 0.3 # a usable, non-degenerate drawing floors at 0.3 before quality # SOFT GATE (progressive U -> G -> A): annotation quality is only credited to the # extent geometry is correct. We multiply the annotation term by a soft gate # derived from the geometry score, so "geometry wrong but numbers right" cannot # earn much overall, WITHOUT hard-zeroing A (the raw A is still reported for # diagnosis). gate = GATE_FLOOR + (1-GATE_FLOOR) * G, clipped to [0,1]. # GATE_FLOOR>0 keeps a small annotation credit alive even when G is low, so the # reward gradient does not fully vanish (helps RL / avoids dead zones). GATE_FLOOR = 0.25 # ============================================================ # SECTION 1 — code execution + DXF entity extraction (helpers) # ============================================================ 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, "", "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" # strip known prefixes / control tokens anywhere 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))) # ============================================================ # SECTION 2 — U: Usability # ============================================================ 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 # non-degenerate: produced real geometry with a sane bounding box 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, } # ============================================================ # SECTION 3 — shared alignment (Procrustes translate+scale) # ============================================================ 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 # Fold the 2 iterations into one transform relative to the ORIGINAL src. # aligned = s_total * (src - src_c0) + dst_c_final 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) # ============================================================ # SECTION 4 — G: Geometry (lines / hidden lines / circles / arcs) # ============================================================ 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()) # pred -> gt rec = float((D.min(axis=0) <= tau).mean()) # gt -> pred 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)]) # symmetric: both directions 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), # mm-accuracy (precision side): how far off matched vertices are "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) # weighted mean over families that are "present" in either pred or GT 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} # ============================================================ # SECTION 4b — G (DENSE): continuous geometry reward for RL only # ============================================================ # The metric above uses F1@tau / matched-F1 (threshold HITS). That is correct # for REPORTING but gives a FLAT reward surface for RL: a vertex at 1.1% error # and one at 5% error both score 0 until they cross tau, so the policy gets no # gradient while "getting closer". Here we reward CONTINUOUS proximity so every # mm of improvement is credited. The reported F1 metric is left unchanged; these # functions are used ONLY by the RL reward plugin. DENSE_SIGMA_FRAC = 0.02 # distance decay length = 2% of GT diagonal. # Chosen so the reward gradient is strongest around the # model's current line error (~2-9mm), giving signal both # for fine (near tau) and coarse (several-mm) improvements. DENSE_RADIUS_RHO = 0.05 # radius rel-err decay length for circles/arcs 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()) # pred -> gt soft_rec = float(np.exp(-D.min(axis=0) / sigma).mean()) # gt -> pred 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])) # ============================================================ # SECTION 5 — A: Annotation (dimension value + placement) # ============================================================ 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) # trust the DXF dimtype family first; fall back to text-derived family 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 # linear/aligned only compare to linear/aligned; circular compare to circular 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 # placement: defpoint distance after alignment (only for value-matched) 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)} # ============================================================ # SECTION 6 — per-sample overall + main # ============================================================ 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") # accumulators u_flags = Counter() u_scores, g_scores, a_scores, overalls = [], [], [], [] g_lines, g_hidden, g_circ, g_arc = [], [], [], [] # mm-accuracy accumulators (precision side of geometry) 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), # hit-ratio side (F1@tau / matched-F1) "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), # mm-accuracy side (precision): how far off matched geometry is "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()