""" Project worn teeth into the PCA space of good (unworn) teeth. Default mode: loads corresponded point clouds from the SSM correspondence pipeline output. These have consistent point ordering, so PCA captures true anatomical shape variation. Raw mode (--raw): loads original PLY meshes, samples points, normalizes, and ICP-aligns. GPU-accelerated with CuPy on multiple V100s. Usage: python worn_teeth_projection.py # corresponded + t-SNE plot python worn_teeth_projection.py --no-tsne # skip t-SNE python worn_teeth_projection.py --raw --n-points 100000 # raw + GPU ICP python worn_teeth_projection.py --raw --no-gpu # raw + CPU ICP """ import matplotlib matplotlib.use("Agg") import argparse import os import re import sys import time 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.decomposition import PCA from sklearn.manifold import TSNE from tqdm import tqdm HAS_CUPY = False try: import cupy as cp HAS_CUPY = 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") GOOD_TEETH_DIRS = [ os.path.join(PROJECT_DIR, "Good teeth"), os.path.join(PROJECT_DIR, "Good teeth-part2"), ] WORN_TEETH_DIR = os.path.join(PROJECT_DIR, "Worn teeth") ARTIFICIAL_WORN_DIR = os.path.join(PROJECT_DIR, "Artificially worn part 2") CORR_BASE = os.path.join( PROJECT_DIR, "ssm_pipeline", "output", "correspondence_real_100k_v2" ) CORR_GOOD_DIR = os.path.join(CORR_BASE, "good_teeth") CORR_WORN_DIR = os.path.join(CORR_BASE, "artificial_worn") # ── Preprocessing helpers (raw mode) ───────────────────────────── def sample_points(mesh_path: str, n_points: int, seed: int) -> np.ndarray: mesh = trimesh.load(mesh_path, force="mesh", process=False) pts, _ = trimesh.sample.sample_surface(mesh, n_points, seed=seed) return np.asarray(pts, 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 # ── ICP implementations ────────────────────────────────────────── def icp_align_cpu(source: np.ndarray, target: np.ndarray, max_iter: int = 100, tol: float = 1e-6) -> np.ndarray: """CPU fallback using scipy cKDTree.""" 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 icp_align_gpu(source: np.ndarray, target: np.ndarray, gpu_id: int = 0, max_iter: int = 100, tol: float = 1e-6, batch_size: int = 10000) -> np.ndarray: """GPU-accelerated ICP using CuPy batched brute-force nearest neighbor. Uses ||a-b||^2 = ||a||^2 + ||b||^2 - 2*a·b to leverage fast GPU matmul. Default batch_size 10000 uses ~4 GB for 100k-point clouds (safe for V100 16 GB). """ with cp.cuda.Device(gpu_id): src = cp.asarray(source, dtype=cp.float32) tgt = cp.asarray(target, dtype=cp.float32) tgt_sq = cp.sum(tgt ** 2, axis=1) n = src.shape[0] prev_err = float("inf") for _ in range(max_iter): min_idx = cp.empty(n, dtype=cp.int64) sum_dist = cp.float32(0.0) for start in range(0, n, batch_size): end = min(start + batch_size, n) batch = src[start:end] dist_sq = (cp.sum(batch ** 2, axis=1, keepdims=True) + tgt_sq[None, :] - 2.0 * batch @ tgt.T) cp.maximum(dist_sq, 0, out=dist_sq) idx = cp.argmin(dist_sq, axis=1) min_idx[start:end] = idx sum_dist += cp.sum(cp.sqrt(dist_sq[cp.arange(end - start), idx])) corr = tgt[min_idx] src_c = src.mean(axis=0) corr_c = corr.mean(axis=0) H = (src - src_c).T @ (corr - corr_c) U, _, Vt = cp.linalg.svd(H) R = Vt.T @ U.T if float(cp.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(sum_dist) / n if abs(prev_err - err) < tol: break prev_err = err return cp.asnumpy(src).astype(np.float64) def parallel_icp_gpu(clouds, template, n_gpus=4, max_iter=100, tol=1e-6, batch_size=10000): """Align all clouds to template using multiple GPUs in parallel threads.""" from concurrent.futures import ThreadPoolExecutor, as_completed n_avail = cp.cuda.runtime.getDeviceCount() n_use = min(n_gpus, n_avail) def _align(i): gpu_id = (i - 1) % n_use return i, icp_align_gpu(clouds[i], template, gpu_id=gpu_id, max_iter=max_iter, tol=tol, batch_size=batch_size) n_to_align = len(clouds) - 1 with ThreadPoolExecutor(max_workers=n_use) as executor: futures = {executor.submit(_align, i): i for i in range(1, len(clouds))} with tqdm(total=n_to_align, desc=f"ICP aligning ({n_use} GPU{'s' if n_use > 1 else ''})") as pbar: for future in as_completed(futures): idx, result = future.result() clouds[idx] = result pbar.update(1) return clouds # ── Label / classification helpers ──────────────────────────────── def extract_specimen_id(filename: str) -> str: m = re.search(r"n(\d+)", filename) if m: return f"n{m.group(1)}" m2 = re.search(r"(TEST\d+).*?(\d+)\.ply", filename) if m2: return f"{m2.group(1)}_L{m2.group(2)}" return os.path.splitext(filename)[0][:15] def classify_worn_dir(dirname: str): """Classify a correspondence worn dir name like 'tooth_TEST1_wear_level3'.""" 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 return "Real worn", 0 def classify_worn_file(filename: str): """Classify a raw worn file.""" if "TEST1" in filename: level = int(re.search(r"(\d+)\.ply", filename).group(1)) return "TEST1", level if "TEST2" in filename: level = int(re.search(r"(\d+)\.ply", filename).group(1)) return "TEST2", level return "Real worn", 0 def worn_dir_label(dirname: str) -> str: """Create a display label from correspondence worn dir name.""" if "TEST1" in dirname: m = re.search(r"level(\d+)", dirname) return f"TEST1_L{m.group(1)}" if m else "TEST1" if "TEST2" in dirname: m = re.search(r"level(\d+)", dirname) return f"TEST2_L{m.group(1)}" if m else "TEST2" m = re.search(r"tooth_(\d+)", dirname) return f"T{m.group(1)}_worn" if m else dirname[:15] # ── Loading strategies ──────────────────────────────────────────── def _load_ply_points(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 load_corresponded(corr_good_dir: str, corr_worn_dir: str): """Load corresponded point clouds for good and worn teeth.""" # 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 = [], [], [] for td in worn_dirs: ply = os.path.join(td, "corresponded.ply") if os.path.exists(ply): worn_files.append(ply) dname = os.path.basename(td) worn_labels.append(worn_dir_label(dname)) worn_groups.append(classify_worn_dir(dname)) # Load all good_clouds = [] for f in tqdm(good_files, desc="Loading good teeth"): good_clouds.append(_load_ply_points(f)) worn_clouds = [] for f in tqdm(worn_files, desc="Loading worn teeth"): worn_clouds.append(_load_ply_points(f)) return good_clouds, good_labels, worn_clouds, worn_labels, worn_groups def load_raw(good_dirs_list, worn_dir, artificial_dir, n_points, seed, use_gpu, n_gpus): """Load raw PLY meshes, sample, normalize, ICP-align.""" # Good good_files = [] for d in good_dirs_list: good_files.extend(sorted(glob(os.path.join(d, "*.ply")))) good_files.sort(key=lambda f: os.path.basename(f)) good_labels = [extract_specimen_id(os.path.basename(f)) for f in good_files] # Worn worn_files = sorted(glob(os.path.join(worn_dir, "*.ply")), key=lambda f: os.path.basename(f)) worn_files += sorted(glob(os.path.join(artificial_dir, "*.ply")), key=lambda f: os.path.basename(f)) worn_labels = [extract_specimen_id(os.path.basename(f)) for f in worn_files] worn_groups = [classify_worn_file(os.path.basename(f)) for f in worn_files] # Preprocess all together all_files = good_files + worn_files clouds = [] for i, f in enumerate(tqdm(all_files, desc="Sampling & normalizing")): pts = sample_points(f, n_points, seed + i) pts = normalize(pts) clouds.append(pts) template = clouds[0] t0 = time.time() if use_gpu: parallel_icp_gpu(clouds, template, n_gpus=n_gpus) else: for i in tqdm(range(1, len(clouds)), desc="ICP aligning (CPU)"): clouds[i] = icp_align_cpu(clouds[i], template) print(f"ICP alignment took {time.time() - t0:.1f}s") n_good = len(good_files) return (clouds[:n_good], good_labels, clouds[n_good:], worn_labels, worn_groups) # ── Main ────────────────────────────────────────────────────────── def main(): parser = argparse.ArgumentParser( description="Worn teeth PCA projection (uses corresponded point clouds by default)") parser.add_argument("--raw", action="store_true", help="Use raw PLY meshes instead of corresponded outputs") parser.add_argument("--n-points", type=int, default=10000, help="Points to sample per tooth (raw mode only)") parser.add_argument("--seed", type=int, default=42) parser.add_argument("--n-gpus", type=int, default=4, help="Number of GPUs for parallel ICP (raw mode, default: 4)") parser.add_argument("--no-gpu", action="store_true", help="Force CPU-only ICP (raw mode)") parser.add_argument("--no-tsne", action="store_true", help="Skip t-SNE embedding plot") parser.add_argument("--tsne-perplexity", type=float, default=30.0, help="t-SNE perplexity (clamped to n_samples-1, default 30)") parser.add_argument("--tsne-pc-dims", type=int, default=10, help="Number of leading PCs to feed t-SNE (default 10)") args = parser.parse_args() os.makedirs(PLOT_DIR, exist_ok=True) if args.raw: use_gpu = HAS_CUPY and not args.no_gpu if use_gpu: n_avail = cp.cuda.runtime.getDeviceCount() print(f"Raw mode + GPU: {n_avail} GPU(s), using {min(args.n_gpus, n_avail)}") else: reason = "CuPy not installed" if not HAS_CUPY else "--no-gpu flag" print(f"Raw mode + CPU ({reason})") (good_clouds, good_labels, worn_clouds, worn_labels, worn_groups) = load_raw( GOOD_TEETH_DIRS, WORN_TEETH_DIR, ARTIFICIAL_WORN_DIR, args.n_points, args.seed, use_gpu, args.n_gpus) else: print(f"Loading corresponded point clouds from:\n {CORR_BASE}") if not os.path.isdir(CORR_GOOD_DIR): sys.exit(f"Correspondence dir not found: {CORR_GOOD_DIR}\n" f"Run with --raw to use original PLY meshes.") (good_clouds, good_labels, worn_clouds, worn_labels, worn_groups) = load_corresponded( CORR_GOOD_DIR, CORR_WORN_DIR) n_good = len(good_clouds) n_worn = len(worn_clouds) n_pts = good_clouds[0].shape[0] print(f"Good 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)") if n_good < 3: sys.exit("Need at least 3 good teeth") X_good = np.array([c.flatten() for c in good_clouds]) X_worn = np.array([c.flatten() for c in worn_clouds]) # ── PCA on good teeth, project worn ─────────────────────────── n_comp = min(n_good - 1, 10) pca = PCA(n_components=n_comp) scores_good = pca.fit_transform(X_good) scores_worn = pca.transform(X_worn) 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}%)") # Group colors and markers group_style = { "Good": {"color": "#4C72B0", "marker": "o", "size": 120}, "Real worn": {"color": "#C44E52", "marker": "^", "size": 110}, "TEST1": {"color": "#55A868", "marker": "D", "size": 100}, "TEST2": {"color": "#8172B2", "marker": "s", "size": 100}, } # ── Plot 1: 2D scatter good + worn in PC1-PC2 ──────────────── fig, ax = plt.subplots(figsize=(11, 8)) gs = group_style["Good"] ax.scatter(scores_good[:, 0], scores_good[:, 1], c=gs["color"], marker=gs["marker"], s=gs["size"], edgecolors="k", linewidths=0.5, zorder=4, label="Good teeth") for i, lbl in enumerate(good_labels): ax.annotate(lbl, (scores_good[i, 0], scores_good[i, 1]), textcoords="offset points", xytext=(6, 6), fontsize=7, color=gs["color"]) for gi, (grp, _) in enumerate(worn_groups): ws = group_style[grp] ax.scatter(scores_worn[gi, 0], scores_worn[gi, 1], c=ws["color"], marker=ws["marker"], s=ws["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[gi], (scores_worn[gi, 0], scores_worn[gi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=ws["color"]) legend_handles = [ Line2D([0], [0], marker=v["marker"], color="w", markerfacecolor=v["color"], markersize=10, markeredgecolor="k", label=k) for k, v in group_style.items() ] ax.legend(handles=legend_handles, fontsize=10, 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) mode_tag = "corresponded" if not args.raw else "raw" ax.set_title(f"Worn Teeth Projected onto Good-Teeth PCA (PC1 vs PC2, {mode_tag})", fontsize=13) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "worn_vs_good_pca_2d.png"), dpi=200) plt.close(fig) print("Saved worn_vs_good_pca_2d.png") # ── t-SNE on stacked good + worn PC scores ──────────────────── n_all = n_good + n_worn if not args.no_tsne and n_all >= 3: d_tsne = min(max(2, args.tsne_pc_dims), n_comp) X_stack = np.vstack([scores_good[:, :d_tsne], scores_worn[:, :d_tsne]]) 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 good+worn ({n_all} specimens, input dims={d_tsne}, " f"perplexity={perp:.1f})...") _tsne_kw = dict( n_components=2, perplexity=perp, random_state=args.seed, init="pca", ) try: tsne = TSNE(**_tsne_kw, learning_rate="auto") except TypeError: tsne = TSNE(**_tsne_kw, learning_rate=200) Z = tsne.fit_transform(X_stack) Z_good = Z[:n_good] Z_worn = Z[n_good:] fig, ax = plt.subplots(figsize=(11, 8)) gs = group_style["Good"] ax.scatter(Z_good[:, 0], Z_good[:, 1], c=gs["color"], marker=gs["marker"], s=gs["size"], edgecolors="k", linewidths=0.5, zorder=4, label="Good teeth") for i, lbl in enumerate(good_labels): ax.annotate(lbl, (Z_good[i, 0], Z_good[i, 1]), textcoords="offset points", xytext=(6, 6), fontsize=7, color=gs["color"]) for gi, (grp, _) in enumerate(worn_groups): ws = group_style[grp] ax.scatter(Z_worn[gi, 0], Z_worn[gi, 1], c=ws["color"], marker=ws["marker"], s=ws["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[gi], (Z_worn[gi, 0], Z_worn[gi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=ws["color"]) legend_handles_tsne = [ Line2D([0], [0], marker=v["marker"], color="w", markerfacecolor=v["color"], markersize=10, markeredgecolor="k", label=k) for k, v in group_style.items() ] ax.legend(handles=legend_handles_tsne, fontsize=10, loc="best") ax.set_xlabel("t-SNE 1", fontsize=12) ax.set_ylabel("t-SNE 2", fontsize=12) mode_tag = "corresponded" if not args.raw else "raw" ax.set_title( f"Good + Worn t-SNE (first {d_tsne} PCs, perplexity={perp:.1f}, {mode_tag})", fontsize=13, ) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "worn_vs_good_tsne.png"), dpi=200) plt.close(fig) print("Saved worn_vs_good_tsne.png") # ── t-SNE directly on full feature vectors (no PCA reduction) ─ if not args.no_tsne and n_all >= 3: X_all = np.vstack([X_good, X_worn]) 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.shape[1] print(f"\nRunning t-SNE on raw features ({n_feat}D, {n_all} specimens, " f"perplexity={perp:.1f})...") _tsne_kw2 = dict( n_components=2, perplexity=perp, random_state=args.seed, metric="euclidean", ) try: tsne2 = TSNE(**_tsne_kw2, learning_rate="auto", init="pca") except TypeError: tsne2 = TSNE(**_tsne_kw2, learning_rate=200, init="random") Z2 = tsne2.fit_transform(X_all) Z2_good = Z2[:n_good] Z2_worn = Z2[n_good:] fig, ax = plt.subplots(figsize=(11, 8)) gs = group_style["Good"] ax.scatter(Z2_good[:, 0], Z2_good[:, 1], c=gs["color"], marker=gs["marker"], s=gs["size"], edgecolors="k", linewidths=0.5, zorder=4, label="Good teeth") for i, lbl in enumerate(good_labels): ax.annotate(lbl, (Z2_good[i, 0], Z2_good[i, 1]), textcoords="offset points", xytext=(6, 6), fontsize=7, color=gs["color"]) for gi, (grp, _) in enumerate(worn_groups): ws = group_style[grp] ax.scatter(Z2_worn[gi, 0], Z2_worn[gi, 1], c=ws["color"], marker=ws["marker"], s=ws["size"], edgecolors="k", linewidths=0.5, zorder=3) ax.annotate(worn_labels[gi], (Z2_worn[gi, 0], Z2_worn[gi, 1]), textcoords="offset points", xytext=(6, -8), fontsize=6, color=ws["color"]) legend_handles_raw = [ Line2D([0], [0], marker=v["marker"], color="w", markerfacecolor=v["color"], markersize=10, markeredgecolor="k", label=k) for k, v in group_style.items() ] ax.legend(handles=legend_handles_raw, fontsize=10, loc="best") ax.set_xlabel("t-SNE 1", fontsize=12) ax.set_ylabel("t-SNE 2", fontsize=12) mode_tag = "corresponded" if not args.raw else "raw" ax.set_title( f"Good + Worn t-SNE (full {n_feat}D features, perplexity={perp:.1f}, {mode_tag})", fontsize=13, ) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "worn_vs_good_tsne_raw.png"), dpi=200) plt.close(fig) print("Saved worn_vs_good_tsne_raw.png") # ── Plot 2: 3D scatter PC1-PC2-PC3 ─────────────────────────── if n_comp >= 3: fig = plt.figure(figsize=(11, 9)) ax = fig.add_subplot(111, projection="3d") gs = group_style["Good"] ax.scatter(scores_good[:, 0], scores_good[:, 1], scores_good[:, 2], c=gs["color"], marker=gs["marker"], s=gs["size"], edgecolors="k", linewidths=0.4, label="Good teeth", depthshade=True) for i, lbl in enumerate(good_labels): ax.text(scores_good[i, 0], scores_good[i, 1], scores_good[i, 2], f" {lbl}", fontsize=6, color=gs["color"]) for gi, (grp, _) in enumerate(worn_groups): ws = group_style[grp] ax.scatter(scores_worn[gi, 0], scores_worn[gi, 1], scores_worn[gi, 2], c=ws["color"], marker=ws["marker"], s=ws["size"], edgecolors="k", linewidths=0.3, depthshade=True) ax.legend(handles=legend_handles, fontsize=9, loc="upper left") ax.set_xlabel(f"PC1 ({var_ratio[0]*100:.1f}%)") ax.set_ylabel(f"PC2 ({var_ratio[1]*100:.1f}%)") ax.set_zlabel(f"PC3 ({var_ratio[2]*100:.1f}%)") ax.set_title("Good + Worn Teeth (PC1-PC2-PC3)", fontsize=13) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "worn_vs_good_pca_3d.png"), dpi=200) plt.close(fig) print("Saved worn_vs_good_pca_3d.png") # ── Plot 3: Distance bar chart ──────────────────────────────── good_centroid = scores_good.mean(axis=0) distances = np.linalg.norm(scores_worn - good_centroid, axis=1) sort_idx = np.argsort(distances) sorted_labels = [worn_labels[i] for i in sort_idx] sorted_dists = distances[sort_idx] sorted_groups = [worn_groups[i][0] for i in sort_idx] bar_colors = [group_style[g]["color"] for g in sorted_groups] fig, ax = plt.subplots(figsize=(13, 6)) ax.barh(range(len(sorted_labels)), sorted_dists, color=bar_colors, edgecolor="k", linewidth=0.4) ax.set_yticks(range(len(sorted_labels))) ax.set_yticklabels(sorted_labels, fontsize=8) ax.set_xlabel("Euclidean Distance to Good-Teeth Centroid (in PC space)", fontsize=11) ax.set_title("Worn Teeth: Distance from Good-Teeth Distribution", fontsize=13) ax.invert_yaxis() legend_handles_bar = [ Line2D([0], [0], color=v["color"], linewidth=8, label=k) for k, v in group_style.items() if k != "Good" ] ax.legend(handles=legend_handles_bar, fontsize=10, loc="lower right") ax.grid(True, axis="x", alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "worn_distance_to_good.png"), dpi=200) plt.close(fig) print("Saved worn_distance_to_good.png") # ── Plot 4: Wear trajectories for TEST1 and TEST2 ──────────── fig, ax = plt.subplots(figsize=(11, 8)) gs = group_style["Good"] ax.scatter(scores_good[:, 0], scores_good[:, 1], c=gs["color"], marker=gs["marker"], s=gs["size"], edgecolors="k", linewidths=0.5, alpha=0.4, zorder=2, label="Good teeth") for test_name, color in [("TEST1", "#55A868"), ("TEST2", "#8172B2")]: idx_levels = [(i, worn_groups[i][1]) for i in range(n_worn) if worn_groups[i][0] == test_name] idx_levels.sort(key=lambda x: x[1]) if not idx_levels: continue traj_x = [scores_worn[i, 0] for i, _ in idx_levels] traj_y = [scores_worn[i, 1] for i, _ in idx_levels] levels = [lv for _, lv in idx_levels] ax.plot(traj_x, traj_y, "-", color=color, linewidth=2, alpha=0.7, zorder=3) for j, (xi, yi, lv) in enumerate(zip(traj_x, traj_y, levels)): alpha = 0.4 + 0.6 * (j / max(len(levels) - 1, 1)) ax.scatter(xi, yi, c=color, s=100, edgecolors="k", linewidths=0.5, alpha=alpha, zorder=4) ax.annotate(f"L{lv}", (xi, yi), textcoords="offset points", xytext=(5, 5), fontsize=8, color=color, fontweight="bold") if len(traj_x) >= 2: ax.annotate("", xy=(traj_x[-1], traj_y[-1]), xytext=(traj_x[-2], traj_y[-2]), arrowprops=dict(arrowstyle="->", color=color, lw=2)) legend_handles_traj = [ Line2D([0], [0], marker="o", color="w", markerfacecolor="#4C72B0", markersize=10, markeredgecolor="k", label="Good teeth"), Line2D([0], [0], color="#55A868", linewidth=2, marker="o", markerfacecolor="#55A868", markersize=8, label="TEST1 wear path"), Line2D([0], [0], color="#8172B2", linewidth=2, marker="o", markerfacecolor="#8172B2", markersize=8, label="TEST2 wear path"), ] ax.legend(handles=legend_handles_traj, fontsize=10, 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("Wear Progression Trajectories in PCA Space", fontsize=13) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "wear_trajectory.png"), dpi=200) plt.close(fig) print("Saved wear_trajectory.png") # ── Summary ─────────────────────────────────────────────────── print(f"\n{'='*50}") print("Distance Summary (worn -> good centroid):") print(f"{'='*50}") for i in sort_idx: grp = worn_groups[i][0] print(f" {worn_labels[i]:>15s} ({grp:>9s}) dist = {distances[i]:.4f}") print(f"\nAll plots saved to {PLOT_DIR}/") if __name__ == "__main__": main()