| |
| """ |
| Anomaly-type co-occurrence matrix for I-BADAS. |
| |
| Reads the per-scene COCO annotation files, pools them, and counts per-image |
| PRESENCE of each anomaly type (an image with three separate oil patches counts |
| once for nuisance_oil). Produces: |
| |
| (a) an NxN co-occurrence heatmap; diagonal = images containing that type, |
| off-diagonal = images containing both types |
| (b) a bar chart of the number of distinct anomaly types per anomalous image |
| """ |
|
|
| import argparse |
| import json |
| 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 |
| from matplotlib.gridspec import GridSpec |
|
|
| plt.rcParams.update({ |
| "font.family": "serif", |
| "font.serif": ["Times New Roman", "DejaVu Serif"], |
| "font.size": 7, |
| "axes.linewidth": 0.6, |
| }) |
|
|
| DEFAULT_DROP_SUPERCAT = {"box"} |
|
|
|
|
| def file_stem(path): |
| stem = Path(path).name |
| for suffix in (".coco.json", ".json"): |
| if stem.endswith(suffix): |
| return stem[: -len(suffix)] |
| return stem |
|
|
|
|
| def scene_labels(paths): |
| labels = {p: file_stem(p) for p in paths} |
| for depth in range(1, 8): |
| clash = {lab for lab, c in Counter(labels.values()).items() if c > 1} |
| if not clash: |
| break |
| for p in paths: |
| if labels[p] in clash: |
| parts = Path(p).resolve().parts[:-1] |
| prefix = parts[-depth:] if len(parts) >= depth else parts |
| labels[p] = "/".join([*prefix, file_stem(p)]) |
| return labels |
|
|
|
|
| def sort_key(path): |
| return [int(t) if t.isdigit() else t for t in re.split(r"(\d+)", str(path))] |
|
|
|
|
| def load_scene(path, scene, level, keep_supercat, drop_names, keep_names, |
| subset, min_area, audit): |
| with open(path, "r", encoding="utf-8") as f: |
| coco = json.load(f) |
|
|
| id2name, id2cat = {}, {} |
| for c in coco.get("categories", []): |
| name = str(c["name"]).strip() |
| supercat = str(c.get("supercategory", "")).strip() |
| id2name[c["id"]] = name |
| id2cat[c["id"]] = c |
| audit["supercat"][name].add(supercat) |
|
|
| keep_ids = set() |
| for cid, c in id2cat.items(): |
| name = id2name[cid] |
| sc = str(c.get("supercategory", "")).strip() |
| if name in drop_names: |
| audit["excluded"][name] = f"dropped by name ({sc})" |
| elif name in keep_names: |
| keep_ids.add(cid) |
| elif sc in keep_supercat: |
| keep_ids.add(cid) |
| else: |
| audit["excluded"][name] = sc |
|
|
| images = {} |
| for im in coco.get("images", []): |
| meta = { |
| "file_name": im.get("file_name", ""), |
| "classification": im.get("classification"), |
| "width": im.get("width"), |
| "height": im.get("height"), |
| } |
| images[im["id"]] = meta |
|
|
| per_unit = {} |
| for iid in images: |
| if subset and images[iid]["classification"] != subset: |
| continue |
| key = scene if level == "scene" else f"{scene}::{iid}" |
| per_unit.setdefault(key, set()) |
|
|
| for ann in coco.get("annotations", []): |
| cid = ann.get("category_id") |
| iid = ann.get("image_id") |
| if cid not in keep_ids or iid not in images: |
| continue |
| if subset and images[iid]["classification"] != subset: |
| continue |
| if min_area and ann.get("area", float("inf")) < min_area: |
| audit["tiny"] += 1 |
| continue |
| key = scene if level == "scene" else f"{scene}::{iid}" |
| per_unit[key].add(id2name[cid]) |
|
|
| unit_meta = {} |
| if level == "image": |
| for iid, m in images.items(): |
| if not subset or m["classification"] == subset: |
| unit_meta[f"{scene}::{iid}"] = m |
|
|
| return per_unit, unit_meta |
|
|
|
|
| def build_counts(per_unit, categories): |
| n = len(categories) |
| idx = {c: i for i, c in enumerate(categories)} |
| M = np.zeros((n, n), dtype=int) |
| mult = Counter() |
|
|
| for types in per_unit.values(): |
| types = {t for t in types if t in idx} |
| mult[len(types)] += 1 |
| for t in types: |
| M[idx[t], idx[t]] += 1 |
| for a, b in combinations(types, 2): |
| i, j = idx[a], idx[b] |
| M[i, j] += 1 |
| M[j, i] += 1 |
|
|
| return M, mult |
|
|
|
|
| def short(name): |
| return name.replace("nuisance_", "").replace("_", " ") |
|
|
|
|
| def plot(M, categories, mult, out_stem, level): |
| n = len(categories) |
| labels = [short(c) for c in categories] |
|
|
| fig = plt.figure(figsize=(7.5, 3.4), dpi=300) |
| gs = GridSpec(1, 2, width_ratios=[1.35, 1.0], wspace=0.35, |
| left=0.18, right=0.96, top=0.90, bottom=0.22) |
|
|
| ax0 = fig.add_subplot(gs[0]) |
| vmax = int(M.max()) if M.size else 1 |
| im = ax0.imshow(M, cmap="magma", vmin=0, vmax=vmax) |
|
|
| for i in range(n): |
| for j in range(n): |
| val = M[i, j] |
| if val == 0: |
| continue |
| bright = val / vmax > 0.55 |
| col = "black" if bright else "white" |
| fw = "bold" if i == j else "normal" |
| ax0.text(j, i, str(val), ha="center", va="center", |
| fontsize=5.5, color=col, fontweight=fw) |
|
|
| ax0.set_xticks(range(n)) |
| ax0.set_yticks(range(n)) |
| ax0.set_xticklabels(labels, rotation=45, ha="right") |
| ax0.set_yticklabels(labels) |
| ax0.set_title(f"Co-occurrence ({level} count)", fontsize=8, pad=6) |
|
|
| ax0.set_xticks(np.arange(-0.5, n, 1), minor=True) |
| ax0.set_yticks(np.arange(-0.5, n, 1), minor=True) |
| ax0.grid(which="minor", color="white", linestyle="-", linewidth=0.5) |
| ax0.tick_params(which="minor", bottom=False, left=False) |
|
|
| cb = fig.colorbar(im, ax=ax0, fraction=0.046, pad=0.04) |
| cb.ax.tick_params(labelsize=6) |
|
|
| ax1 = fig.add_subplot(gs[1]) |
| ks = sorted(k for k in mult if k > 0) |
| if not ks: |
| ks = [0] |
| vals = [mult[k] for k in ks] |
| bars = ax1.bar(ks, vals, color="#3b528b", edgecolor="none", width=0.65) |
| ax1.set_xlabel(f"Distinct anomaly types per {level}", fontsize=7.5) |
| ax1.set_ylabel(f"Number of {level}s", fontsize=7.5) |
| ax1.set_title(f"Anomaly multiplicity (total {sum(vals)})", fontsize=8, pad=6) |
| ax1.set_xticks(ks) |
| ax1.grid(axis="y", linestyle=":", alpha=0.5, linewidth=0.5) |
| ax1.set_axisbelow(True) |
|
|
| for b in bars: |
| h = b.get_height() |
| if h > 0: |
| ax1.text(b.get_x() + b.get_width() / 2, h + max(vals) * 0.015, |
| str(h), ha="center", va="bottom", fontsize=6) |
| if vals: |
| ax1.set_ylim(0, max(vals) * 1.15) |
|
|
| for ext in ("png", "pdf"): |
| fig.savefig(f"{out_stem}.{ext}", bbox_inches="tight") |
| plt.close(fig) |
| print(f"wrote {out_stem}.png and {out_stem}.pdf") |
|
|
|
|
| def default_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 default_out_stem(): |
| if Path("checkpoint_data").is_dir(): |
| return "checkpoint_data/fig_cooccurrence" |
| if (Path(__file__).resolve().parent.parent / "checkpoint_data").is_dir(): |
| return str(Path(__file__).resolve().parent.parent / "checkpoint_data" / "fig_cooccurrence") |
| return "./fig_cooccurrence" |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser(description=__doc__, |
| formatter_class=argparse.RawDescriptionHelpFormatter) |
| p.add_argument("paths", nargs="*", default=None, |
| help="annotation files or folders to scan (auto-detected if omitted)") |
| p.add_argument("--root", nargs="+", default=None, |
| help="directories to search recursively for --pattern") |
| p.add_argument("--pattern", default="annotations*.coco.json") |
| p.add_argument("--keep-supercat", default=None) |
| p.add_argument("--drop-supercat", default="box") |
| p.add_argument("--drop", default="", help="comma-separated category names to drop") |
| p.add_argument("--keep", default="", help="comma-separated category names to keep") |
| p.add_argument("--min-area", type=float, default=0) |
| p.add_argument("--subset", default=None) |
| p.add_argument("--expect", type=int, default=0) |
| p.add_argument("--level", choices=("image", "scene"), default="image") |
| p.add_argument("--out", default=None, help="output file stem") |
| a = p.parse_args() |
|
|
| files = [] |
| if a.paths: |
| for item in a.paths: |
| path = Path(item) |
| if path.is_file(): |
| files.append(str(path)) |
| elif path.is_dir(): |
| files.extend(str(q) for q in path.rglob(a.pattern)) |
| elif a.root: |
| for r in a.root: |
| files.extend(str(q) for q in Path(r).rglob(a.pattern)) |
| else: |
| for r in default_search(): |
| files.extend(str(q) for q in Path(r).rglob(a.pattern)) |
|
|
| files = sorted(set(files), key=sort_key) |
| if not files: |
| sys.exit("no annotation files found") |
|
|
| labels = scene_labels(files) |
| print(f"Found {len(files)} annotation file(s):") |
| for f in files: |
| print(f" {labels[f]:<35} -> {f}") |
|
|
| drop_names = {x.strip() for x in a.drop.split(",") if x.strip()} |
| keep_names = {x.strip() for x in a.keep.split(",") if x.strip()} |
| drop_supercat = {x.strip() for x in a.drop_supercat.split(",") if x.strip()} |
|
|
| all_supercat = set() |
| for f in files: |
| with open(f, "r", encoding="utf-8") as fp: |
| data = json.load(fp) |
| for c in data.get("categories", []): |
| all_supercat.add(str(c.get("supercategory", "")).strip()) |
|
|
| if a.keep_supercat: |
| keep_supercat = {x.strip() for x in a.keep_supercat.split(",") if x.strip()} |
| else: |
| keep_supercat = all_supercat - drop_supercat |
|
|
| out_stem = a.out if a.out is not None else default_out_stem() |
| Path(out_stem).parent.mkdir(parents=True, exist_ok=True) |
|
|
| audit = {"supercat": defaultdict(set), "excluded": {}, "tiny": 0} |
| per_unit, meta = {}, {} |
| for f in files: |
| pu, mt = load_scene(f, labels[f], a.level, keep_supercat, drop_names, |
| keep_names, a.subset, a.min_area, audit) |
| for k, v in pu.items(): |
| per_unit.setdefault(k, set()).update(v) |
| meta.update(mt) |
|
|
| categories = sorted({t for s in per_unit.values() for t in s}) |
| if not categories: |
| sys.exit("no categories left after exclusion") |
| M, mult = build_counts(per_unit, categories) |
|
|
| with open(f"{out_stem}_counts.csv", "w", encoding="utf-8") as f: |
| f.write("," + ",".join(categories) + "\n") |
| for i, c in enumerate(categories): |
| f.write(c + "," + ",".join(str(v) for v in M[i]) + "\n") |
| print(f"wrote {out_stem}_counts.csv") |
|
|
| plot(M, categories, mult, out_stem, a.level) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
