"""926/D — one-view qualitative grid: chair, guitar, helicopter, elephant x {ground truth, paired EEG, same-category swap, target-category mean, wrong-category mean}. Protocol of the existing Fig. 3 columns: sub01, 200k checkpoint, 200 denoising steps, figure seed 20260716, the same six-object batch, seed reset before every condition (so all columns share their initial noise); wrong = (c + 1) mod 72. One view per cell (elev 25, azim 35, the front view of the existing figure), white background, no shadow / second point layer. All six generated objects are saved; the four figure rows are fixed in advance (no selection). """ import argparse import json import sys from pathlib import Path import numpy as np REFS = Path("/home/hubin/workspace/July/brain3d_refs") BATCH = ["01_airplane_08", "15_chair_08", "27_guitar_08", "29_helicopter_08", "21_elephant_08", "14_cat_08"] ROWS = ["15_chair_08", "27_guitar_08", "29_helicopter_08", "21_elephant_08"] CONDS = [("real", "paired EEG", (0.12, 0.35, 0.70)), ("same_category_swap", "same-cat swap", (0.20, 0.55, 0.30)), ("category_mean", "target-cat mean", (0.55, 0.25, 0.65)), ("wrong_category_mean", "wrong-cat mean", (0.88, 0.48, 0.00))] ELEV, AZIM = 25, 35 def generate(out, subject, steps, seed): import torch sys.path.insert(0, str(REFS / "third_party" / "neuro-3D")) sys.path.insert(0, str(REFS / "scripts")) import evaluate_shape_diffusion_controls as ev ev.ROOT, ev.REPO, ev.DATA = REFS, REFS / "third_party" / "neuro-3D", REFS / "data" / "EEG-3D" data = ev.DATA device = torch.device("cuda") ckpt = data / "model/point_generate/shape" / subject / "resumable_200000steps/checkpoint-200000.pth" model = ev.EEGTo3DDiffusionModel( beta_start=1e-5, beta_end=8e-3, beta_schedule="linear", sub=subject, generate_type="shape", retri_pretrain_model=f"{data}/model/retraival/{subject}/{ev.encoder_name(int(subject[3:]))}/", point_cloud_model_embed_dim=64, in_channels=1027, out_channels=3) model.load_state_dict(torch.load(ckpt, map_location="cpu", weights_only=False)["model"]) model.eval().to(device) test = ev.AllDataFeatureTwoEEG(f"{data}/", sub_list=[subject], train=False, test_mean=True, aug_data=False, load_point_cloud=True) train = ev.AllDataFeatureTwoEEG(f"{data}/", sub_list=[subject], train=True, aug_data=False, load_point_cloud=False) items = [test[i] for i in range(len(test))] by_name = {str(it["name"]): it for it in items} mdyn = torch.from_numpy(train.eeg_data[0].mean(axis=(1, 2))).float() msta = torch.from_numpy(train.eeg_data2[0].mean(axis=(1, 2))).float() all_pf = test.color_point_features[:, 0].float().to(device) all_vf = test.color_video_features[:, 0].float().to(device) sel = [by_name[n] for n in BATCH] out.mkdir(parents=True, exist_ok=True) for cond, _, _ in CONDS: cb = ev.condition_batch(sel, cond, items, mdyn, msta) torch.manual_seed(seed); torch.cuda.manual_seed_all(seed) feats = {"point_features": cb["color_point_fea"].float().to(device), "video_features": cb["color_video_fea"].float().to(device), "point_features_all": all_pf, "video_features_all": all_vf} with torch.inference_mode(): pred, _ = model(cb["point_cloud"].float()[:, :, :3].to(device), cb["eeg_data"].float().to(device), cb["eeg_data2"].float().to(device), mode="sample", shape_c=None, fea_list=feats, labels=cb["cls_label"].to(device), return_sample_every_n_steps=-1, num_inference_steps=steps, disable_tqdm=True) pred = pred.float().cpu().numpy() for i, n in enumerate(BATCH): np.save(out / f"{n}__{cond}.npy", pred[i]) print(f"D render generated {cond}", flush=True) for n in BATCH: np.save(out / f"{n}__gt.npy", np.asarray(by_name[n]["point_cloud"])[:, :3]) def norm(x): x = np.asarray(x, np.float64)[:, :3] x = x - x.mean(0) return x / max(np.linalg.norm(x, axis=1).max(), 1e-8) def chamfer_l1(a, b): from scipy.spatial import cKDTree return float(cKDTree(b).query(a)[0].mean() + cKDTree(a).query(b)[0].mean()) def panel(ax, pts, rgb): phi, th = np.deg2rad(90 - ELEV), np.deg2rad(AZIM) cam = np.array([np.sin(phi) * np.cos(th), np.sin(phi) * np.sin(th), np.cos(phi)]) p = pts[:, [0, 2, 1]] depth = p @ cam t = ((depth - depth.min()) / max(np.ptp(depth), 1e-8)) ** 0.85 base = np.array(rgb) col = (base * 0.35)[None] * (1 - t[:, None]) + np.clip(base + (1 - base) * 0.55, 0, 1)[None] * t[:, None] o = np.argsort(depth) ax.scatter(p[o, 0], p[o, 1], p[o, 2], c=col[o], s=0.6, alpha=0.95, linewidths=0, depthshade=False) for f in (ax.set_xlim, ax.set_ylim, ax.set_zlim): f(-1.0, 1.0) ax.set_box_aspect((1, 1, 1)); ax.view_init(elev=ELEV, azim=AZIM); ax.set_axis_off(); ax.set_facecolor("white") def main(): ap = argparse.ArgumentParser() ap.add_argument("--subject", default="sub01") ap.add_argument("--steps", type=int, default=200) ap.add_argument("--seed", type=int, default=20260716) ap.add_argument("--out", default="/home/hubin/926/results/D") ap.add_argument("--skip-generate", action="store_true") a = ap.parse_args() out = Path(a.out); pcd = out / "qualitative_pointclouds" if not a.skip_generate: generate(pcd, a.subject, a.steps, a.seed) import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt cols = [("gt", "ground truth", (0.35, 0.35, 0.35))] + CONDS fig = plt.figure(figsize=(2.0 * len(cols), 2.0 * len(ROWS)), facecolor="white") check = {} gts = {n: norm(np.load(pcd / f"{n}__gt.npy")) for n in BATCH} for r, n in enumerate(ROWS): cat = n.split("_")[1] for c, (cond, label, rgb) in enumerate(cols): ax = fig.add_subplot(len(ROWS), len(cols), r * len(cols) + c + 1, projection="3d") pts = norm(np.load(pcd / f"{n}__{cond}.npy")) panel(ax, pts, rgb) if r == 0: ax.set_title(label, fontsize=9) if c == 0: ax.text2D(-0.08, 0.5, cat, transform=ax.transAxes, rotation=90, va="center", fontsize=9) plt.subplots_adjust(left=0.03, right=0.99, top=0.95, bottom=0.01, wspace=0.0, hspace=0.0) fig.savefig(out / "qualitative_oneview.png", dpi=220, facecolor="white") fig.savefig(out / "qualitative_oneview.pdf", facecolor="white") # non-visual check: distance of every generation to the target GT and to the wrong category's held-out objects for n in BATCH: c = int(n.split("_")[0]) - 1 wrong = [k for k in gts if int(k.split("_")[0]) - 1 == (c + 1) % 72] check[n] = {} for cond, _, _ in CONDS: pts = norm(np.load(pcd / f"{n}__{cond}.npy")) check[n][cond] = {"to_target_gt": chamfer_l1(pts, gts[n]), "to_paired_generation": chamfer_l1(pts, norm(np.load(pcd / f"{n}__real.npy")))} json.dump({"rows": ROWS, "batch": BATCH, "subject": a.subject, "steps": a.steps, "seed": a.seed, "view": {"elev": ELEV, "azim": AZIM}, "check_chamfer_l1_pcnorm": check}, open(out / "qualitative_check.json", "w"), indent=1) print(json.dumps({n: {k: round(v["to_target_gt"], 3) for k, v in check[n].items()} for n in ROWS}), flush=True) if __name__ == "__main__": main()