""" PCA variance analysis and clustering of good (unworn) teeth. Default mode: loads corresponded point clouds from the SSM correspondence pipeline output. These have consistent point ordering across teeth, so PCA captures true anatomical shape variation (not random sampling noise). Raw mode (--raw): loads original PLY meshes, samples points, normalizes, and ICP-aligns. GPU-accelerated with CuPy on multiple V100s. Usage: python good_teeth_pca.py # corresponded + t-SNE plot python good_teeth_pca.py --k-means-k 3 # K-Means with k=3 (not auto) python good_teeth_pca.py --no-tsne # skip t-SNE python good_teeth_pca.py --raw --n-points 100000 # raw mesh + GPU ICP python good_teeth_pca.py --raw --no-gpu # raw mesh + 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 mpl_toolkits.mplot3d import Axes3D # noqa: F401 from sklearn.cluster import KMeans from sklearn.decomposition import PCA from sklearn.manifold import TSNE from sklearn.metrics import silhouette_score 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"), ] CORRESPONDENCE_DIR = os.path.join( PROJECT_DIR, "ssm_pipeline", "output", "correspondence_real_100k_v2", "good_teeth" ) # ── 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. batch_size controls GPU memory: each batch allocates (batch_size x N_target x 4) bytes. Default 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 helpers ───────────────────────────────────────────────── def extract_specimen_id(filename: str) -> str: m = re.search(r"n(\d+)", filename) return f"n{m.group(1)}" if m else os.path.splitext(filename)[0][:12] def extract_tooth_label(dirname: str) -> str: """Extract a label from a correspondence directory name like 'tooth_01'.""" return dirname.replace("tooth_", "T") # ── Loading strategies ──────────────────────────────────────────── def load_corresponded(corr_dir: str): """Load corresponded point clouds (already in correspondence).""" tooth_dirs = sorted(glob(os.path.join(corr_dir, "tooth_*"))) files, labels, sources = [], [], [] for td in tooth_dirs: ply = os.path.join(td, "corresponded.ply") if not os.path.exists(ply): print(f" [SKIP] {os.path.basename(td)} -- no corresponded.ply") continue files.append(ply) labels.append(extract_tooth_label(os.path.basename(td))) norm_json = os.path.join(td, "normalization.json") if os.path.exists(norm_json): import json with open(norm_json) as f: meta = json.load(f) src_file = meta.get("source_file", "") sources.append("Part 2" if "part2" in src_file.lower() or "part 2" in src_file.lower() else "Part 1") else: sources.append("Part 1") clouds = [] for f in tqdm(files, desc="Loading corresponded point clouds"): pc = trimesh.load(f, process=False) pts = np.asarray(pc.vertices if hasattr(pc, "vertices") else pc, dtype=np.float64) clouds.append(pts) return clouds, labels, sources def load_raw_meshes(good_dirs, n_points, seed, use_gpu, n_gpus): """Load raw PLY meshes, sample, normalize, ICP-align.""" files, sources = [], [] for d in good_dirs: for f in sorted(glob(os.path.join(d, "*.ply"))): files.append(f) sources.append("Part 1" if "Good teeth-part2" not in d else "Part 2") labels = [extract_specimen_id(os.path.basename(f)) for f in files] clouds = [] for i, f in enumerate(tqdm(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") return clouds, labels, sources # ── Main ────────────────────────────────────────────────────────── def main(): parser = argparse.ArgumentParser( description="PCA of good teeth (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("--correspondence-dir", type=str, default=CORRESPONDENCE_DIR, help="Path to correspondence good_teeth/ output dir") 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_teeth-1, default 30)") parser.add_argument("--tsne-pc-dims", type=int, default=10, help="Number of leading PCs to feed t-SNE (default 10)") parser.add_argument("--k-means-k", type=int, default=None, metavar="K", help="Fix number of K-Means clusters (e.g. 3). " "If omitted, k is chosen by best silhouette score.") 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) detected, " f"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})") clouds, labels, sources = load_raw_meshes( GOOD_TEETH_DIRS, args.n_points, args.seed, use_gpu, args.n_gpus) else: print(f"Loading corresponded point clouds from:\n {args.correspondence_dir}") if not os.path.isdir(args.correspondence_dir): sys.exit(f"Correspondence dir not found: {args.correspondence_dir}\n" f"Run with --raw to use original PLY meshes instead.") clouds, labels, sources = load_corresponded(args.correspondence_dir) n_teeth = len(clouds) n_pts = clouds[0].shape[0] print(f"Found {n_teeth} good teeth ({n_pts} points each)") if n_teeth < 3: sys.exit("Need at least 3 teeth for meaningful PCA") # Build feature matrix (N_teeth x 3*n_points) X = np.array([c.flatten() for c in clouds]) print(f"Feature matrix: {X.shape}") # PCA n_components = min(n_teeth, 10) pca = PCA(n_components=n_components) scores = pca.fit_transform(X) var_ratio = pca.explained_variance_ratio_ cum_var = np.cumsum(var_ratio) print("\nVariance explained per component:") for i, (v, c) in enumerate(zip(var_ratio, cum_var)): print(f" PC{i+1}: {v*100:6.2f}% (cumulative {c*100:6.2f}%)") # ── Plot 1: Scree plot ──────────────────────────────────────── 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) lines1, labels1 = ax1.get_legend_handles_labels() lines2, labels2 = ax2.get_legend_handles_labels() ax1.legend(lines1 + lines2, labels1 + labels2, loc="center right", fontsize=10) mode_tag = "raw" if args.raw else "corresponded" ax1.set_title(f"PCA Scree Plot ({n_teeth} Good Teeth, {mode_tag})", fontsize=14) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "good_teeth_scree.png"), dpi=200) plt.close(fig) print("Saved good_teeth_scree.png") # ── Plot 2: PC1 vs PC2 colored by source group ─────────────── fig, ax = plt.subplots(figsize=(9, 7)) for src, marker, color in [("Part 1", "o", "#4C72B0"), ("Part 2", "s", "#DD8452")]: idx = [i for i, s in enumerate(sources) if s == src] if not idx: continue ax.scatter(scores[idx, 0], scores[idx, 1], c=color, marker=marker, s=120, edgecolors="k", linewidths=0.5, label=src, zorder=3) for i, lbl in enumerate(labels): ax.annotate(lbl, (scores[i, 0], scores[i, 1]), textcoords="offset points", xytext=(6, 6), fontsize=8) 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 Teeth in PCA Space (PC1 vs PC2)", fontsize=14) ax.legend(fontsize=11) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "good_teeth_pca_2d.png"), dpi=200) plt.close(fig) print("Saved good_teeth_pca_2d.png") # ── Plot 3: 3D scatter PC1-PC2-PC3 ─────────────────────────── if n_components >= 3: fig = plt.figure(figsize=(10, 8)) ax = fig.add_subplot(111, projection="3d") for src, marker, color in [("Part 1", "o", "#4C72B0"), ("Part 2", "s", "#DD8452")]: idx = [i for i, s in enumerate(sources) if s == src] if not idx: continue ax.scatter(scores[idx, 0], scores[idx, 1], scores[idx, 2], c=color, marker=marker, s=100, edgecolors="k", linewidths=0.4, label=src, depthshade=True) for i, lbl in enumerate(labels): ax.text(scores[i, 0], scores[i, 1], scores[i, 2], f" {lbl}", fontsize=7) 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 Teeth (PC1-PC2-PC3)", fontsize=14) ax.legend(fontsize=10) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "good_teeth_pca_3d.png"), dpi=200) plt.close(fig) print("Saved good_teeth_pca_3d.png") # ── t-SNE on PCA scores (2D visualization) ─────────────────── if not args.no_tsne and n_teeth >= 3: d_tsne = min(max(2, args.tsne_pc_dims), n_components) X_tsne_in = scores[:, :d_tsne] max_perp = max(2.0, float(n_teeth - 1) - 1e-6) perp = float(np.clip(args.tsne_perplexity, 2.0, max_perp)) print(f"\nRunning t-SNE (input dims={d_tsne}, 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_tsne_in) fig, ax = plt.subplots(figsize=(9, 7)) for src, marker, color in [("Part 1", "o", "#4C72B0"), ("Part 2", "s", "#DD8452")]: idx = [i for i, s in enumerate(sources) if s == src] if not idx: continue ax.scatter(Z[idx, 0], Z[idx, 1], c=color, marker=marker, s=120, edgecolors="k", linewidths=0.5, label=src, zorder=3) for i, lbl in enumerate(labels): ax.annotate(lbl, (Z[i, 0], Z[i, 1]), textcoords="offset points", xytext=(6, 6), fontsize=8) ax.set_xlabel("t-SNE 1", fontsize=12) ax.set_ylabel("t-SNE 2", fontsize=12) ax.set_title( f"Good Teeth t-SNE (from first {d_tsne} PCs, perplexity={perp:.1f})", fontsize=14, ) ax.legend(fontsize=11) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "good_teeth_tsne.png"), dpi=200) plt.close(fig) print("Saved good_teeth_tsne.png") # ── t-SNE directly on full feature vectors (no PCA reduction) ─ if not args.no_tsne and n_teeth >= 3: max_perp = max(2.0, float(n_teeth - 1) - 1e-6) perp = float(np.clip(args.tsne_perplexity, 2.0, max_perp)) n_feat = X.shape[1] print(f"\nRunning t-SNE on raw features ({n_feat}D, 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) fig, ax = plt.subplots(figsize=(9, 7)) for src, marker, color in [("Part 1", "o", "#4C72B0"), ("Part 2", "s", "#DD8452")]: idx = [i for i, s in enumerate(sources) if s == src] if not idx: continue ax.scatter(Z2[idx, 0], Z2[idx, 1], c=color, marker=marker, s=120, edgecolors="k", linewidths=0.5, label=src, zorder=3) for i, lbl in enumerate(labels): ax.annotate(lbl, (Z2[i, 0], Z2[i, 1]), textcoords="offset points", xytext=(6, 6), fontsize=8) ax.set_xlabel("t-SNE 1", fontsize=12) ax.set_ylabel("t-SNE 2", fontsize=12) ax.set_title( f"Good Teeth t-SNE (full {n_feat}D features, perplexity={perp:.1f})", fontsize=14, ) ax.legend(fontsize=11) ax.grid(True, alpha=0.3) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "good_teeth_tsne_raw.png"), dpi=200) plt.close(fig) print("Saved good_teeth_tsne_raw.png") # ── Plot 4: Clustering + silhouette analysis ────────────────── # Default sweep: k = 2 .. min(5, n_teeth-1) (same as old range(2, min(n_teeth, 6))) k_hi_sweep = min(n_teeth - 1, 5) if args.k_means_k is not None: if args.k_means_k < 2 or args.k_means_k > n_teeth - 1: sys.exit(f"--k-means-k must be between 2 and {n_teeth - 1} (n_teeth={n_teeth})") k_hi_sweep = max(k_hi_sweep, args.k_means_k) k_range = range(2, k_hi_sweep + 1) sil_scores = [] cluster_results = {} pca_dims = min(5, n_components) for k in k_range: km = KMeans(n_clusters=k, n_init=20, random_state=args.seed) cluster_labels = km.fit_predict(scores[:, :pca_dims]) s = silhouette_score(scores[:, :pca_dims], cluster_labels) sil_scores.append(s) cluster_results[k] = cluster_labels print(f" k={k}: silhouette={s:.3f}") if args.k_means_k is not None: best_k = args.k_means_k best_labels = cluster_results[best_k] print(f"Using k={best_k} (--k-means-k); silhouette={sil_scores[list(k_range).index(best_k)]:.3f}") else: best_k = list(k_range)[int(np.argmax(sil_scores))] best_labels = cluster_results[best_k] print(f"Best k={best_k} (silhouette={max(sil_scores):.3f})") fig, (ax_sil, ax_clust) = plt.subplots(1, 2, figsize=(14, 6)) ax_sil.plot(list(k_range), sil_scores, "o-", linewidth=2, color="#4C72B0") vline_label = f"k={best_k} (fixed)" if args.k_means_k is not None else f"Best k={best_k}" ax_sil.axvline(best_k, linestyle="--", color="#C44E52", alpha=0.7, label=vline_label) ax_sil.set_xlabel("Number of Clusters (k)", fontsize=12) ax_sil.set_ylabel("Silhouette Score", fontsize=12) ax_sil.set_title("Silhouette Analysis", fontsize=13) ax_sil.legend(fontsize=11) ax_sil.grid(True, alpha=0.3) cmap = plt.cm.Set2 for ci in range(best_k): idx = np.where(best_labels == ci)[0] ax_clust.scatter(scores[idx, 0], scores[idx, 1], c=[cmap(ci)] * len(idx), s=120, edgecolors="k", linewidths=0.5, label=f"Cluster {ci+1}", zorder=3) for i, lbl in enumerate(labels): ax_clust.annotate(lbl, (scores[i, 0], scores[i, 1]), textcoords="offset points", xytext=(6, 6), fontsize=8) ax_clust.set_xlabel(f"PC1 ({var_ratio[0]*100:.1f}%)", fontsize=12) ax_clust.set_ylabel(f"PC2 ({var_ratio[1]*100:.1f}%)", fontsize=12) ax_clust.set_title(f"K-Means Clustering (k={best_k})", fontsize=13) ax_clust.legend(fontsize=10) ax_clust.grid(True, alpha=0.3) fig.suptitle(f"Good Teeth Clustering ({n_teeth} specimens)", fontsize=14, y=1.01) fig.tight_layout() fig.savefig(os.path.join(PLOT_DIR, "good_teeth_clusters.png"), dpi=200, bbox_inches="tight") plt.close(fig) print("Saved good_teeth_clusters.png") print(f"\nAll plots saved to {PLOT_DIR}/") if __name__ == "__main__": main()