#!/usr/bin/env python3 """ Anomaly-type difficulty matrices for I-BADAS. Joins per-image AUPRO (M3DM multimodal, STFPM RGB) to the anomaly-type sets taken from the COCO annotation files, then writes ten standalone figures: fig01_matrix_m3dm mean AUPRO per anomaly-type combination fig02_matrix_stfpm same, RGB baseline fig03_matrix_combined mean of the two methods, per image fig04_matrix_m3dm_minus_stfpm paired difference fig05_matrix_stfpm_minus_m3dm paired difference, sign flipped fig06_multiplicity_m3dm AUPRO vs number of co-occurring types fig07_multiplicity_stfpm fig08_multiplicity_combined fig09_multiplicity_m3dm_minus_stfpm paired difference vs multiplicity fig10_multiplicity_stfpm_minus_m3dm Each figure is written as PDF (vector, for the paper) and PNG, and every underlying matrix is written as CSV so the numbers in the caption can be checked without re-reading the figure. Join key -------- The three sources spell the same image differently: COCO file_name 'anomaly/rgb/00001.png' + scene from the folder M3DM image_id '000006/good/00015/rgb.png' STFPM image_key '000004_zivid_darkblue/anomaly/rgb/00001.png' so all three are reduced to a canonical (scene number, split, sample id) triple. Unmatched keys are reported rather than silently dropped. Category selection ------------------ 'box' and 'permanent_mortise' are excluded by name. nuisance_dent is kept even though its supercategory is 'box'. Everything else with supercategory 'nuisance' or 'object' is kept. Category names are shown verbatim, including underscores. Usage ----- python plot_difficulty.py python plot_difficulty.py \ --coco test \ --m3dm checkpoint_data/per_image_aupro_zivid.csv checkpoint_data/per_image_aupro_realsense.csv \ --stfpm checkpoint_data/per_image_aupro_stfpm.csv \ --out checkpoint_data/difficulty_figures """ from __future__ import annotations import argparse import re import sys from collections import Counter, defaultdict from itertools import combinations from pathlib import Path import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt import numpy as np import pandas as pd from matplotlib.colors import LinearSegmentedColormap plt.rcParams.update({ "font.family": "serif", "font.serif": ["Times New Roman", "DejaVu Serif"], "font.size": 8, "axes.linewidth": 0.6, "pdf.fonttype": 42, # editable text in the PDF }) # Transparent paper palette COLORS = { "yellow": "#48c16e80", "teal": "#1e9c8980", "purple": "#eae51a80", "PASTEL_PURPLE": "#48237480", } # Sequential ramp for absolute metrics, dark to light. PAPER_SEQUENTIAL = LinearSegmentedColormap.from_list( "paper_sequential", [COLORS["PASTEL_PURPLE"], COLORS["teal"], COLORS["yellow"], COLORS["purple"]], N=256, ) # Zero-centred ramp for paired differences. PAPER_DIVERGING = LinearSegmentedColormap.from_list( "paper_diverging", [COLORS["PASTEL_PURPLE"], COLORS["purple"], COLORS["teal"]], N=256, ) for _cmap in (PAPER_SEQUENTIAL, PAPER_DIVERGING): _cmap.set_bad("white") # 'box' and 'permanent_mortise' are container structure and are excluded by name DROP_SUPERCATEGORIES = {"box"} DROP_NAMES = {"box", "permanent_mortise"} FORCE_KEEP_NAMES = {"nuisance_dent"} ANOMALOUS_SPLITS = {"anomaly", "anomalous", "test_bad", "bad", "defect"} # ---------------------------------------------------------------------- # Canonical image key # ---------------------------------------------------------------------- def canonical_key(path_like, scene_hint=None): """Reduce any of the path spellings to (scene, split, sample_id).""" parts = [p for p in re.split(r"[\\/]+", str(path_like)) if p] if scene_hint is not None: parts = [str(scene_hint)] + parts scene = None scene_at = None for i, part in enumerate(parts): m = re.search(r"(\d{4,6})", part) if m: scene = m.group(1).zfill(6) scene_at = i break if scene is None: return None split = None for part in parts[scene_at + 1:]: low = part.lower() if low in ANOMALOUS_SPLITS: split = "anomaly" break if low in {"good", "normal", "test_good", "ok"}: split = "good" break if split is None: split = "unknown" stem = Path(parts[-1]).stem if re.fullmatch(r"\d+", stem): sample = stem.zfill(5) else: sample = None after = [p for p in parts[scene_at + 1:] if p.lower() not in ANOMALOUS_SPLITS | {"good", "normal", "test_good", "ok", "rgb", "xyz", "depth"}] for part in after: if re.fullmatch(r"\d+", part): sample = part.zfill(5) break if sample is None: return None return (scene, split, sample) # ---------------------------------------------------------------------- # Annotations # ---------------------------------------------------------------------- def load_annotations(coco_paths, verbose=True): """Return {canonical_key: set(type names)} for anomalous images.""" import json per_image = {} supercats = defaultdict(set) n_files = 0 for path in coco_paths: with open(path, "r", encoding="utf-8") as f: coco = json.load(f) n_files += 1 scene_hint = Path(path).parent.name id2name, keep_ids = {}, set() for c in coco["categories"]: name = str(c["name"]).strip() sc = str(c.get("supercategory", "")).strip() id2name[c["id"]] = name supercats[name].add(sc) if name in DROP_NAMES: continue if name in FORCE_KEEP_NAMES or sc not in DROP_SUPERCATEGORIES: keep_ids.add(c["id"]) img_key = {} for img in coco["images"]: key = canonical_key(img["file_name"], scene_hint=scene_hint) if key is None: continue img_key[img["id"]] = key per_image.setdefault(key, set()) for ann in coco["annotations"]: if ann["category_id"] not in keep_ids: continue key = img_key.get(ann["image_id"]) if key is not None: per_image[key].add(id2name[ann["category_id"]]) inconsistent = {n: sorted(s) for n, s in supercats.items() if len(s) > 1} if verbose: dropped = sorted(n for n, s in supercats.items() if n in DROP_NAMES or (n not in FORCE_KEEP_NAMES and s & DROP_SUPERCATEGORIES)) print(f" annotation files read : {n_files}") print(f" images with types : {sum(1 for v in per_image.values() if v)}") print(f" excluded categories : {', '.join(dropped) or 'none'}") if inconsistent: print(f" ! supercategory differs across files: {inconsistent}", file=sys.stderr) return per_image # ---------------------------------------------------------------------- # Per-image AUPRO # ---------------------------------------------------------------------- def load_scores(csv_paths, metric, label, verbose=True): """Return {canonical_key: mean metric} averaged over runs/methods/sensors.""" frames = [] for path in csv_paths: df = pd.read_csv(path) frames.append(df) if not frames: return {} df = pd.concat(frames, ignore_index=True) id_col = None for candidate in ("image_key", "image_id", "original_path"): if candidate in df.columns: id_col = candidate break if id_col is None: raise SystemExit(f"{label}: no image identity column found in {csv_paths}") if metric not in df.columns: raise SystemExit(f"{label}: metric {metric!r} not in {list(df.columns)}") df["_key"] = df[id_col].map(canonical_key) unresolved = int(df["_key"].isna().sum()) df = df[df["_key"].notna()] grouped = df.groupby("_key")[metric].agg(["mean", "count"]) scores = grouped["mean"].to_dict() if verbose: print(f" {label}: {len(df)} rows -> {len(scores)} unique images " f"(mean {grouped['count'].mean():.1f} rows/image)") if unresolved: print(f" ! {label}: {unresolved} rows had an unparsable image key", file=sys.stderr) anomalous = sum(1 for k in scores if k[1] == "anomaly") if anomalous < len(scores): print(f" ! {label}: {len(scores) - anomalous} images are not in an " f"'anomaly' split but carry a score", file=sys.stderr) return scores # ---------------------------------------------------------------------- # Matrix construction # ---------------------------------------------------------------------- def build_matrix(per_image, scores, categories): n = len(categories) idx = {c: i for i, c in enumerate(categories)} total = np.zeros((n, n)) count = np.zeros((n, n), dtype=int) exact_total = np.zeros((n, n)) exact_count = np.zeros((n, n), dtype=int) for key, types in per_image.items(): if key not in scores: continue types = {t for t in types if t in idx} if not types: continue value = scores[key] for t in types: i = idx[t] total[i, i] += value count[i, i] += 1 for a, b in combinations(sorted(types), 2): i, j = idx[a], idx[b] total[i, j] += value; total[j, i] += value count[i, j] += 1; count[j, i] += 1 if len(types) == 2: exact_total[i, j] += value; exact_total[j, i] += value exact_count[i, j] += 1; exact_count[j, i] += 1 with np.errstate(invalid="ignore", divide="ignore"): mean = np.where(count > 0, total / np.maximum(count, 1), np.nan) exact_mean = np.where(exact_count > 0, exact_total / np.maximum(exact_count, 1), np.nan) return mean, count, exact_mean, exact_count def multiplicity_stats(per_image, scores, categories): keep = set(categories) buckets = defaultdict(list) for key, types in per_image.items(): if key not in scores: continue k = len({t for t in types if t in keep}) if k >= 1: buckets[k].append(scores[key]) ks = sorted(buckets) return (np.array(ks), np.array([np.mean(buckets[k]) for k in ks]), np.array([np.std(buckets[k], ddof=1) if len(buckets[k]) > 1 else 0.0 for k in ks]), np.array([len(buckets[k]) for k in ks])) # ---------------------------------------------------------------------- # Plotting # ---------------------------------------------------------------------- def short(name): return name.replace("nuisance_", "").replace("_", " ") def plot_matrix(mean, count, categories, cbar_label, out_stem, min_n, diverging_zero=False, vlim=None): n = len(categories) show = np.where(count >= min_n, mean, np.nan) valid = show[np.isfinite(show)] if valid.size == 0: print(f" ! {out_stem}: every cell below min_n={min_n}, skipped", file=sys.stderr) return None if vlim is not None: vmin, vmax = vlim elif diverging_zero: m = np.nanmax(np.abs(valid)) vmin, vmax = -m, m else: centre = float(np.nanmean(valid)) spread = float(np.nanmax(np.abs(valid - centre))) vmin, vmax = centre - spread, centre + spread fig, ax = plt.subplots(figsize=(7.4, 6.2)) cmap = (PAPER_DIVERGING if diverging_zero else PAPER_SEQUENTIAL).copy() cmap.set_bad("white") im = ax.imshow(np.ma.masked_invalid(show), cmap=cmap, vmin=vmin, vmax=vmax) for i in range(n): for j in range(n): if count[i, j] < min_n: if count[i, j] > 0: ax.text(j, i, f"{count[i, j]}", ha="center", va="center", fontsize=4.8, color="black", zorder=5) continue ax.text(j, i, f"{mean[i, j]:.2f}\n{count[i, j]}", ha="center", va="center", fontsize=5.4, linespacing=1.05, color="black", zorder=5) labels = list(categories) ax.set_xticks(range(n)); ax.set_yticks(range(n)) ax.set_xticklabels(labels, rotation=50, ha="right", fontsize=6.5) ax.set_yticklabels(labels, fontsize=6.5) ax.set_xticks(np.arange(-.5, n, 1), minor=True) ax.set_yticks(np.arange(-.5, n, 1), minor=True) ax.grid(which="minor", color="0.82", linewidth=0.7) ax.tick_params(which="minor", length=0) ax.set_axisbelow(True) cb = fig.colorbar(im, ax=ax, fraction=0.045, pad=0.03, shrink=0.72) cb.set_label(cbar_label, fontsize=7.5) cb.ax.tick_params(labelsize=6.5) cb.outline.set_linewidth(0.6) fig.tight_layout() for ext in ("pdf", "png"): fig.savefig(f"{out_stem}.{ext}", dpi=400, bbox_inches="tight") plt.close(fig) return (vmin, vmax) def plot_multiplicity(series, ylabel, out_stem, zero_line=False): fig, ax = plt.subplots(figsize=(5.0, 3.7)) for label, (ks, mu, sd, ns) in series.items(): if ks.size == 0: continue sem = np.divide(sd, np.sqrt(np.maximum(ns, 1))) ax.errorbar(ks, mu, yerr=sem, marker="none", lw=1.4, capsize=2.5, color="0.45", zorder=2, label=label) grade = (ks - ks.min()) / max(ks.max() - ks.min(), 1) ax.scatter(ks, mu, s=42, c=[PAPER_SEQUENTIAL(g) for g in grade], edgecolor="black", linewidth=0.5, zorder=3) for k, m, e, nn in zip(ks, mu, sem, ns): ax.annotate(f"{nn}", (k, m + e), textcoords="offset points", xytext=(0, 6), ha="center", fontsize=5.6, color="black") if zero_line: ax.axhline(0.0, color="black", lw=0.8, ls="--", zorder=0) ax.set_xlabel("Distinct Anomaly Types Present", fontsize=8.5) ax.set_ylabel(ylabel, fontsize=8.5) all_ks = sorted({int(k) for ks, *_ in series.values() for k in ks}) if all_ks: ax.set_xticks(all_ks) ax.tick_params(labelsize=7.5) ax.margins(y=0.13) for s_ in ("top", "right"): ax.spines[s_].set_visible(False) if len(series) > 1: ax.legend(fontsize=7.5, frameon=False) fig.tight_layout() for ext in ("pdf", "png"): fig.savefig(f"{out_stem}.{ext}", dpi=400, bbox_inches="tight") plt.close(fig) def save_matrix_csv(path, mean, count, categories): rows = [] for i, a in enumerate(categories): for j, b in enumerate(categories): if j < i: continue rows.append({"type_i": a, "type_j": b, "kind": "single" if i == j else "pair", "mean": mean[i, j], "n": int(count[i, j])}) pd.DataFrame(rows).to_csv(path, index=False) def default_coco_search(): candidates = [ Path("test"), Path("../test"), Path(__file__).resolve().parent.parent / "test", Path("train"), Path("../train"), Path(__file__).resolve().parent.parent / "train", Path("."), Path(".."), Path(__file__).resolve().parent.parent, ] for c in candidates: if c.is_dir() and list(c.rglob("annotations*.coco.json")): return [str(c)] return ["."] def find_files(names): resolved = [] for name in names: candidates = [ Path(f"checkpoint_data/{name}"), Path(f"../checkpoint_data/{name}"), Path(__file__).resolve().parent.parent / "checkpoint_data" / name, Path(__file__).resolve().parent / name, Path(name), ] found = next((str(c) for c in candidates if c.is_file()), None) if found: resolved.append(found) return resolved def default_out_dir(): if Path("checkpoint_data").is_dir(): return Path("checkpoint_data/difficulty_figures") if (Path(__file__).resolve().parent.parent / "checkpoint_data").is_dir(): return Path(__file__).resolve().parent.parent / "checkpoint_data/difficulty_figures" return Path("./difficulty_figures") # ---------------------------------------------------------------------- def main(): p = argparse.ArgumentParser(description="Anomaly-type difficulty matrices and multiplicity plots") p.add_argument("--coco", nargs="+", default=None, help="annotation files, or a directory to search (auto-detected if omitted)") p.add_argument("--coco-pattern", default="annotations*.coco.json") p.add_argument("--m3dm", nargs="*", default=None, help="M3DM per-image CSVs (auto-detected from checkpoint_data/ if omitted)") p.add_argument("--stfpm", nargs="*", default=None, help="STFPM per-image CSVs (auto-detected from checkpoint_data/ if omitted)") p.add_argument("--metric", default="aupro_30") p.add_argument("--min-n", type=int, default=20) p.add_argument("--out", default=None, help="output directory (default: checkpoint_data/difficulty_figures or ./difficulty_figures)") a = p.parse_args() coco_entries = a.coco if a.coco is not None else default_coco_search() coco_paths = [] for entry in coco_entries: path = Path(entry) coco_paths.extend(sorted(str(q) for q in path.rglob(a.coco_pattern)) if path.is_dir() else [str(path)]) if not coco_paths: raise SystemExit(f"No annotation files found in {coco_entries}") m3dm_paths = a.m3dm if a.m3dm is not None else find_files(["per_image_aupro_zivid.csv", "per_image_aupro_realsense.csv"]) stfpm_paths = a.stfpm if a.stfpm is not None else find_files(["per_image_aupro_stfpm.csv"]) out = Path(a.out) if a.out is not None else default_out_dir() out.mkdir(parents=True, exist_ok=True) print("Annotations") per_image = load_annotations(coco_paths) print("\nPer-image scores") m3dm = load_scores(m3dm_paths, a.metric, "M3DM") if m3dm_paths else {} stfpm = load_scores(stfpm_paths, a.metric, "STFPM") if stfpm_paths else {} if not m3dm and not stfpm: raise SystemExit("no per-image score files given or found") ann_keys = {k for k, v in per_image.items() if v} print("\nJoin") for label, sc in (("M3DM", m3dm), ("STFPM", stfpm)): if not sc: continue matched = ann_keys & set(sc) print(f" {label}: {len(matched)} of {len(sc)} scored images matched " f"an annotated image with >=1 anomaly type") if not matched: print(f" ! {label}: nothing matched.", file=sys.stderr) paired = {k: 0.5 * (m3dm[k] + stfpm[k]) for k in set(m3dm) & set(stfpm)} diff = {k: m3dm[k] - stfpm[k] for k in set(m3dm) & set(stfpm)} print(f" images scored by both methods: {len(paired)}") categories = sorted({t for k in ann_keys for t in per_image[k]}) print(f"\n{len(categories)} anomaly types: {', '.join(categories)}") made = [] absolute = {} for label, sc in (("M3DM", m3dm), ("STFPM", stfpm), ("Combined", paired)): if sc: absolute[label] = build_matrix(per_image, sc, categories) pool = [] for label in ("M3DM", "STFPM"): if label in absolute: mean, count, *_ = absolute[label] pool.append(mean[count >= a.min_n]) shared = None if pool: vals = np.concatenate(pool) vals = vals[np.isfinite(vals)] if vals.size: centre = float(vals.mean()) spread = float(np.abs(vals - centre).max()) shared = (centre - spread, centre + spread) metric_label = a.metric.replace("aupro_", "AUPRO@").replace("_", " ") if metric_label.startswith("AUPRO@"): metric_label += "%" spec = [ ("fig01_matrix_m3dm", "M3DM"), ("fig02_matrix_stfpm", "STFPM"), ("fig03_matrix_combined", "Combined"), ] for stem, label in spec: if label not in absolute: continue mean, count, exact_mean, exact_count = absolute[label] plot_matrix(mean, count, categories, f"Mean {metric_label}", str(out / stem), a.min_n, vlim=shared if label != "Combined" else None) save_matrix_csv(out / f"{stem}_values.csv", mean, count, categories) save_matrix_csv(out / f"{stem}_exactpairs.csv", exact_mean, exact_count, categories) made.append(stem) if diff: dm, dc, dem, dec = build_matrix(per_image, diff, categories) plot_matrix(dm, dc, categories, f"Δ {metric_label} (Positive: M3DM Better)", str(out / "fig04_matrix_m3dm_minus_stfpm"), a.min_n, diverging_zero=True) save_matrix_csv(out / "fig04_matrix_m3dm_minus_stfpm_values.csv", dm, dc, categories) plot_matrix(-dm, dc, categories, f"Δ {metric_label} (Positive: STFPM Better)", str(out / "fig05_matrix_stfpm_minus_m3dm"), a.min_n, diverging_zero=True) save_matrix_csv(out / "fig05_matrix_stfpm_minus_m3dm_values.csv", -dm, dc, categories) made += ["fig04_matrix_m3dm_minus_stfpm", "fig05_matrix_stfpm_minus_m3dm"] mult = {} for label, sc in (("M3DM", m3dm), ("STFPM", stfpm), ("Combined", paired)): if sc: mult[label] = multiplicity_stats(per_image, sc, categories) for stem, label in (("fig06_multiplicity_m3dm", "M3DM"), ("fig07_multiplicity_stfpm", "STFPM"), ("fig08_multiplicity_combined", "Combined")): if label not in mult: continue plot_multiplicity({label: mult[label]}, f"Mean {metric_label}", str(out / stem)) ks, mu, sd, ns = mult[label] pd.DataFrame({"n_types": ks, "mean": mu, "std": sd, "n_images": ns}) \ .to_csv(out / f"{stem}_values.csv", index=False) made.append(stem) if diff: dstats = multiplicity_stats(per_image, diff, categories) plot_multiplicity({"difference": dstats}, f"Δ {metric_label} (Positive: M3DM Better)", str(out / "fig09_multiplicity_m3dm_minus_stfpm"), zero_line=True) ks, mu, sd, ns = dstats pd.DataFrame({"n_types": ks, "mean": mu, "std": sd, "n_images": ns}) \ .to_csv(out / "fig09_multiplicity_m3dm_minus_stfpm_values.csv", index=False) flipped = (dstats[0], -dstats[1], dstats[2], dstats[3]) plot_multiplicity({"difference": flipped}, f"Δ {metric_label} (Positive: STFPM Better)", str(out / "fig10_multiplicity_stfpm_minus_m3dm"), zero_line=True) ks, mu, sd, ns = flipped pd.DataFrame({"n_types": ks, "mean": mu, "std": sd, "n_images": ns}) \ .to_csv(out / "fig10_multiplicity_stfpm_minus_m3dm_values.csv", index=False) made += ["fig09_multiplicity_m3dm_minus_stfpm", "fig10_multiplicity_stfpm_minus_m3dm"] print(f"\nWrote {len(made)} figures (PDF + PNG) and underlying CSVs to {out}") if __name__ == "__main__": main()