""" Combined analysis of good, worn, and SSM-reconstructed teeth. Loads corresponded point clouds for good and worn teeth, plus the SSM reconstruction outputs, and visualises all three groups in: - PCA space (scree, 2-D, 3-D) - t-SNE from leading PCs - t-SNE from raw 300 k-D feature vectors - UMAP from leading PCs - UMAP from raw 300 k-D feature vectors - Distance bar chart (worn vs. reconstructed, relative to good centroid) PCA is fit on good teeth only; worn and reconstructed are projected in. Usage: python all_teeth_analysis.py python all_teeth_analysis.py --correspondence-dir ../ssm_pipeline/output/correspondence_all_100k python all_teeth_analysis.py --extra-recon-dir ../ssm_pipeline/output/recon_local_t14/reconstructions python all_teeth_analysis.py --no-arrows # cleaner PCA 2-D plot python all_teeth_analysis.py --no-tsne # skip t-SNE plots python all_teeth_analysis.py --no-umap # skip UMAP plots python all_teeth_analysis.py --tsne-perplexity 10 python all_teeth_analysis.py --umap-n-neighbors 10 --umap-min-dist 0.3 """ import matplotlib matplotlib.use("Agg") import argparse import os import re import sys from glob import glob import matplotlib.pyplot as plt import numpy as np import trimesh from matplotlib.lines import Line2D from mpl_toolkits.mplot3d import Axes3D # noqa: F401 from sklearn.cluster import KMeans from sklearn.decomposition import PCA from sklearn.manifold import TSNE from tqdm import tqdm HAS_UMAP = False try: from umap import UMAP HAS_UMAP = True except ImportError: pass SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) PROJECT_DIR = os.path.dirname(SCRIPT_DIR) PLOT_DIR = os.path.join(SCRIPT_DIR, "plots_v2") DEFAULT_CORR_BASE = os.path.join( PROJECT_DIR, "ssm_pipeline", "output", "correspondence_all_100k" ) RECON_DIR = os.path.join( PROJECT_DIR, "ssm_pipeline", "output", "recon_neighborhood_v4", "reconstructions" ) # ── Style definitions ───────────────────────────────────────────── ORIGINAL_DIR = os.path.join(PROJECT_DIR, "Original models") ORIGINAL_MAP = { "cprc_nyu_n0245_ULM3_EDJ.ply": "TEST1", "cprc_nyu_n0257_ULM3_EDJ.ply": "TEST2", } ORIGINAL_CORR_MAP = { "original_TEST1": ("n0245", "TEST1"), "original_TEST2": ("n0257", "TEST2"), } STYLE = { "Good": {"color": "#4C72B0", "marker": "o", "size": 120}, "Original": {"color": "#E5A030", "marker": "p", "size": 160}, "Real worn": {"color": "#C44E52", "marker": "^", "size": 110}, "TEST1": {"color": "#55A868", "marker": "D", "size": 100}, "TEST2": {"color": "#8172B2", "marker": "s", "size": 100}, "Recon (Real)": {"color": "#E8868B", "marker": "*", "size": 160}, "Recon (TEST1)": {"color": "#8FCC99", "marker": "*", "size": 160}, "Recon (TEST2)": {"color": "#B3A8D8", "marker": "*", "size": 160}, # Local-mean / alternate reconstructions (e.g. recon_local_t14) "Recon local (Real)": {"color": "#DD8452", "marker": "X", "size": 140}, "Recon local (TEST1)": {"color": "#6BAF7A", "marker": "X", "size": 140}, "Recon local (TEST2)": {"color": "#9B8FC9", "marker": "X", "size": 140}, # GPMM posterior shape-completion reconstructions "Recon GPMM (Real)": {"color": "#2A9D8F", "marker": "P", "size": 150}, "Recon GPMM (TEST1)": {"color": "#52B69A", "marker": "P", "size": 150}, "Recon GPMM (TEST2)": {"color": "#168AAD", "marker": "P", "size": 150}, } WORN_TO_RECON_COLOR = { "Real worn": "Recon (Real)", "TEST1": "Recon (TEST1)", "TEST2": "Recon (TEST2)", } WORN_TO_LOCAL_RECON_COLOR = { "Real worn": "Recon local (Real)", "TEST1": "Recon local (TEST1)", "TEST2": "Recon local (TEST2)", } WORN_TO_GPMM_RECON_COLOR = { "Real worn": "Recon GPMM (Real)", "TEST1": "Recon GPMM (TEST1)", "TEST2": "Recon GPMM (TEST2)", } # ── Helpers ─────────────────────────────────────────────────────── def _load_ply(path: str) -> np.ndarray: pc = trimesh.load(path, process=False) return np.asarray( pc.vertices if hasattr(pc, "vertices") else pc, dtype=np.float64 ) def _normalize(points: np.ndarray) -> np.ndarray: centroid = points.mean(axis=0) centered = points - centroid _, _, Vt = np.linalg.svd(centered, full_matrices=False) rotated = centered @ Vt.T for ax in range(3): if np.sum(rotated[:, ax] > 0) < len(rotated) // 2: rotated[:, ax] *= -1 diag = rotated.max(axis=0) - rotated.min(axis=0) scale = np.linalg.norm(diag) if scale > 0: rotated /= scale return rotated def _icp_align(source: np.ndarray, target: np.ndarray, max_iter: int = 100, tol: float = 1e-6) -> np.ndarray: from scipy.spatial import cKDTree src = source.copy() tree = cKDTree(target) prev_err = np.inf for _ in range(max_iter): dists, idx = tree.query(src) corr = target[idx] src_c = src.mean(axis=0) corr_c = corr.mean(axis=0) H = (src - src_c).T @ (corr - corr_c) U, _, Vt = np.linalg.svd(H) R = Vt.T @ U.T if np.linalg.det(R) < 0: Vt[-1, :] *= -1 R = Vt.T @ U.T t = corr_c - R @ src_c src = (R @ src.T).T + t err = float(np.mean(dists)) if abs(prev_err - err) < tol: break prev_err = err return src def load_originals_corresponded(corr_orig_dir): """Load corresponded original teeth (preferred -- exact same pipeline as all others).""" orig_clouds, orig_labels, orig_test_group = [], [], [] for dirname, (label, test_name) in sorted(ORIGINAL_CORR_MAP.items()): ply = os.path.join(corr_orig_dir, dirname, "corresponded.ply") if not os.path.exists(ply): continue orig_clouds.append(_load_ply(ply)) orig_labels.append(label) orig_test_group.append(test_name) print(f" Loaded corresponded {dirname} -> {label} ({test_name})") return orig_clouds, orig_labels, orig_test_group def load_originals_raw(original_dir, template_cloud, n_points=100000, seed=42): """Fallback: load raw meshes, sample, normalize, ICP-align (no CPD correspondence).""" orig_clouds, orig_labels, orig_test_group = [], [], [] for fname, test_name in sorted(ORIGINAL_MAP.items()): fpath = os.path.join(original_dir, fname) if not os.path.exists(fpath): print(f" [SKIP original] {fname} -- not found") continue mesh = trimesh.load(fpath, force="mesh", process=False) pts, _ = trimesh.sample.sample_surface(mesh, n_points, seed=seed) pts = np.asarray(pts, dtype=np.float64) pts = _normalize(pts) pts = _icp_align(pts, template_cloud) orig_clouds.append(pts) m = re.search(r"n(\d+)", fname) orig_labels.append(f"n{m.group(1)}" if m else fname[:12]) orig_test_group.append(test_name) print(f" Loaded raw original {fname} -> {orig_labels[-1]} ({test_name})") return orig_clouds, orig_labels, orig_test_group def classify_worn_dir(dirname: str): if "TEST1" in dirname: m = re.search(r"level(\d+)", dirname) return "TEST1", int(m.group(1)) if m else 0 if "TEST2" in dirname: m = re.search(r"level(\d+)", dirname) return "TEST2", int(m.group(1)) if m else 0 if re.match(r"tooth_.+_original$", dirname): return "Original", -1 return "Real worn", 0 def worn_dir_label(dirname: str) -> str: """Per-directory short label. Handles three naming schemes seen across datasets: old real-worn (tooth_01_wear_real), TEST1/TEST2 (tooth_TEST1_wear_levelN), and v5 (tooth__wear_levelN / tooth__original) -- the v5 scheme previously fell through to a blind dirname[:12] truncation that dropped the wear-level number entirely, making every level of a tooth share one label.""" if "TEST1" in dirname: m = re.search(r"level(\d+)", dirname) return f"T1_L{m.group(1)}" if m else "TEST1" if "TEST2" in dirname: m = re.search(r"level(\d+)", dirname) return f"T2_L{m.group(1)}" if m else "TEST2" m = re.match(r"tooth_(.+)_wear_level(\d+)$", dirname) if m: return f"{m.group(1)}_L{m.group(2)}" m = re.match(r"tooth_(.+)_original$", dirname) if m: return f"{m.group(1)}_orig" m = re.match(r"tooth_(\d+)_wear_real$", dirname) if m: return f"T{m.group(1)}_w" m = re.match(r"tooth_(\d+)$", dirname) if m: return f"T{m.group(1)}_w" return dirname[:12] def recon_label_from_worn(worn_label: str) -> str: """Same naming as global recon in load_all (star / triangle pairs in plots).""" if "_L" not in worn_label: return worn_label.replace("_w", "_r").replace("_L", "r_L") return worn_label + "r" def local_recon_label_from_worn(worn_label: str) -> str: """Distinct annotation for local-mean (or other alternate) reconstructions.""" return recon_label_from_worn(worn_label) + "L" def gpmm_recon_label_from_worn(worn_label: str) -> str: """Distinct annotation for GPMM posterior reconstructions.""" return recon_label_from_worn(worn_label) + "G" # ── Loading ─────────────────────────────────────────────────────── def load_all(corr_good_dir, corr_worn_dir, recon_dir): """Return good/worn/recon clouds, metadata, and worn_keys (folder names).""" # Good teeth good_dirs = sorted(glob(os.path.join(corr_good_dir, "tooth_*"))) good_files, good_labels = [], [] for td in good_dirs: ply = os.path.join(td, "corresponded.ply") if os.path.exists(ply): good_files.append(ply) good_labels.append(os.path.basename(td).replace("tooth_", "T")) # Worn teeth worn_dirs = sorted(glob(os.path.join(corr_worn_dir, "tooth_*"))) worn_files, worn_labels, worn_groups, worn_keys = [], [], [], [] for td in worn_dirs: ply = os.path.join(td, "corresponded.ply") if os.path.exists(ply): dname = os.path.basename(td) worn_files.append(ply) worn_labels.append(worn_dir_label(dname)) worn_groups.append(classify_worn_dir(dname)) worn_keys.append(dname) # Reconstructed teeth (matched by directory name) recon_files, recon_labels, recon_groups = [], [], [] matched_worn_idx = [] for wi, key in enumerate(worn_keys): rply = os.path.join(recon_dir, key, "reconstructed.ply") if os.path.exists(rply): recon_files.append(rply) recon_labels.append(recon_label_from_worn(worn_labels[wi])) recon_groups.append(worn_groups[wi]) matched_worn_idx.append(wi) else: print(f" [SKIP recon] {key} -- no reconstructed.ply") # Load point clouds good_clouds = [_load_ply(f) for f in tqdm(good_files, desc="Loading good teeth")] worn_clouds = [_load_ply(f) for f in tqdm(worn_files, desc="Loading worn teeth")] recon_clouds = [_load_ply(f) for f in tqdm(recon_files, desc="Loading reconstructed")] return (good_clouds, good_labels, worn_clouds, worn_labels, worn_groups, recon_clouds, recon_labels, recon_groups, matched_worn_idx, worn_keys) def load_extra_reconstructions(extra_recon_dir, worn_keys, worn_labels, worn_groups, label_fn=local_recon_label_from_worn, tag="extra"): """ Load alternate reconstructions (e.g. local-mean SSM, GPMM) keyed by the same artificial_worn directory names as the primary recon set. """ if not extra_recon_dir or not os.path.isdir(extra_recon_dir): return [], [], [], [] extra_files, extra_labels, extra_groups, extra_wi = [], [], [], [] for wi, key in enumerate(worn_keys): rply = os.path.join(extra_recon_dir, key, "reconstructed.ply") if not os.path.exists(rply): continue extra_files.append(rply) extra_labels.append(label_fn(worn_labels[wi])) extra_groups.append(worn_groups[wi]) extra_wi.append(wi) print(f" [{tag} recon] {key} -> {extra_labels[-1]}") if not extra_files: return [], [], [], [] extra_clouds = [_load_ply(f) for f in tqdm(extra_files, desc=f"Loading {tag} recon")] return extra_clouds, extra_labels, extra_groups, extra_wi # ── Plotting helpers ────────────────────────────────────────────── def _legend_handles(include_recon=True, include_original=True, include_local_recon=False, include_gpmm_recon=False): keys = ["Good"] if include_original: keys.append("Original") keys += ["Real worn", "TEST1", "TEST2"] if include_recon: keys += ["Recon (Real)", "Recon (TEST1)", "Recon (TEST2)"] if include_local_recon: keys += ["Recon local (Real)", "Recon local (TEST1)", "Recon local (TEST2)"] if include_gpmm_recon: keys += ["Recon GPMM (Real)", "Recon GPMM (TEST1)", "Recon GPMM (TEST2)"] return [ Line2D([0], [0], marker=STYLE[k]["marker"], color="w", markerfacecolor=STYLE[k]["color"], markersize=10, markeredgecolor="k", label=k) for k in keys ] def _plot_paired_distance(worn_2d, recon_2d, worn_labels, worn_groups, matched_worn_idx, filename, title, ax_label): """Bar chart: Euclidean distance from each reconstructed tooth to its worn counterpart.""" n_pairs = len(matched_worn_idx) dists = np.array([ np.linalg.norm(recon_2d[ri] - worn_2d[matched_worn_idx[ri]]) for ri in range(n_pairs) ]) labels = [worn_labels[matched_worn_idx[ri]] for ri in range(n_pairs)] colors = [STYLE[worn_groups[matched_worn_idx[ri]][0]]["color"] for ri in range(n_pairs)] sort_idx = np.argsort(dists)[::-1] fig, ax = plt.subplots(figsize=(11, max(5, n_pairs * 0.32))) y_pos = range(len(sort_idx)) ax.barh(y_pos, dists[sort_idx], color=[colors[i] for i in sort_idx], edgecolor="k", linewidth=0.4) ax.set_yticks(y_pos) ax.set_yticklabels([labels[i] for i in sort_idx], fontsize=8) ax.set_xlabel(f"Euclidean Distance ({ax_label})", fontsize=11) ax.set_title(title, fontsize=13) ax.invert_yaxis() legend_bar = [ Line2D([0], [0], color=STYLE[k]["color"], linewidth=8, label=k) for k in ["Real worn", "TEST1", "TEST2"] ] ax.legend(handles=legend_bar, fontsize=9, loc="lower right") ax.grid(True, axis="x", alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, filename), dpi=200) plt.close(fig) print(f"Saved {filename}") return dists, labels def _scatter_group(ax, pts_2d, labels, group_key, annotate=True, fontsize=7, text_offset=(6, 6)): s = STYLE[group_key] ax.scatter(pts_2d[:, 0], pts_2d[:, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=4 if group_key == "Good" else 3) if annotate: for i, lbl in enumerate(labels): ax.annotate(lbl, (pts_2d[i, 0], pts_2d[i, 1]), textcoords="offset points", xytext=text_offset, fontsize=fontsize, color=s["color"]) def _scatter_extra_recons_2d(ax, sc_extra, extra_labels, extra_groups, fontsize=5, text_offset=(6, -10), style_map=WORN_TO_LOCAL_RECON_COLOR): for ei in range(len(sc_extra)): grp = extra_groups[ei][0] rkey = style_map[grp] s = STYLE[rkey] ax.scatter(sc_extra[ei, 0], sc_extra[ei, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(extra_labels[ei], (sc_extra[ei, 0], sc_extra[ei, 1]), textcoords="offset points", xytext=text_offset, fontsize=fontsize, color=s["color"]) def _scatter_extra_recons_3d(ax3, sc_extra, extra_groups, style_map=WORN_TO_LOCAL_RECON_COLOR): for ei in range(len(sc_extra)): grp = extra_groups[ei][0] rkey = style_map[grp] rs = STYLE[rkey] ax3.scatter(sc_extra[ei, 0], sc_extra[ei, 1], sc_extra[ei, 2], c=rs["color"], marker=rs["marker"], s=rs["size"], edgecolors="k", linewidths=0.3, depthshade=True) # ── Main ────────────────────────────────────────────────────────── def main(): parser = argparse.ArgumentParser( description="Combined PCA / t-SNE analysis of good, worn, and reconstructed teeth") parser.add_argument("--correspondence-dir", type=str, default=DEFAULT_CORR_BASE, help="Correspondence output root (good_teeth/, artificial_worn/)") parser.add_argument("--recon-dir", type=str, default=RECON_DIR, help="Path to reconstruction output directory") parser.add_argument("--extra-recon-dir", type=str, default=None, help="Optional second recon root (e.g. .../recon_local_t14/reconstructions). " "Same folder names as primary recon; plotted as orange X markers " "(labels end with L, e.g. T03_rL).") parser.add_argument("--gpmm-recon-dir", type=str, default=None, help="Optional GPMM posterior recon root (e.g. .../recon_gpmm/reconstructions). " "Same folder names as primary recon; plotted as teal plus markers " "(labels end with G, e.g. T03_rG).") parser.add_argument("--seed", type=int, default=42) parser.add_argument("--no-tsne", action="store_true", help="Skip t-SNE plots") parser.add_argument("--tsne-perplexity", type=float, default=30.0, help="t-SNE perplexity (clamped to n_samples-1)") parser.add_argument("--tsne-pc-dims", type=int, default=10, help="Number of leading PCs to feed t-SNE (default 10)") parser.add_argument("--no-umap", action="store_true", help="Skip UMAP plots") parser.add_argument("--umap-n-neighbors", type=int, default=15, help="UMAP n_neighbors (default 15)") parser.add_argument("--umap-min-dist", type=float, default=0.1, help="UMAP min_dist (default 0.1)") parser.add_argument("--no-arrows", action="store_true", help="Skip worn->recon arrows on PCA 2-D plot") parser.add_argument("--n-clusters", type=int, default=2, help="K-Means clusters to split the PCA 2-D plot into (default 2)") parser.add_argument("--no-cluster-split", action="store_true", help="Skip the cluster-split PCA 2-D plot") parser.add_argument("--no-test-only", action="store_true", help="Skip the TEST1/TEST2-only PCA 2-D plot") args = parser.parse_args() os.makedirs(PLOT_DIR, exist_ok=True) corr_base = os.path.abspath(args.correspondence_dir) corr_good_dir = os.path.join(corr_base, "good_teeth") corr_worn_dir = os.path.join(corr_base, "artificial_worn") corr_orig_dir = os.path.join(corr_base, "originals") # ── Load data ───────────────────────────────────────────────── print(f"Correspondence dir : {corr_base}") print(f"Reconstruction dir : {args.recon_dir}") if not os.path.isdir(corr_good_dir): sys.exit(f"Good-teeth correspondence dir not found: {corr_good_dir}") (good_clouds, good_labels, worn_clouds, worn_labels, worn_groups, recon_clouds, recon_labels, recon_groups, matched_worn_idx, worn_keys) = load_all(corr_good_dir, corr_worn_dir, args.recon_dir) extra_recon_dir = args.extra_recon_dir if extra_recon_dir: extra_recon_dir = os.path.abspath(extra_recon_dir) print(f"Extra reconstruction dir : {extra_recon_dir}") extra_clouds, extra_labels, extra_groups, extra_wi = load_extra_reconstructions( extra_recon_dir, worn_keys, worn_labels, worn_groups, label_fn=local_recon_label_from_worn, tag="local") gpmm_recon_dir = args.gpmm_recon_dir if gpmm_recon_dir: gpmm_recon_dir = os.path.abspath(gpmm_recon_dir) print(f"GPMM reconstruction dir : {gpmm_recon_dir}") gpmm_clouds, gpmm_labels, gpmm_groups, gpmm_wi = load_extra_reconstructions( gpmm_recon_dir, worn_keys, worn_labels, worn_groups, label_fn=gpmm_recon_label_from_worn, tag="gpmm") n_good = len(good_clouds) n_worn = len(worn_clouds) n_recon = len(recon_clouds) n_extra = len(extra_clouds) n_gpmm = len(gpmm_clouds) n_pts = good_clouds[0].shape[0] print(f"\nGood teeth : {n_good} ({n_pts} pts each)") print(f"Worn teeth : {n_worn} " f"({sum(1 for g, _ in worn_groups if g == 'Real worn')} real, " f"{sum(1 for g, _ in worn_groups if g == 'TEST1')} TEST1, " f"{sum(1 for g, _ in worn_groups if g == 'TEST2')} TEST2)") print(f"Reconstructed : {n_recon}") if n_extra: print(f"Extra (local) reconstructions : {n_extra}") if n_gpmm: print(f"GPMM reconstructions : {n_gpmm}") # Load original (unworn) teeth for TEST1/TEST2 # Prefer corresponded outputs; fall back to raw mesh + ICP if os.path.isdir(corr_orig_dir): print(f"\nLoading corresponded originals from: {corr_orig_dir}") orig_clouds, orig_labels, orig_test_group = load_originals_corresponded(corr_orig_dir) else: orig_clouds, orig_labels, orig_test_group = [], [], [] if not orig_clouds: template_cloud = good_clouds[0] print(f" No corresponded originals found -- falling back to raw meshes + ICP") print(f" (Run ssm_pipeline/correspond_originals.py first for exact results)") orig_clouds, orig_labels, orig_test_group = load_originals_raw( ORIGINAL_DIR, template_cloud, n_points=n_pts, seed=args.seed) n_orig = len(orig_clouds) print(f"Originals : {n_orig}") if n_good < 3: sys.exit("Need at least 3 good teeth for PCA") # Feature matrices X_good = np.array([c.flatten() for c in good_clouds]) X_worn = np.array([c.flatten() for c in worn_clouds]) X_recon = np.array([c.flatten() for c in recon_clouds]) X_extra = np.array([c.flatten() for c in extra_clouds]) if n_extra else np.empty((0, X_good.shape[1])) X_gpmm = np.array([c.flatten() for c in gpmm_clouds]) if n_gpmm else np.empty((0, X_good.shape[1])) X_orig = np.array([c.flatten() for c in orig_clouds]) if n_orig > 0 else np.empty((0, X_good.shape[1])) # ── PCA (fit on good, project worn + recon + originals) ─────── n_comp = min(n_good - 1, 10) pca = PCA(n_components=n_comp) sc_good = pca.fit_transform(X_good) sc_worn = pca.transform(X_worn) sc_recon = pca.transform(X_recon) sc_extra = pca.transform(X_extra) if n_extra else np.empty((0, n_comp)) sc_gpmm = pca.transform(X_gpmm) if n_gpmm else np.empty((0, n_comp)) sc_orig = pca.transform(X_orig) if n_orig > 0 else np.empty((0, n_comp)) var_ratio = pca.explained_variance_ratio_ cum_var = np.cumsum(var_ratio) print(f"\nPCA on {n_good} good teeth ({n_comp} components):") for i in range(min(8, n_comp)): print(f" PC{i+1}: {var_ratio[i]*100:6.2f}% (cumulative {cum_var[i]*100:6.2f}%)") # ── Plot 1: Scree ───────────────────────────────────────────── fig, ax1 = plt.subplots(figsize=(8, 5)) pcs = np.arange(1, len(var_ratio) + 1) ax1.bar(pcs, var_ratio * 100, color="#4C72B0", alpha=0.8, label="Individual") ax1.set_xlabel("Principal Component", fontsize=12) ax1.set_ylabel("Variance Explained (%)", fontsize=12) ax1.set_xticks(pcs) ax2 = ax1.twinx() ax2.plot(pcs, cum_var * 100, "o-", color="#C44E52", linewidth=2, label="Cumulative") ax2.set_ylabel("Cumulative Variance (%)", fontsize=12) ax2.set_ylim(0, 105) h1, l1 = ax1.get_legend_handles_labels() h2, l2 = ax2.get_legend_handles_labels() ax1.legend(h1 + h2, l1 + l2, loc="center right", fontsize=10) ax1.set_title(f"PCA Scree Plot ({n_good} Good Teeth)", fontsize=14) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_scree.png"), dpi=200) plt.close(fig) print("Saved all_teeth_scree.png") # ── Plot 2: PCA 2-D (PC1 vs PC2) ───────────────────────────── fig, ax = plt.subplots(figsize=(13, 9)) # Good _scatter_group(ax, sc_good[:, :2], good_labels, "Good") # Worn for wi in range(n_worn): grp = worn_groups[wi][0] s = STYLE[grp] ax.scatter(sc_worn[wi, 0], sc_worn[wi, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[wi], (sc_worn[wi, 0], sc_worn[wi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=s["color"]) # Reconstructed for ri in range(n_recon): grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] s = STYLE[rkey] ax.scatter(sc_recon[ri, 0], sc_recon[ri, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(recon_labels[ri], (sc_recon[ri, 0], sc_recon[ri, 1]), textcoords="offset points", xytext=(6, 6), fontsize=5, color=s["color"]) if n_extra: _scatter_extra_recons_2d(ax, sc_extra[:, :2], extra_labels, extra_groups) if n_gpmm: _scatter_extra_recons_2d(ax, sc_gpmm[:, :2], gpmm_labels, gpmm_groups, style_map=WORN_TO_GPMM_RECON_COLOR) # Originals if n_orig > 0: _scatter_group(ax, sc_orig[:, :2], orig_labels, "Original", fontsize=8, text_offset=(6, 8)) # Arrows worn -> recon if not args.no_arrows: for ri, wi in enumerate(matched_worn_idx): grp = worn_groups[wi][0] ax.annotate("", xy=(sc_recon[ri, 0], sc_recon[ri, 1]), xytext=(sc_worn[wi, 0], sc_worn[wi, 1]), arrowprops=dict(arrowstyle="->", color=STYLE[grp]["color"], lw=1.0, linestyle="--", alpha=0.6)) for ei, wi in enumerate(extra_wi): grp = worn_groups[wi][0] ax.annotate("", xy=(sc_extra[ei, 0], sc_extra[ei, 1]), xytext=(sc_worn[wi, 0], sc_worn[wi, 1]), arrowprops=dict(arrowstyle="->", color=STYLE[grp]["color"], lw=1.2, linestyle=":", alpha=0.75)) for gi, wi in enumerate(gpmm_wi): grp = worn_groups[wi][0] ax.annotate("", xy=(sc_gpmm[gi, 0], sc_gpmm[gi, 1]), xytext=(sc_worn[wi, 0], sc_worn[wi, 1]), arrowprops=dict(arrowstyle="->", color=STYLE[grp]["color"], lw=1.2, linestyle="-.", alpha=0.75)) ax.legend(handles=_legend_handles(include_local_recon=n_extra > 0, include_gpmm_recon=n_gpmm > 0), fontsize=9, loc="best") ax.set_xlabel(f"PC1 ({var_ratio[0]*100:.1f}%)", fontsize=12) ax.set_ylabel(f"PC2 ({var_ratio[1]*100:.1f}%)", fontsize=12) ax.set_title("Good + Worn + Reconstructed + Originals (PC1 vs PC2)", fontsize=14) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_pca_2d.png"), dpi=200) plt.close(fig) print("Saved all_teeth_pca_2d.png") # ── Plot 2b: Cluster-split PCA 2-D (K-Means on Good teeth) ─── if not args.no_cluster_split and n_good >= args.n_clusters: km = KMeans(n_clusters=args.n_clusters, random_state=args.seed, n_init=10) good_cluster = km.fit_predict(sc_good[:, :2]) centroids = km.cluster_centers_ def _assign_cluster(pts_2d): if len(pts_2d) == 0: return np.empty(0, dtype=int) dists = np.linalg.norm(pts_2d[:, None, :] - centroids[None, :, :], axis=2) return dists.argmin(axis=1) worn_cluster = _assign_cluster(sc_worn[:, :2]) recon_cluster = _assign_cluster(sc_recon[:, :2]) extra_cluster = _assign_cluster(sc_extra[:, :2]) if n_extra else np.empty(0, dtype=int) gpmm_cluster = _assign_cluster(sc_gpmm[:, :2]) if n_gpmm else np.empty(0, dtype=int) orig_cluster = _assign_cluster(sc_orig[:, :2]) if n_orig else np.empty(0, dtype=int) n_c = args.n_clusters fig, axes = plt.subplots(1, n_c, figsize=(10 * n_c, 9)) if n_c == 1: axes = [axes] for c in range(n_c): ax = axes[c] gmask = good_cluster == c g_idx = np.where(gmask)[0] _scatter_group(ax, sc_good[g_idx][:, :2], [good_labels[i] for i in g_idx], "Good") for wi in np.where(worn_cluster == c)[0]: grp = worn_groups[wi][0] s = STYLE[grp] ax.scatter(sc_worn[wi, 0], sc_worn[wi, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[wi], (sc_worn[wi, 0], sc_worn[wi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=s["color"]) for ri in np.where(recon_cluster == c)[0]: grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] s = STYLE[rkey] ax.scatter(sc_recon[ri, 0], sc_recon[ri, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(recon_labels[ri], (sc_recon[ri, 0], sc_recon[ri, 1]), textcoords="offset points", xytext=(6, 6), fontsize=5, color=s["color"]) if n_extra: ei_idx = np.where(extra_cluster == c)[0] if len(ei_idx): _scatter_extra_recons_2d( ax, sc_extra[ei_idx][:, :2], [extra_labels[i] for i in ei_idx], [extra_groups[i] for i in ei_idx]) if n_gpmm: gi_idx = np.where(gpmm_cluster == c)[0] if len(gi_idx): _scatter_extra_recons_2d( ax, sc_gpmm[gi_idx][:, :2], [gpmm_labels[i] for i in gi_idx], [gpmm_groups[i] for i in gi_idx], style_map=WORN_TO_GPMM_RECON_COLOR) if n_orig: oi_idx = np.where(orig_cluster == c)[0] if len(oi_idx): _scatter_group(ax, sc_orig[oi_idx][:, :2], [orig_labels[i] for i in oi_idx], "Original", fontsize=8, text_offset=(6, 8)) ax.set_xlabel(f"PC1 ({var_ratio[0]*100:.1f}%)", fontsize=11) ax.set_ylabel(f"PC2 ({var_ratio[1]*100:.1f}%)", fontsize=11) ax.set_title(f"Cluster {c+1} ({gmask.sum()} good teeth)", fontsize=13) ax.grid(True, alpha=0.3) axes[0].legend(handles=_legend_handles(include_local_recon=n_extra > 0, include_gpmm_recon=n_gpmm > 0), fontsize=8, loc="best") fig.suptitle(f"PCA 2-D split by K-Means cluster (k={n_c}, fit on Good teeth)", fontsize=15) fig.tight_layout(rect=[0, 0, 1, 0.96]) fig.savefig(os.path.join(PLOT_DIR, "all_teeth_pca_2d_clusters.png"), dpi=200) plt.close(fig) print("Saved all_teeth_pca_2d_clusters.png") # ── Plot 2c: Test-set-only PCA 2-D (no Good teeth) ────────────── # "Test set" = TEST1/TEST2 if this dataset has them (old data: held-out # synthetic-wear cases, distinct from the 9 real production-worn teeth); # otherwise (v5 data) every worn/original entry already IS the held-out # specimen set, so fall back to "Real worn" + "Original". if not args.no_test_only: groups_present = {g[0] for g in worn_groups} if "TEST1" in groups_present or "TEST2" in groups_present: test_groups = {"TEST1", "TEST2", "Original"} else: test_groups = {"Real worn", "Original"} print(f"\nTest-only plot: groups = {sorted(test_groups)}") worn_mask = np.array([g[0] in test_groups for g in worn_groups]) recon_mask = np.array([g[0] in test_groups for g in recon_groups]) \ if n_recon else np.empty(0, dtype=bool) extra_mask = np.array([g[0] in test_groups for g in extra_groups]) \ if n_extra else np.empty(0, dtype=bool) gpmm_mask = np.array([g[0] in test_groups for g in gpmm_groups]) \ if n_gpmm else np.empty(0, dtype=bool) fig, ax = plt.subplots(figsize=(11, 8)) for wi in np.where(worn_mask)[0]: grp = worn_groups[wi][0] s = STYLE[grp] ax.scatter(sc_worn[wi, 0], sc_worn[wi, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[wi], (sc_worn[wi, 0], sc_worn[wi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=7, color=s["color"]) for ri in np.where(recon_mask)[0]: grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] s = STYLE[rkey] ax.scatter(sc_recon[ri, 0], sc_recon[ri, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(recon_labels[ri], (sc_recon[ri, 0], sc_recon[ri, 1]), textcoords="offset points", xytext=(6, 6), fontsize=6, color=s["color"]) if n_extra: ei_idx = np.where(extra_mask)[0] if len(ei_idx): _scatter_extra_recons_2d( ax, sc_extra[ei_idx][:, :2], [extra_labels[i] for i in ei_idx], [extra_groups[i] for i in ei_idx], fontsize=6, text_offset=(6, -10)) if n_gpmm: gi_idx = np.where(gpmm_mask)[0] if len(gi_idx): _scatter_extra_recons_2d( ax, sc_gpmm[gi_idx][:, :2], [gpmm_labels[i] for i in gi_idx], [gpmm_groups[i] for i in gi_idx], fontsize=6, text_offset=(6, -10), style_map=WORN_TO_GPMM_RECON_COLOR) if n_orig: _scatter_group(ax, sc_orig[:, :2], orig_labels, "Original", fontsize=10, text_offset=(8, 10)) if not args.no_arrows: for ri, wi in enumerate(matched_worn_idx): if ri < len(recon_mask) and not recon_mask[ri]: continue grp = worn_groups[wi][0] if grp not in test_groups: continue ax.annotate("", xy=(sc_recon[ri, 0], sc_recon[ri, 1]), xytext=(sc_worn[wi, 0], sc_worn[wi, 1]), arrowprops=dict(arrowstyle="->", color=STYLE[grp]["color"], lw=1.0, linestyle="--", alpha=0.6)) for ei, wi in enumerate(extra_wi): if ei < len(extra_mask) and not extra_mask[ei]: continue grp = worn_groups[wi][0] if grp not in test_groups: continue ax.annotate("", xy=(sc_extra[ei, 0], sc_extra[ei, 1]), xytext=(sc_worn[wi, 0], sc_worn[wi, 1]), arrowprops=dict(arrowstyle="->", color=STYLE[grp]["color"], lw=1.2, linestyle=":", alpha=0.75)) for gi, wi in enumerate(gpmm_wi): if gi < len(gpmm_mask) and not gpmm_mask[gi]: continue grp = worn_groups[wi][0] if grp not in test_groups: continue ax.annotate("", xy=(sc_gpmm[gi, 0], sc_gpmm[gi, 1]), xytext=(sc_worn[wi, 0], sc_worn[wi, 1]), arrowprops=dict(arrowstyle="->", color=STYLE[grp]["color"], lw=1.2, linestyle="-.", alpha=0.75)) legend_keys = ["Original"] if "Original" in test_groups else [] for g in ("Real worn", "TEST1", "TEST2"): if g in test_groups: legend_keys.append(g) for g in ("Real worn", "TEST1", "TEST2"): if g in test_groups: legend_keys.append(WORN_TO_RECON_COLOR[g]) if n_extra: for g in ("Real worn", "TEST1", "TEST2"): if g in test_groups: legend_keys.append(WORN_TO_LOCAL_RECON_COLOR[g]) if n_gpmm: for g in ("Real worn", "TEST1", "TEST2"): if g in test_groups: legend_keys.append(WORN_TO_GPMM_RECON_COLOR[g]) ax.legend(handles=[Line2D([0], [0], marker=STYLE[k]["marker"], color="w", markerfacecolor=STYLE[k]["color"], markersize=10, markeredgecolor="k", label=k) for k in legend_keys], fontsize=9, loc="best") ax.set_xlabel(f"PC1 ({var_ratio[0]*100:.1f}%)", fontsize=12) ax.set_ylabel(f"PC2 ({var_ratio[1]*100:.1f}%)", fontsize=12) ax.set_title("Test set only: Originals + Worn levels + Reconstructions (PC1 vs PC2)", fontsize=13) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_pca_2d_test_only.png"), dpi=200) plt.close(fig) print("Saved all_teeth_pca_2d_test_only.png") # Paired worn<->recon distance in PC1-PC2 _plot_paired_distance( sc_worn[:, :2], sc_recon[:, :2], worn_labels, worn_groups, matched_worn_idx, "paired_dist_pca_2d.png", "Worn-to-Recon Distance (PC1-PC2)", "PC1-PC2 space") if n_extra: _plot_paired_distance( sc_worn[:, :2], sc_extra[:, :2], worn_labels, worn_groups, extra_wi, "paired_dist_pca_2d_local.png", "Worn-to-Local-Recon Distance (PC1-PC2)", "PC1-PC2 space") if n_gpmm: _plot_paired_distance( sc_worn[:, :2], sc_gpmm[:, :2], worn_labels, worn_groups, gpmm_wi, "paired_dist_pca_2d_gpmm.png", "Worn-to-GPMM-Recon Distance (PC1-PC2)", "PC1-PC2 space") # ── Plot 3: PCA 3-D ────────────────────────────────────────── if n_comp >= 3: fig = plt.figure(figsize=(12, 9)) ax3 = fig.add_subplot(111, projection="3d") s = STYLE["Good"] ax3.scatter(sc_good[:, 0], sc_good[:, 1], sc_good[:, 2], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.4, depthshade=True) for i, lbl in enumerate(good_labels): ax3.text(sc_good[i, 0], sc_good[i, 1], sc_good[i, 2], f" {lbl}", fontsize=6, color=s["color"]) for wi in range(n_worn): grp = worn_groups[wi][0] ws = STYLE[grp] ax3.scatter(sc_worn[wi, 0], sc_worn[wi, 1], sc_worn[wi, 2], c=ws["color"], marker=ws["marker"], s=ws["size"], edgecolors="k", linewidths=0.3, depthshade=True) for ri in range(n_recon): grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] rs = STYLE[rkey] ax3.scatter(sc_recon[ri, 0], sc_recon[ri, 1], sc_recon[ri, 2], c=rs["color"], marker=rs["marker"], s=rs["size"], edgecolors="k", linewidths=0.3, depthshade=True) if n_extra: _scatter_extra_recons_3d(ax3, sc_extra[:, :3], extra_groups) if n_gpmm: _scatter_extra_recons_3d(ax3, sc_gpmm[:, :3], gpmm_groups, style_map=WORN_TO_GPMM_RECON_COLOR) if n_orig > 0: os_ = STYLE["Original"] ax3.scatter(sc_orig[:, 0], sc_orig[:, 1], sc_orig[:, 2], c=os_["color"], marker=os_["marker"], s=os_["size"], edgecolors="k", linewidths=0.4, depthshade=True) for i, lbl in enumerate(orig_labels): ax3.text(sc_orig[i, 0], sc_orig[i, 1], sc_orig[i, 2], f" {lbl}", fontsize=7, color=os_["color"]) ax3.legend(handles=_legend_handles(include_local_recon=n_extra > 0, include_gpmm_recon=n_gpmm > 0), fontsize=8, loc="upper left") ax3.set_xlabel(f"PC1 ({var_ratio[0]*100:.1f}%)") ax3.set_ylabel(f"PC2 ({var_ratio[1]*100:.1f}%)") ax3.set_zlabel(f"PC3 ({var_ratio[2]*100:.1f}%)") ax3.set_title("All Teeth (PC1-PC2-PC3)", fontsize=13) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_pca_3d.png"), dpi=200) plt.close(fig) print("Saved all_teeth_pca_3d.png") # ── t-SNE from PCs ──────────────────────────────────────────── n_all = n_good + n_worn + n_recon + n_extra + n_gpmm + n_orig if not args.no_tsne and n_all >= 3: d_tsne = min(max(2, args.tsne_pc_dims), n_comp) stack_parts = [sc_good[:, :d_tsne], sc_worn[:, :d_tsne], sc_recon[:, :d_tsne]] if n_extra: stack_parts.append(sc_extra[:, :d_tsne]) if n_gpmm: stack_parts.append(sc_gpmm[:, :d_tsne]) if n_orig > 0: stack_parts.append(sc_orig[:, :d_tsne]) X_stack = np.vstack(stack_parts) max_perp = max(2.0, float(n_all - 1) - 1e-6) perp = float(np.clip(args.tsne_perplexity, 2.0, max_perp)) print(f"\nRunning t-SNE on PCs ({n_all} specimens, dims={d_tsne}, " f"perplexity={perp:.1f})...") kw = dict(n_components=2, perplexity=perp, random_state=args.seed, init="pca") try: tsne = TSNE(**kw, learning_rate="auto") except TypeError: tsne = TSNE(**kw, learning_rate=200) Z = tsne.fit_transform(X_stack) off = 0 Zg = Z[off:off + n_good] off += n_good Zw = Z[off:off + n_worn] off += n_worn Zr = Z[off:off + n_recon] off += n_recon Zrl = Z[off:off + n_extra] if n_extra else np.empty((0, 2)) off += n_extra Zgp = Z[off:off + n_gpmm] if n_gpmm else np.empty((0, 2)) off += n_gpmm Zo = Z[off:] if n_orig > 0 else np.empty((0, 2)) fig, ax = plt.subplots(figsize=(13, 9)) _scatter_group(ax, Zg, good_labels, "Good") for wi in range(n_worn): grp = worn_groups[wi][0] s = STYLE[grp] ax.scatter(Zw[wi, 0], Zw[wi, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[wi], (Zw[wi, 0], Zw[wi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=s["color"]) for ri in range(n_recon): grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] s = STYLE[rkey] ax.scatter(Zr[ri, 0], Zr[ri, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(recon_labels[ri], (Zr[ri, 0], Zr[ri, 1]), textcoords="offset points", xytext=(6, 6), fontsize=5, color=s["color"]) if n_extra: _scatter_extra_recons_2d(ax, Zrl, extra_labels, extra_groups) if n_gpmm: _scatter_extra_recons_2d(ax, Zgp, gpmm_labels, gpmm_groups, style_map=WORN_TO_GPMM_RECON_COLOR) if n_orig > 0: _scatter_group(ax, Zo, orig_labels, "Original", fontsize=8, text_offset=(6, 8)) ax.legend(handles=_legend_handles(include_local_recon=n_extra > 0, include_gpmm_recon=n_gpmm > 0), fontsize=9, loc="best") ax.set_xlabel("t-SNE 1", fontsize=12) ax.set_ylabel("t-SNE 2", fontsize=12) ax.set_title(f"All Teeth t-SNE (first {d_tsne} PCs, perplexity={perp:.1f})", fontsize=14) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_tsne.png"), dpi=200) plt.close(fig) print("Saved all_teeth_tsne.png") _plot_paired_distance( Zw, Zr, worn_labels, worn_groups, matched_worn_idx, "paired_dist_tsne.png", f"Worn-to-Recon Distance (t-SNE, {d_tsne} PCs)", "t-SNE space") if n_extra: _plot_paired_distance( Zw, Zrl, worn_labels, worn_groups, extra_wi, "paired_dist_tsne_local.png", f"Worn-to-Local-Recon Distance (t-SNE, {d_tsne} PCs)", "t-SNE space") if n_gpmm: _plot_paired_distance( Zw, Zgp, worn_labels, worn_groups, gpmm_wi, "paired_dist_tsne_gpmm.png", f"Worn-to-GPMM-Recon Distance (t-SNE, {d_tsne} PCs)", "t-SNE space") # ── t-SNE from raw 300 k-D features ────────────────────────── if not args.no_tsne and n_all >= 3: raw_parts = [X_good, X_worn, X_recon] if n_extra: raw_parts.append(X_extra) if n_gpmm: raw_parts.append(X_gpmm) if n_orig > 0: raw_parts.append(X_orig) X_all_raw = np.vstack(raw_parts) max_perp = max(2.0, float(n_all - 1) - 1e-6) perp = float(np.clip(args.tsne_perplexity, 2.0, max_perp)) n_feat = X_all_raw.shape[1] print(f"\nRunning t-SNE on raw features ({n_feat}D, {n_all} specimens, " f"perplexity={perp:.1f})...") kw2 = dict(n_components=2, perplexity=perp, random_state=args.seed, metric="euclidean") try: tsne2 = TSNE(**kw2, learning_rate="auto", init="pca") except TypeError: tsne2 = TSNE(**kw2, learning_rate=200, init="random") Z2 = tsne2.fit_transform(X_all_raw) off2 = 0 Z2g = Z2[off2:off2 + n_good] off2 += n_good Z2w = Z2[off2:off2 + n_worn] off2 += n_worn Z2r = Z2[off2:off2 + n_recon] off2 += n_recon Z2rl = Z2[off2:off2 + n_extra] if n_extra else np.empty((0, 2)) off2 += n_extra Z2gp = Z2[off2:off2 + n_gpmm] if n_gpmm else np.empty((0, 2)) off2 += n_gpmm Z2o = Z2[off2:] if n_orig > 0 else np.empty((0, 2)) fig, ax = plt.subplots(figsize=(13, 9)) _scatter_group(ax, Z2g, good_labels, "Good") for wi in range(n_worn): grp = worn_groups[wi][0] s = STYLE[grp] ax.scatter(Z2w[wi, 0], Z2w[wi, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[wi], (Z2w[wi, 0], Z2w[wi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=s["color"]) for ri in range(n_recon): grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] s = STYLE[rkey] ax.scatter(Z2r[ri, 0], Z2r[ri, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(recon_labels[ri], (Z2r[ri, 0], Z2r[ri, 1]), textcoords="offset points", xytext=(6, 6), fontsize=5, color=s["color"]) if n_extra: _scatter_extra_recons_2d(ax, Z2rl, extra_labels, extra_groups) if n_gpmm: _scatter_extra_recons_2d(ax, Z2gp, gpmm_labels, gpmm_groups, style_map=WORN_TO_GPMM_RECON_COLOR) if n_orig > 0: _scatter_group(ax, Z2o, orig_labels, "Original", fontsize=8, text_offset=(6, 8)) ax.legend(handles=_legend_handles(include_local_recon=n_extra > 0, include_gpmm_recon=n_gpmm > 0), fontsize=9, loc="best") ax.set_xlabel("t-SNE 1", fontsize=12) ax.set_ylabel("t-SNE 2", fontsize=12) ax.set_title(f"All Teeth t-SNE (full {n_feat}D features, " f"perplexity={perp:.1f})", fontsize=14) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_tsne_raw.png"), dpi=200) plt.close(fig) print("Saved all_teeth_tsne_raw.png") _plot_paired_distance( Z2w, Z2r, worn_labels, worn_groups, matched_worn_idx, "paired_dist_tsne_raw.png", f"Worn-to-Recon Distance (t-SNE, raw {n_feat}D)", "t-SNE space") if n_extra: _plot_paired_distance( Z2w, Z2rl, worn_labels, worn_groups, extra_wi, "paired_dist_tsne_raw_local.png", f"Worn-to-Local-Recon Distance (t-SNE, raw {n_feat}D)", "t-SNE space") if n_gpmm: _plot_paired_distance( Z2w, Z2gp, worn_labels, worn_groups, gpmm_wi, "paired_dist_tsne_raw_gpmm.png", f"Worn-to-GPMM-Recon Distance (t-SNE, raw {n_feat}D)", "t-SNE space") # ── UMAP from PCs ───────────────────────────────────────────── run_umap = (not args.no_umap) and HAS_UMAP and n_all >= 3 if not args.no_umap and not HAS_UMAP: print("\n[SKIP] UMAP not available -- install with: pip install umap-learn") if run_umap: d_umap = min(max(2, args.tsne_pc_dims), n_comp) umap_pc_parts = [sc_good[:, :d_umap], sc_worn[:, :d_umap], sc_recon[:, :d_umap]] if n_extra: umap_pc_parts.append(sc_extra[:, :d_umap]) if n_gpmm: umap_pc_parts.append(sc_gpmm[:, :d_umap]) if n_orig > 0: umap_pc_parts.append(sc_orig[:, :d_umap]) X_stack_u = np.vstack(umap_pc_parts) nn = min(args.umap_n_neighbors, n_all - 1) print(f"\nRunning UMAP on PCs ({n_all} specimens, dims={d_umap}, " f"n_neighbors={nn}, min_dist={args.umap_min_dist})...") reducer = UMAP(n_components=2, n_neighbors=nn, min_dist=args.umap_min_dist, random_state=args.seed) U = reducer.fit_transform(X_stack_u) uo = 0 Ug = U[uo:uo + n_good] uo += n_good Uw = U[uo:uo + n_worn] uo += n_worn Ur = U[uo:uo + n_recon] uo += n_recon Url = U[uo:uo + n_extra] if n_extra else np.empty((0, 2)) uo += n_extra Ugp = U[uo:uo + n_gpmm] if n_gpmm else np.empty((0, 2)) uo += n_gpmm Uo = U[uo:] if n_orig > 0 else np.empty((0, 2)) fig, ax = plt.subplots(figsize=(13, 9)) _scatter_group(ax, Ug, good_labels, "Good") for wi in range(n_worn): grp = worn_groups[wi][0] s = STYLE[grp] ax.scatter(Uw[wi, 0], Uw[wi, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[wi], (Uw[wi, 0], Uw[wi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=s["color"]) for ri in range(n_recon): grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] s = STYLE[rkey] ax.scatter(Ur[ri, 0], Ur[ri, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(recon_labels[ri], (Ur[ri, 0], Ur[ri, 1]), textcoords="offset points", xytext=(6, 6), fontsize=5, color=s["color"]) if n_extra: _scatter_extra_recons_2d(ax, Url, extra_labels, extra_groups) if n_gpmm: _scatter_extra_recons_2d(ax, Ugp, gpmm_labels, gpmm_groups, style_map=WORN_TO_GPMM_RECON_COLOR) if n_orig > 0: _scatter_group(ax, Uo, orig_labels, "Original", fontsize=8, text_offset=(6, 8)) ax.legend(handles=_legend_handles(include_local_recon=n_extra > 0, include_gpmm_recon=n_gpmm > 0), fontsize=9, loc="best") ax.set_xlabel("UMAP 1", fontsize=12) ax.set_ylabel("UMAP 2", fontsize=12) ax.set_title(f"All Teeth UMAP (first {d_umap} PCs, " f"n_neighbors={nn})", fontsize=14) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_umap.png"), dpi=200) plt.close(fig) print("Saved all_teeth_umap.png") _plot_paired_distance( Uw, Ur, worn_labels, worn_groups, matched_worn_idx, "paired_dist_umap.png", f"Worn-to-Recon Distance (UMAP, {d_umap} PCs)", "UMAP space") if n_extra: _plot_paired_distance( Uw, Url, worn_labels, worn_groups, extra_wi, "paired_dist_umap_local.png", f"Worn-to-Local-Recon Distance (UMAP, {d_umap} PCs)", "UMAP space") if n_gpmm: _plot_paired_distance( Uw, Ugp, worn_labels, worn_groups, gpmm_wi, "paired_dist_umap_gpmm.png", f"Worn-to-GPMM-Recon Distance (UMAP, {d_umap} PCs)", "UMAP space") # ── UMAP from raw 300 k-D features ─────────────────────────── if run_umap: umap_raw_parts = [X_good, X_worn, X_recon] if n_extra: umap_raw_parts.append(X_extra) if n_gpmm: umap_raw_parts.append(X_gpmm) if n_orig > 0: umap_raw_parts.append(X_orig) X_all_raw_u = np.vstack(umap_raw_parts) nn = min(args.umap_n_neighbors, n_all - 1) n_feat = X_all_raw_u.shape[1] print(f"\nRunning UMAP on raw features ({n_feat}D, {n_all} specimens, " f"n_neighbors={nn}, min_dist={args.umap_min_dist})...") reducer2 = UMAP(n_components=2, n_neighbors=nn, min_dist=args.umap_min_dist, random_state=args.seed, metric="euclidean") U2 = reducer2.fit_transform(X_all_raw_u) u2o = 0 U2g = U2[u2o:u2o + n_good] u2o += n_good U2w = U2[u2o:u2o + n_worn] u2o += n_worn U2r = U2[u2o:u2o + n_recon] u2o += n_recon U2rl = U2[u2o:u2o + n_extra] if n_extra else np.empty((0, 2)) u2o += n_extra U2gp = U2[u2o:u2o + n_gpmm] if n_gpmm else np.empty((0, 2)) u2o += n_gpmm U2o = U2[u2o:] if n_orig > 0 else np.empty((0, 2)) fig, ax = plt.subplots(figsize=(13, 9)) _scatter_group(ax, U2g, good_labels, "Good") for wi in range(n_worn): grp = worn_groups[wi][0] s = STYLE[grp] ax.scatter(U2w[wi, 0], U2w[wi, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[wi], (U2w[wi, 0], U2w[wi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=s["color"]) for ri in range(n_recon): grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] s = STYLE[rkey] ax.scatter(U2r[ri, 0], U2r[ri, 1], c=s["color"], marker=s["marker"], s=s["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(recon_labels[ri], (U2r[ri, 0], U2r[ri, 1]), textcoords="offset points", xytext=(6, 6), fontsize=5, color=s["color"]) if n_extra: _scatter_extra_recons_2d(ax, U2rl, extra_labels, extra_groups) if n_gpmm: _scatter_extra_recons_2d(ax, U2gp, gpmm_labels, gpmm_groups, style_map=WORN_TO_GPMM_RECON_COLOR) if n_orig > 0: _scatter_group(ax, U2o, orig_labels, "Original", fontsize=8, text_offset=(6, 8)) ax.legend(handles=_legend_handles(include_local_recon=n_extra > 0, include_gpmm_recon=n_gpmm > 0), fontsize=9, loc="best") ax.set_xlabel("UMAP 1", fontsize=12) ax.set_ylabel("UMAP 2", fontsize=12) ax.set_title(f"All Teeth UMAP (full {n_feat}D features, " f"n_neighbors={nn})", fontsize=14) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_umap_raw.png"), dpi=200) plt.close(fig) print("Saved all_teeth_umap_raw.png") _plot_paired_distance( U2w, U2r, worn_labels, worn_groups, matched_worn_idx, "paired_dist_umap_raw.png", f"Worn-to-Recon Distance (UMAP, raw {n_feat}D)", "UMAP space") if n_extra: _plot_paired_distance( U2w, U2rl, worn_labels, worn_groups, extra_wi, "paired_dist_umap_raw_local.png", f"Worn-to-Local-Recon Distance (UMAP, raw {n_feat}D)", "UMAP space") if n_gpmm: _plot_paired_distance( U2w, U2gp, worn_labels, worn_groups, gpmm_wi, "paired_dist_umap_raw_gpmm.png", f"Worn-to-GPMM-Recon Distance (UMAP, raw {n_feat}D)", "UMAP space") # ── Distance bar chart ──────────────────────────────────────── good_centroid = sc_good.mean(axis=0) dist_worn = np.linalg.norm(sc_worn - good_centroid, axis=1) dist_recon = np.linalg.norm(sc_recon - good_centroid, axis=1) dist_extra = (np.linalg.norm(sc_extra - good_centroid, axis=1) if n_extra else np.array([])) dist_gpmm = (np.linalg.norm(sc_gpmm - good_centroid, axis=1) if n_gpmm else np.array([])) dist_orig = np.linalg.norm(sc_orig - good_centroid, axis=1) if n_orig > 0 else np.array([]) bar_labels, bar_dists, bar_colors, bar_types = [], [], [], [] for oi in range(n_orig): bar_labels.append(orig_labels[oi]) bar_dists.append(dist_orig[oi]) bar_colors.append(STYLE["Original"]["color"]) bar_types.append("original") for wi in range(n_worn): grp = worn_groups[wi][0] bar_labels.append(worn_labels[wi]) bar_dists.append(dist_worn[wi]) bar_colors.append(STYLE[grp]["color"]) bar_types.append("worn") for ri in range(n_recon): grp = recon_groups[ri][0] rkey = WORN_TO_RECON_COLOR[grp] bar_labels.append(recon_labels[ri]) bar_dists.append(dist_recon[ri]) bar_colors.append(STYLE[rkey]["color"]) bar_types.append("recon") for ei in range(n_extra): grp = extra_groups[ei][0] rkey = WORN_TO_LOCAL_RECON_COLOR[grp] bar_labels.append(extra_labels[ei]) bar_dists.append(dist_extra[ei]) bar_colors.append(STYLE[rkey]["color"]) bar_types.append("recon_local") for gi in range(n_gpmm): grp = gpmm_groups[gi][0] rkey = WORN_TO_GPMM_RECON_COLOR[grp] bar_labels.append(gpmm_labels[gi]) bar_dists.append(dist_gpmm[gi]) bar_colors.append(STYLE[rkey]["color"]) bar_types.append("recon_gpmm") sort_idx = np.argsort(bar_dists)[::-1] fig, ax = plt.subplots(figsize=(13, max(8, len(bar_labels) * 0.28))) y_pos = range(len(sort_idx)) ax.barh(y_pos, [bar_dists[i] for i in sort_idx], color=[bar_colors[i] for i in sort_idx], edgecolor="k", linewidth=0.4) ax.set_yticks(y_pos) ax.set_yticklabels([bar_labels[i] for i in sort_idx], fontsize=7) ax.set_xlabel("Euclidean Distance to Good-Teeth Centroid (PC space)", fontsize=11) ax.set_title("All Teeth: Distance from Good-Teeth Distribution", fontsize=13) ax.invert_yaxis() legend_keys = ["Original", "Real worn", "TEST1", "TEST2", "Recon (Real)", "Recon (TEST1)", "Recon (TEST2)"] if n_extra: legend_keys += ["Recon local (Real)", "Recon local (TEST1)", "Recon local (TEST2)"] if n_gpmm: legend_keys += ["Recon GPMM (Real)", "Recon GPMM (TEST1)", "Recon GPMM (TEST2)"] legend_bar = [ Line2D([0], [0], color=STYLE[k]["color"], linewidth=8, label=k) for k in legend_keys ] ax.legend(handles=legend_bar, fontsize=8, loc="lower right") ax.grid(True, axis="x", alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "all_teeth_distance.png"), dpi=200) plt.close(fig) print("Saved all_teeth_distance.png") # ── Terminal summary ────────────────────────────────────────── print(f"\n{'='*60}") print("Distance Summary (to good-teeth centroid in PC space)") print(f"{'='*60}") print(f"{'Label':>18s} {'Group':>14s} {'Type':>6s} {'Dist':>8s}") print(f"{'-'*60}") for i in sort_idx: print(f"{bar_labels[i]:>18s} " f"{'':>14s} " f"{bar_types[i]:>6s} " f"{bar_dists[i]:8.4f}") # Paired comparison print(f"\n{'='*60}") print("Paired Comparison (worn -> recon distance shift)") print(f"{'='*60}") print(f"{'Worn':>18s} {'d_worn':>8s} {'d_recon':>8s} {'delta':>8s} {'Closer?':>8s}") print(f"{'-'*60}") for ri, wi in enumerate(matched_worn_idx): dw = dist_worn[wi] dr = dist_recon[ri] delta = dr - dw closer = "Yes" if delta < 0 else "No" print(f"{worn_labels[wi]:>18s} {dw:8.4f} {dr:8.4f} " f"{delta:+8.4f} {closer:>8s}") n_closer = sum(1 for ri, wi in enumerate(matched_worn_idx) if dist_recon[ri] < dist_worn[wi]) print(f"\n{n_closer}/{n_recon} reconstructions are closer to good-teeth centroid " f"than their worn input.") # Direct worn-to-global-recon distance for ALL worn teeth print(f"\n{'='*70}") print("Worn-to-Global-Recon Distance (direct, full PC space)") print(" Lower = reconstruction stays closer to the worn tooth") print(f"{'='*70}") print(f"{'Worn':>18s} {'Group':>10s} {'d(worn,recon)':>14s}") print(f"{'-'*70}") paired_dists_global = [] for ri, wi in enumerate(matched_worn_idx): d = float(np.linalg.norm(sc_recon[ri] - sc_worn[wi])) grp = worn_groups[wi][0] paired_dists_global.append((worn_labels[wi], grp, d)) paired_dists_global.sort(key=lambda x: x[2]) for lbl, grp, d in paired_dists_global: print(f"{lbl:>18s} {grp:>10s} {d:14.4f}") avg_d = np.mean([d for _, _, d in paired_dists_global]) print(f"\n{'Average':>18s} {'':>10s} {avg_d:14.4f}") if n_extra: print(f"\n{'='*60}") print("Local recon: distance to good-teeth centroid") print(f"{'='*60}") print(f"{'Worn':>18s} {'d_worn':>8s} {'d_local':>8s} {'delta':>8s} {'Closer?':>8s}") print(f"{'-'*60}") for ei, wi in enumerate(extra_wi): dw = dist_worn[wi] dl = dist_extra[ei] delta = dl - dw closer = "Yes" if delta < 0 else "No" print(f"{worn_labels[wi]:>18s} {dw:8.4f} {dl:8.4f} " f"{delta:+8.4f} {closer:>8s}") # Direct worn-to-recon distance: how close is each recon to its worn input? # Build lookup: worn_key -> index in sc_recon (global recon) global_ri_by_wi = {wi: ri for ri, wi in enumerate(matched_worn_idx)} print(f"\n{'='*80}") print("Worn-to-Recon Distance (direct, in full PC space)") print(" Lower = reconstruction stays closer to the worn tooth") print(f"{'='*80}") print(f"{'Worn':>18s} {'d(w,global)':>12s} {'d(w,local)':>12s} " f"{'delta':>10s} {'Local closer?':>14s}") print(f"{'-'*80}") for ei, wi in enumerate(extra_wi): d_local = float(np.linalg.norm(sc_extra[ei] - sc_worn[wi])) gri = global_ri_by_wi.get(wi) if gri is not None: d_global = float(np.linalg.norm(sc_recon[gri] - sc_worn[wi])) delta = d_local - d_global closer = "YES" if delta < 0 else "no" print(f"{worn_labels[wi]:>18s} {d_global:12.4f} {d_local:12.4f} " f"{delta:+10.4f} {closer:>14s}") else: print(f"{worn_labels[wi]:>18s} {'N/A':>12s} {d_local:12.4f} " f"{'':>10s} {'':>14s}") n_local_closer = sum( 1 for ei, wi in enumerate(extra_wi) if wi in global_ri_by_wi and np.linalg.norm(sc_extra[ei] - sc_worn[wi]) < np.linalg.norm(sc_recon[global_ri_by_wi[wi]] - sc_worn[wi])) n_comparable = sum(1 for wi in [w for _, w in enumerate(extra_wi)] if wi in global_ri_by_wi) print(f"\n{n_local_closer}/{n_comparable} local reconstructions are " f"closer to their worn input than the global recon.") if n_gpmm: print(f"\n{'='*60}") print("GPMM recon: distance to good-teeth centroid") print(f"{'='*60}") print(f"{'Worn':>18s} {'d_worn':>8s} {'d_gpmm':>8s} {'delta':>8s} {'Closer?':>8s}") print(f"{'-'*60}") for gi, wi in enumerate(gpmm_wi): dw = dist_worn[wi] dg = dist_gpmm[gi] delta = dg - dw closer = "Yes" if delta < 0 else "No" print(f"{worn_labels[wi]:>18s} {dw:8.4f} {dg:8.4f} " f"{delta:+8.4f} {closer:>8s}") global_ri_by_wi_g = {wi: ri for ri, wi in enumerate(matched_worn_idx)} print(f"\n{'='*80}") print("Worn-to-Recon Distance (direct, in full PC space)") print(" Lower = reconstruction stays closer to the worn tooth") print(f"{'='*80}") print(f"{'Worn':>18s} {'d(w,global)':>12s} {'d(w,gpmm)':>12s} " f"{'delta':>10s} {'GPMM closer?':>14s}") print(f"{'-'*80}") for gi, wi in enumerate(gpmm_wi): d_gpmm = float(np.linalg.norm(sc_gpmm[gi] - sc_worn[wi])) gri = global_ri_by_wi_g.get(wi) if gri is not None: d_global = float(np.linalg.norm(sc_recon[gri] - sc_worn[wi])) delta = d_gpmm - d_global closer = "YES" if delta < 0 else "no" print(f"{worn_labels[wi]:>18s} {d_global:12.4f} {d_gpmm:12.4f} " f"{delta:+10.4f} {closer:>14s}") else: print(f"{worn_labels[wi]:>18s} {'N/A':>12s} {d_gpmm:12.4f} " f"{'':>10s} {'':>14s}") n_gpmm_closer = sum( 1 for gi, wi in enumerate(gpmm_wi) if wi in global_ri_by_wi_g and np.linalg.norm(sc_gpmm[gi] - sc_worn[wi]) < np.linalg.norm(sc_recon[global_ri_by_wi_g[wi]] - sc_worn[wi])) n_comparable_g = sum(1 for wi in gpmm_wi if wi in global_ri_by_wi_g) print(f"\n{n_gpmm_closer}/{n_comparable_g} GPMM reconstructions are " f"closer to their worn input than the global recon.") print(f"\nAll plots saved to {PLOT_DIR}/") if __name__ == "__main__": main()