| |
| """ |
| 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, |
| }) |
|
|
| |
| COLORS = { |
| "yellow": "#48c16e80", |
| "teal": "#1e9c8980", |
| "purple": "#eae51a80", |
| "PASTEL_PURPLE": "#48237480", |
| } |
|
|
| |
| PAPER_SEQUENTIAL = LinearSegmentedColormap.from_list( |
| "paper_sequential", |
| [COLORS["PASTEL_PURPLE"], COLORS["teal"], COLORS["yellow"], COLORS["purple"]], |
| N=256, |
| ) |
| |
| 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") |
|
|
| |
| DROP_SUPERCATEGORIES = {"box"} |
| DROP_NAMES = {"box", "permanent_mortise"} |
| FORCE_KEEP_NAMES = {"nuisance_dent"} |
| ANOMALOUS_SPLITS = {"anomaly", "anomalous", "test_bad", "bad", "defect"} |
|
|
|
|
| |
| |
| |
| 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) |
|
|
|
|
| |
| |
| |
| 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 |
|
|
|
|
| |
| |
| |
| 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 |
|
|
|
|
| |
| |
| |
| 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])) |
|
|
|
|
| |
| |
| |
| 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() |
|
|
