| |
| """Benchmark-grade OBB evaluator (rotated IoU) for RipBench. |
| |
| Consumes prediction dumps from eval/predict_obb.py + the DOTA GT in |
| labels/obb/dota/. Same protocol as evaluate_detection.py: sweep the |
| confidence threshold on VAL, select best F2 @ rotated-IoU 0.50 (ties |
| broken by recall, then precision, then the higher threshold), FREEZE it, |
| apply to TEST. Appends one row per model x split to |
| eval/results/obb_eval.tsv. |
| |
| No CLI args - edit CONFIG below and run (needs shapely; the yoloV26 env |
| has it). |
| |
| Matching is COCO-style greedy in descending score order with rotated |
| (polygon) IoU. Because greedy matching in score order is stable under |
| threshold truncation, each image is matched ONCE at the confidence |
| floor and every threshold in the sweep is evaluated by truncating the |
| scored match list - O(1) per threshold. |
| """ |
|
|
| import json |
| import os |
| _RIPBENCH_ROOT = os.environ.get("RIPBENCH_ROOT", os.path.normpath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", ".."))) |
| from datetime import datetime |
|
|
| from shapely.geometry import Polygon |
|
|
| |
| DATASET_ROOT = _RIPBENCH_ROOT |
| PRED_DIR = os.path.join(DATASET_ROOT, "models", "obb", "best_models", "predictions") |
| PRED_GLOB = "*_preds_" |
| IOU_THR = 0.50 |
| CONF_GRID = [round(0.01 * i, 2) for i in range(1, 10)] + [round(0.05 * i, 2) for i in range(2, 19)] |
| USE_VAL_SELECTION = True |
| FIXED_CONF_THRESHOLD = None |
| SPLITS = ("val", "test") |
| OUT_TSV = os.path.join(os.path.dirname(os.path.abspath(__file__)), "results", "obb_eval.tsv") |
| |
|
|
| DOTA_DIR = os.path.join(DATASET_ROOT, "labels", "obb", "dota") |
|
|
| TSV_COLS = ["timestamp", "model", "task", "split", "selected_conf", "selected_on", |
| "n_images", "n_gt", "AP50", "P50", "R50", "F1_50", "F2_50", |
| "TP50", "FP50", "FN50"] |
|
|
|
|
| def gt_polys(split): |
| """{image basename: [Polygon, ...]} for every image in the split manifest |
| (images without a label file are negatives with an empty list).""" |
| out = {} |
| manifest = os.path.join(DOTA_DIR, f"{split}.txt") |
| for line in open(manifest).read().splitlines(): |
| if not line: |
| continue |
| rel = line[2:] if line.startswith("./") else line |
| stem = os.path.splitext(os.path.basename(rel))[0] |
| |
| parts = rel.split("/") |
| lbl = os.path.join(DOTA_DIR, "labels", *parts[1:-1], stem + ".txt") |
| polys = [] |
| if os.path.isfile(lbl): |
| for row in open(lbl).read().splitlines(): |
| vals = row.split() |
| if len(vals) < 9: |
| continue |
| pts = [(float(vals[i]), float(vals[i + 1])) for i in range(0, 8, 2)] |
| g = Polygon(pts) |
| if not g.is_valid: |
| g = g.buffer(0) |
| if not g.is_empty: |
| polys.append(g) |
| out[stem] = polys |
| return out |
|
|
|
|
| def riou(a, b): |
| try: |
| inter = a.intersection(b).area |
| union = a.union(b).area |
| return inter / union if union > 0 else 0.0 |
| except Exception: |
| return 0.0 |
|
|
|
|
| def match_split(preds_file, gts): |
| """One greedy pass per image at the conf floor. Returns (scored, n_gt) |
| where scored = [(score, matched_bool), ...] sorted by descending score |
| across the whole split; thresholding = truncation.""" |
| per_img = {} |
| for p in json.load(open(preds_file)): |
| per_img.setdefault(p["image"], []).append(p) |
| scored = [] |
| n_gt = 0 |
| for stem, polys in gts.items(): |
| n_gt += len(polys) |
| used = set() |
| for p in sorted(per_img.get(stem, []), key=lambda x: -x["score"]): |
| pts = p["poly"] |
| g = Polygon([(pts[i], pts[i + 1]) for i in range(0, 8, 2)]) |
| if not g.is_valid: |
| g = g.buffer(0) |
| best, bi = -1.0, -1 |
| for j, o in enumerate(polys): |
| if j in used: |
| continue |
| v = riou(g, o) |
| if v > best: |
| best, bi = v, j |
| ok = best >= IOU_THR |
| if ok: |
| used.add(bi) |
| scored.append((p["score"], ok)) |
| scored.sort(key=lambda x: -x[0]) |
| return scored, n_gt |
|
|
|
|
| def counts_at(scored, n_gt, thr): |
| tp = fp = 0 |
| for s, ok in scored: |
| if s < thr: |
| break |
| if ok: |
| tp += 1 |
| else: |
| fp += 1 |
| return tp, fp, n_gt - tp |
|
|
|
|
| def prf2(tp, fp, fn): |
| p = tp / (tp + fp + 1e-9) |
| r = tp / (tp + fn + 1e-9) |
| f1 = 2 * p * r / (p + r + 1e-9) |
| f2 = 5 * p * r / (4 * p + r + 1e-9) |
| return p, r, f1, f2 |
|
|
|
|
| def ap50(scored, n_gt): |
| """All-point interpolated AP at the rotated-IoU threshold.""" |
| prec, rec = [], [] |
| tp = fp = 0 |
| for s, ok in scored: |
| if ok: |
| tp += 1 |
| else: |
| fp += 1 |
| prec.append(tp / (tp + fp)) |
| rec.append(tp / (n_gt + 1e-9)) |
| if not prec: |
| return 0.0 |
| for i in range(len(prec) - 2, -1, -1): |
| prec[i] = max(prec[i], prec[i + 1]) |
| ap, prev_r = 0.0, 0.0 |
| for p, r in zip(prec, rec): |
| ap += p * (r - prev_r) |
| prev_r = r |
| return ap |
|
|
|
|
| def main(): |
| os.makedirs(os.path.dirname(OUT_TSV), exist_ok=True) |
| if not os.path.isfile(OUT_TSV): |
| with open(OUT_TSV, "w") as f: |
| f.write("\t".join(TSV_COLS) + "\n") |
| gts = {s: gt_polys(s) for s in SPLITS} |
| stems = sorted({f.split("_preds_")[0] for f in os.listdir(PRED_DIR) |
| if "_preds_" in f and f.endswith(".json")}) |
| for stem in stems: |
| matched = {} |
| for s in SPLITS: |
| pf = os.path.join(PRED_DIR, f"{stem}_preds_{s}.json") |
| if not os.path.isfile(pf): |
| print(f"SKIP {stem}: missing {s} predictions") |
| matched = None |
| break |
| matched[s] = match_split(pf, gts[s]) |
| if matched is None: |
| continue |
| if USE_VAL_SELECTION: |
| sv, nv = matched["val"] |
| best = max(CONF_GRID, key=lambda t: ( |
| prf2(*counts_at(sv, nv, t))[3], |
| prf2(*counts_at(sv, nv, t))[1], |
| prf2(*counts_at(sv, nv, t))[0], |
| t)) |
| sel_on = "val" |
| else: |
| best, sel_on = FIXED_CONF_THRESHOLD, "fixed" |
| for s in SPLITS: |
| sc, ng = matched[s] |
| tp, fp, fn = counts_at(sc, ng, best) |
| p, r, f1, f2 = prf2(tp, fp, fn) |
| row = [datetime.now().strftime("%Y-%m-%d %H:%M"), stem, "obb", s, |
| f"{best:.2f}", sel_on, str(len(gts[s])), str(ng), |
| f"{ap50(sc, ng):.6f}", f"{p:.6f}", f"{r:.6f}", |
| f"{f1:.6f}", f"{f2:.6f}", str(tp), str(fp), str(fn)] |
| with open(OUT_TSV, "a") as f: |
| f.write("\t".join(row) + "\n") |
| print(f"{stem} [{s}] conf {best:.2f}: AP50 {ap50(sc, ng):.3f} " |
| f"F2 {f2:.3f} (P {p:.3f} R {r:.3f})") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
