Deploy MindVisualizer live runtime

.dockerignore

@@ -0,0 +1,8 @@
+.git
+.idea
+.venv
+__pycache__
+*.pyc
+*.pyo
+.env
+data/meshes

.gitattributes

@@ -1,35 +1,6 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
+*.obj filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
 *.npy filter=lfs diff=lfs merge=lfs -text
 *.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.ply filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+*.pyo
+.env

Dockerfile

@@ -0,0 +1,39 @@
+FROM python:3.11-slim
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    DISPLAY=:99 \
+    LIBGL_ALWAYS_SOFTWARE=1 \
+    MESA_GL_VERSION_OVERRIDE=3.3 \
+    PIP_NO_CACHE_DIR=1 \
+    PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    libegl1 \
+    libgl1 \
+    libgl1-mesa-dri \
+    libglib2.0-0 \
+    libglu1-mesa \
+    libsm6 \
+    libx11-6 \
+    libxext6 \
+    libxrender1 \
+    libxt6 \
+    xvfb \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app/mindVisualizer
+COPY . /app/mindVisualizer
+
+RUN python -m pip install --upgrade pip setuptools wheel && \
+    python -m pip install \
+      numpy scipy vtk \
+      langchain langchain-openai langchain-community \
+      faiss-cpu python-dotenv certifi tiktoken openai \
+      brainglobe-atlasapi nibabel nilearn scikit-image \
+      trame trame-vtk trame-vuetify && \
+    chmod +x /app/mindVisualizer/start.sh
+
+EXPOSE 7860
+
+CMD ["/app/mindVisualizer/start.sh"]

README.md

@@ -1,10 +1,11 @@
----
-title: Mindvisualizer Vtk
-emoji: 😻
-colorFrom: purple
-colorTo: green
+---
+title: MindVisualizer Live
+colorFrom: green
+colorTo: blue
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MindVisualizer Live
+
+Runs the Python/VTK MindVisualizer runtime through a Trame web transport.

app.py

@@ -0,0 +1,676 @@
+#!/usr/bin/env python3
+"""HF-safe live MindVisualizer wrapper.
+
+This is a web transport for the Python/VTK runtime. It imports the original
+project modules for field loading, particle helpers, mesh overlay, probes, and
+GPT analysis instead of reimplementing the algorithms in TypeScript.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+import sys
+import threading
+from pathlib import Path
+
+import numpy as np
+import vtk
+from scipy.spatial import cKDTree
+from vtkmodules.util.numpy_support import numpy_to_vtk
+from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+DATA_DIR = PROJECT_ROOT / "data"
+MDN_DIR = DATA_DIR / "mdn"
+MESH_DIR = DATA_DIR / "meshes"
+ALIGNMENT_FILE = DATA_DIR / "brain_alignment.json"
+DEFAULT_META = MDN_DIR / "mdn_particles_rdcim_teacher_edge_hq_grid125_meta.json"
+DEFAULT_OOS = MDN_DIR / "mdn_particles_rdcim_teacher_edge_hq_training_points.npy"
+
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from src.colormaps import bicolor_white_center, rainbow_rgb01, turbo_rgb01
+from src.field_loader import TriLinearSampler, load_field, load_points_any
+from src.main import (
+    VtkTextOverlay,
+    add_window_legend,
+    build_cloud,
+    compute_fraction_mask,
+    densify_oos_surface,
+    lattice_positions,
+    wrap_inside,
+)
+from src.mesh_overlay import FlowMeshOverlay
+from src.probe import ProbeSystem
+from src.region_analyzer import analyze_probe_path, analyze_with_gpt
+
+
+def ensure_ssl() -> None:
+    try:
+        import certifi
+
+        cert_file = certifi.where()
+        for name in ("SSL_CERT_FILE", "REQUESTS_CA_BUNDLE"):
+            current = os.environ.get(name, "")
+            if not current or not os.path.isfile(current):
+                os.environ[name] = cert_file
+    except Exception:
+        pass
+
+
+class LiveMindVisualizer:
+    def __init__(self, args: argparse.Namespace):
+        self.args = args
+        self.rng = np.random.default_rng(2025)
+        self.paused = False
+        self.field_mode = "mean"
+        self.colour_mode = "SPEED"
+        self.cmap_mode = "TURBO"
+        self.filter_mode = "OFF"
+        self.filter_top = True
+        self.filter_frac = 1.0
+        self.clip_on = False
+        self.clip_frac = 1.0
+        self.mdn_alpha = 1.0
+        self.oos_visible = False
+        self.probe_busy = False
+        self.gpt_pending: str | None = None
+        self._load_data()
+        self._setup_vtk()
+
+    def _load_data(self) -> None:
+        self.field = load_field(self.args.meta)
+        self.G = self.field["G"]
+        self.amin = self.field["amin"]
+        self.amax = self.field["amax"]
+        self.V_mean = self.field["mean"]
+        self.MUS = self.field["mus"]
+        self.PI = self.field["pi"]
+        self.ENT = self.field["ENT"]
+        self.K = len(self.MUS)
+
+        self.sampler_mean = TriLinearSampler(self.V_mean, self.amin, self.amax)
+        self.diag = float(np.linalg.norm(self.amax - self.amin))
+        self.target_step = self.args.max_step_frac * max(self.diag, 1e-6)
+        self.vmax_mean = self._interior_percentile(self.V_mean)
+
+        self.samplers_comp = [TriLinearSampler(mu, self.amin, self.amax) for mu in self.MUS]
+        self.sampler_gated = None
+        self.V_gated = None
+        if self.PI is not None and self.PI.ndim == 4 and self.PI.shape[-1] == self.K and self.K > 0:
+            idx = np.argmax(self.PI, axis=-1)
+            self.V_gated = np.zeros_like(self.MUS[0], dtype=np.float32)
+            for k_i in range(self.K):
+                self.V_gated += self.MUS[k_i] * (idx == k_i)[..., None].astype(np.float32)
+            self.sampler_gated = TriLinearSampler(self.V_gated, self.amin, self.amax)
+
+        self.field_modes = ["mean"]
+        if self.sampler_gated is not None:
+            self.field_modes.append("gated")
+        self.field_modes += [f"comp{i + 1}" for i in range(self.K)]
+
+        self.sampler_by_name = {"mean": self.sampler_mean}
+        if self.sampler_gated is not None:
+            self.sampler_by_name["gated"] = self.sampler_gated
+        for i, sampler in enumerate(self.samplers_comp):
+            self.sampler_by_name[f"comp{i + 1}"] = sampler
+
+        self.vmax_by_name = {"mean": self.vmax_mean}
+        if self.V_gated is not None:
+            self.vmax_by_name["gated"] = self._interior_percentile(self.V_gated)
+        for i, mu in enumerate(self.MUS):
+            self.vmax_by_name[f"comp{i + 1}"] = self._interior_percentile(mu)
+
+        self.ent_min = self.ent_max = 0.0
+        if self.ENT is not None:
+            self.ent_min = float(np.min(self.ENT))
+            self.ent_max = float(np.max(self.ENT))
+
+        self.oos_pts = None
+        if self.args.oos is not None and Path(self.args.oos).exists():
+            self.oos_pts = load_points_any(Path(self.args.oos)).astype(np.float32)
+
+        self._seed_particles()
+        self._prepare_oos_distance()
+
+    def _interior_percentile(self, vec: np.ndarray, q: float = 100.0) -> float:
+        mag = np.linalg.norm(vec.reshape(-1, 3), axis=1)
+        nz = mag[mag > 0]
+        return float(np.percentile(nz, q)) if nz.size else 1.0
+
+    def _seed_particles(self) -> None:
+        overlap_radius = float(self.args.overlap_frac) * max(self.diag, 1e-9)
+        overlap_sigma = float(self.args.overlap_jitter) * max(self.diag, 1e-9)
+        self.seed_mode = "grid"
+        self.seed_points = None
+        self.n_axis = None
+
+        train = self.field["TRAIN"]
+        if train is not None and self.oos_pts is not None and len(train) > 0 and len(self.oos_pts) > 0:
+            try:
+                tree = cKDTree(train.astype(np.float32))
+                dists, _ = tree.query(self.oos_pts.astype(np.float32), k=1)
+                candidates = self.oos_pts[dists <= overlap_radius]
+                if candidates.size > 0:
+                    self.seed_mode = "overlap"
+                    if self.args.overlap_limit and len(candidates) > self.args.overlap_limit:
+                        idx = self.rng.choice(len(candidates), size=int(self.args.overlap_limit), replace=False)
+                        candidates = candidates[idx]
+                    self.seed_points = candidates.astype(np.float32)
+            except Exception as exc:
+                print("[seed] overlap failed:", exc)
+
+        if self.seed_mode == "overlap" and self.seed_points is not None:
+            if self.args.oos_seed_limit > 0 and len(self.seed_points) > self.args.oos_seed_limit:
+                idx = self.rng.choice(len(self.seed_points), size=self.args.oos_seed_limit, replace=False)
+                self.seed_points = self.seed_points[idx]
+            if self.args.oos_fill_count > 0 and self.oos_pts is not None:
+                extras = densify_oos_surface(
+                    base_pts=self.seed_points,
+                    full_oos_pts=self.oos_pts,
+                    amin=self.amin,
+                    amax=self.amax,
+                    extra_count=self.args.oos_fill_count,
+                )
+                if extras is not None and len(extras) > 0:
+                    self.seed_points = np.concatenate([self.seed_points, extras], axis=0).astype(np.float32)
+
+        if self.seed_mode == "overlap" and self.seed_points is not None:
+            if overlap_sigma > 0:
+                jitter = self.rng.standard_normal(self.seed_points.shape).astype(np.float32) * overlap_sigma
+                self.P0 = np.clip(self.seed_points + jitter, self.amin, self.amax)
+            else:
+                self.P0 = np.clip(self.seed_points, self.amin, self.amax)
+        else:
+            self.n_axis = max(2, self.G // max(1, self.args.stride))
+            self.P0 = lattice_positions(
+                self.n_axis,
+                self.amin,
+                self.amax,
+                margin=0.02,
+                jitter=self.args.respawn_jitter,
+                seed=2025,
+            )
+
+        self.P = self.P0.copy()
+        self.Np = len(self.P)
+        self.base_ttl_lo = max(8, 60 // 2)
+        self.base_ttl_hi = 60
+        self.ttl_scale = 1.0
+        self.ttl = self._sample_ttl(self.Np)
+        self.ages = self.rng.integers(0, np.maximum(1, self.ttl), size=self.Np, dtype=np.int32)
+        self.ent_prev = self.sampler_mean.sample_scalar(self.ENT, self.P).astype(np.float32) if self.ENT is not None else None
+        self.ent_d_ema = np.zeros(self.Np, np.float32) if self.ENT is not None else None
+
+    def _sample_ttl(self, n: int) -> np.ndarray:
+        base = self.rng.integers(self.base_ttl_lo, self.base_ttl_hi + 1, size=int(n))
+        return np.maximum(1, np.round(base * self.ttl_scale)).astype(np.int32)
+
+    def _prepare_oos_distance(self) -> None:
+        self.OOS_DIST = None
+        self.sampler_oosdist = None
+        self.far_oos_params = None
+        if self.args.no_far_from_oos or self.oos_pts is None or len(self.oos_pts) == 0:
+            return
+        Ng = int(max(8, self.args.oos_dist_grid))
+        tree_oos = cKDTree(self.oos_pts.astype(np.float32))
+        gridP = lattice_positions(Ng, self.amin, self.amax, margin=0.0, jitter=0.0, seed=0)
+        dists, _ = tree_oos.query(gridP, k=1)
+        self.OOS_DIST = dists.reshape(Ng, Ng, Ng).astype(np.float32)
+        self.sampler_oosdist = TriLinearSampler(np.zeros((Ng, Ng, Ng, 3), np.float32), self.amin, self.amax)
+        self.far_oos_params = {
+            "d0": float(self.args.oos_dist_thresh_frac) * self.diag,
+            "gamma": float(self.args.oos_dist_gamma),
+            "boost": float(self.args.oos_death_boost),
+        }
+
+    def _setup_vtk(self) -> None:
+        init_rgba = np.tile(np.array([[255, 255, 255, 48]], np.uint8), (self.Np, 1))
+        self.points, self.color_arr, self.poly, self.p_actor = build_cloud(self.P, point_size=2.0, rgba=init_rgba)
+
+        self.ren = vtk.vtkRenderer()
+        self.ren.SetBackground(0, 0, 0)
+        self.ren.AddActor(self.p_actor)
+
+        self.win = vtk.vtkRenderWindow()
+        self.win.SetOffScreenRendering(1)
+        self.win.AddRenderer(self.ren)
+        self.win.SetSize(self.args.window_size[0], self.args.window_size[1])
+        self.win.SetWindowName("mindVisualizer Live")
+
+        self.iren = vtk.vtkRenderWindowInteractor()
+        self.iren.SetRenderWindow(self.win)
+        self.iren.SetInteractorStyle(vtkInteractorStyleTrackballCamera())
+        self.iren.Initialize()
+
+        self.o_actor = None
+        if self.oos_pts is not None and len(self.oos_pts) > 0:
+            rgb_oos = np.tile(np.array([[255, 255, 255]], np.uint8), (len(self.oos_pts), 1))
+            oos_rgba = np.concatenate([rgb_oos, np.full((len(self.oos_pts), 1), 72, np.uint8)], axis=1)
+            _, _, _, self.o_actor = build_cloud(self.oos_pts, point_size=1.5, rgba=oos_rgba, opacity=72 / 255.0)
+
+        self.flow_mesh = None
+        try:
+            self.flow_mesh = FlowMeshOverlay(ren=self.ren, win=self.win, mesh_dir=MESH_DIR, alignment_file=ALIGNMENT_FILE)
+            grid_cache = DATA_DIR / "label_grid_cache.npz"
+            if not self.flow_mesh.load_label_grid(grid_cache):
+                self.flow_mesh.build_label_grid()
+                self.flow_mesh.save_label_grid(grid_cache)
+            if self.flow_mesh.get_all_region_keys():
+                self.flow_mesh.cycle(+1)
+        except Exception as exc:
+            print("[flow mesh] disabled:", exc)
+
+        self.text_overlay = VtkTextOverlay(self.ren)
+        self.probe_sys = ProbeSystem(self.ren, self.win, self.amin, self.amax)
+        if self.flow_mesh is not None:
+            self.probe_sys.set_mesh_overlay(self.flow_mesh)
+        self.probe_sys.set_multi_count(self.args.multi_probe)
+        if self.args.branching and self.PI is not None:
+            self.probe_sys.set_branching(True, pi_field=self.PI, mus_samplers=self.samplers_comp)
+
+        add_window_legend(
+            self.ren,
+            [
+                "mindVisualizer live Python/VTK",
+                "space pause | f field | v colour | m cmap | q/w mesh | hide",
+                "[ ] dt | +/- speed | 1/2 lifetime | 7/8 alpha | y/u/z/x filter",
+                "o OOS | j clip | a/d frac | probe | analyze | clear",
+            ],
+            font_px=12,
+        )
+        self.ren.ResetCamera()
+        for _ in range(12):
+            V = self.sampler_mean.sample_vec(self.P)
+            self.P = wrap_inside(
+                self.P + V * (self.args.dt * self.args.speed_scale) * (self.target_step / max(self.vmax_mean, 1e-9)),
+                self.amin,
+                self.amax,
+                margin_frac=self.args.margin,
+            )
+        if self.ENT is not None:
+            self.ent_prev = self.sampler_mean.sample_scalar(self.ENT, self.P).astype(np.float32)
+            self.ent_d_ema[:] = 0.0
+        self.win.Render()
+
+    def current_sampler(self) -> TriLinearSampler:
+        return self.sampler_by_name.get(self.field_mode, self.sampler_mean)
+
+    def vmax_for_mode(self) -> float:
+        return self.vmax_by_name.get(self.field_mode, self.vmax_mean)
+
+    def map_rgb_from_t(self, t01: np.ndarray) -> np.ndarray:
+        return rainbow_rgb01(t01) if self.cmap_mode == "RAINBOW" else turbo_rgb01(t01)
+
+    def apply_colors(self, speed_vals: np.ndarray, P_world: np.ndarray, dent_vals=None, vis_mask=None) -> None:
+        eps = 1e-12
+        if self.colour_mode == "ENTROPY" and self.ENT is not None:
+            scal = self.sampler_mean.sample_scalar(self.ENT, P_world)
+            t = (scal - self.ent_min) / max(self.ent_max - self.ent_min, eps)
+            base_rgb = self.map_rgb_from_t(np.clip(t, 0, 1))
+        elif self.colour_mode == "DELTA_ENTROPY" and dent_vals is not None:
+            a = np.abs(dent_vals)
+            scale = float(np.percentile(a, 97)) if a.size else 1.0
+            if not np.isfinite(scale) or scale <= eps:
+                scale = 1.0
+            base_rgb = self.map_rgb_from_t(np.clip(a / scale, 0, 1))
+        elif self.colour_mode == "DIR_DELTA_ENTROPY" and dent_vals is not None:
+            base_rgb = bicolor_white_center(dent_vals)
+        else:
+            smin = float(np.min(speed_vals)) if speed_vals.size else 0.0
+            smax = float(np.max(speed_vals)) if speed_vals.size else 1.0
+            t = (speed_vals - smin) / max(smax - smin, eps)
+            base_rgb = self.map_rgb_from_t(np.clip(t, 0, 1))
+
+        alpha = int(np.clip(255.0 * self.mdn_alpha, 5, 255))
+        a = np.full(len(base_rgb), alpha, np.uint8)
+        if vis_mask is not None:
+            a = a.copy()
+            a[~vis_mask] = 0
+        rgba = np.concatenate([base_rgb, a[:, None]], axis=1).astype(np.uint8)
+        self.color_arr.DeepCopy(numpy_to_vtk(rgba, deep=True))
+        self.color_arr.Modified()
+        self.poly.Modified()
+
+    def step(self) -> None:
+        if self.gpt_pending is not None:
+            result = self.gpt_pending
+            self.gpt_pending = None
+            self.probe_busy = False
+            self.text_overlay.show_gpt(result)
+            self.text_overlay.add_log("GPT analysis complete")
+
+        if self.paused:
+            self.win.Render()
+            return
+
+        sampler = self.current_sampler()
+        Vraw = sampler.sample_vec(self.P)
+        vmx = float(self.vmax_for_mode())
+        if self.clip_on:
+            thr = float(max(1e-9, self.clip_frac * vmx))
+            speed = np.linalg.norm(Vraw, axis=1)
+            k = np.minimum(1.0, thr / (speed + 1e-9)).astype(np.float32)
+            Vstep = Vraw * k[:, None]
+            eff_vmax = min(vmx, thr)
+        else:
+            Vstep = Vraw
+            eff_vmax = vmx
+
+        step_size = self.args.dt * self.args.speed_scale * (self.target_step / max(eff_vmax, 1e-9))
+        self.P = wrap_inside(self.P + Vstep * step_size, self.amin, self.amax, margin_frac=self.args.margin)
+
+        dent = None
+        if self.ENT is not None:
+            ent_now = self.sampler_mean.sample_scalar(self.ENT, self.P).astype(np.float32)
+            d = ent_now - self.ent_prev
+            self.ent_d_ema = (1.0 - 0.2) * self.ent_d_ema + 0.2 * d
+            self.ent_prev = ent_now
+            dent = self.ent_d_ema
+
+        age_inc = np.ones(len(self.P), np.int32)
+        if self.sampler_oosdist is not None and self.OOS_DIST is not None and self.far_oos_params is not None:
+            d_oos = self.sampler_oosdist.sample_scalar(self.OOS_DIST, self.P).astype(np.float32)
+            d0 = max(1e-9, self.far_oos_params["d0"])
+            t = np.clip((d_oos - d0) / d0, 0.0, 1.0)
+            gate = np.power(t, float(max(0.1, self.far_oos_params["gamma"]))).astype(np.float32)
+            age_inc += np.floor(gate * float(max(0.0, self.far_oos_params["boost"])) + 1e-9).astype(np.int32)
+        self.ages += age_inc
+
+        dead = self.ages >= self.ttl
+        if np.any(dead):
+            if self.seed_mode == "overlap" and self.seed_points is not None and len(self.seed_points) > 0:
+                sel = self.rng.integers(0, len(self.seed_points), size=dead.sum())
+                base = self.seed_points[sel]
+                if self.args.overlap_jitter > 0:
+                    sigma = float(self.args.overlap_jitter) * max(self.diag, 1e-9)
+                    jitter = self.rng.standard_normal((dead.sum(), 3)).astype(np.float32) * sigma
+                    self.P[dead] = np.clip(base + jitter, self.amin, self.amax)
+                else:
+                    self.P[dead] = np.clip(base, self.amin, self.amax)
+            else:
+                jitter_world = (self.amax - self.amin) * (self.args.respawn_jitter / max((self.n_axis or 2) - 1, 1))
+                jitter = (self.rng.random((dead.sum(), 3)).astype(np.float32) - 0.5) * 2.0 * jitter_world
+                self.P[dead] = np.clip(self.P0[dead] + jitter, self.amin, self.amax)
+            self.ages[dead] = 0
+            self.ttl[dead] = self._sample_ttl(dead.sum())
+            if self.ENT is not None:
+                self.ent_prev[dead] = self.sampler_mean.sample_scalar(self.ENT, self.P[dead]).astype(np.float32)
+                self.ent_d_ema[dead] = 0.0
+
+        if self.probe_sys.active:
+            self.probe_sys.step(sampler, step_size)
+
+        speed = np.linalg.norm(Vstep, axis=1)
+        if self.filter_mode == "OFF":
+            vis_mask = np.ones(len(self.P), dtype=bool)
+        else:
+            vis_mask = compute_fraction_mask(speed, self.filter_frac, top=self.filter_top)
+
+        self.points.SetData(numpy_to_vtk(self.P, deep=True))
+        self.points.Modified()
+        self.apply_colors(speed, self.P, dent_vals=dent, vis_mask=vis_mask)
+        self.win.Render()
+
+    def cycle_field(self) -> str:
+        idx = self.field_modes.index(self.field_mode)
+        self.field_mode = self.field_modes[(idx + 1) % len(self.field_modes)]
+        return self.field_mode
+
+    def cycle_colour(self) -> str:
+        modes = ["SPEED"]
+        if self.ENT is not None:
+            modes += ["ENTROPY", "DELTA_ENTROPY", "DIR_DELTA_ENTROPY"]
+        idx = modes.index(self.colour_mode) if self.colour_mode in modes else 0
+        self.colour_mode = modes[(idx + 1) % len(modes)]
+        return self.colour_mode
+
+    def place_probe_center(self) -> None:
+        pos = ((self.amin + self.amax) * 0.5).astype(np.float32)
+        self.probe_sys.place(pos)
+        self.text_overlay.add_log("Probe placed at brain center")
+
+    def analyze_probe(self, use_rag: bool) -> None:
+        if not self.probe_sys.active or self.flow_mesh is None or self.probe_busy:
+            self.text_overlay.add_log("No probe ready to analyze")
+            return
+        self.probe_sys.freeze()
+        snapshots = []
+        for probe in self.probe_sys.get_all_probes():
+            if not probe.path or len(probe.path) < 3:
+                continue
+            snapshots.append(
+                {
+                    "path": probe.get_path_array().copy(),
+                    "field_mags": probe.get_field_mags_array().copy(),
+                    "ghost": probe.ghost,
+                    "label": probe.label,
+                }
+            )
+        if not snapshots:
+            self.text_overlay.add_log("No probe data")
+            return
+        self.probe_busy = True
+        self.text_overlay.add_log("Analyzing probe path...")
+        threading.Thread(target=self._analyze_async, args=(snapshots, use_rag), daemon=True).start()
+
+    def _analyze_async(self, snapshots, use_rag: bool) -> None:
+        try:
+            transitions = []
+            for snap in snapshots:
+                transitions.extend(
+                    analyze_probe_path(
+                        snap["path"],
+                        self.flow_mesh,
+                        sample_every=5,
+                        field_mags=snap["field_mags"] if len(snap["field_mags"]) == len(snap["path"]) else None,
+                        entropy_sampler=self.sampler_mean if self.ENT is not None else None,
+                        entropy_field=self.ENT,
+                    )
+                )
+            if not transitions:
+                self.gpt_pending = "No brain regions detected along probe path."
+                return
+            self.gpt_pending = analyze_with_gpt(transitions, use_rag=use_rag, model=self.args.model, debug=False)
+        except Exception as exc:
+            self.gpt_pending = f"[GPT ERROR] {exc}"
+
+    @property
+    def status(self) -> str:
+        mesh_count = len(self.flow_mesh.get_all_region_keys()) if self.flow_mesh else 0
+        return (
+            f"{self.field_mode} | {self.colour_mode} | "
+            f"{self.Np:,} particles | {mesh_count} meshes | "
+            f"{'paused' if self.paused else 'running'}"
+        )
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="MindVisualizer Trame live server")
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=int(os.environ.get("PORT", "7860")))
+    parser.add_argument("--meta", type=Path, default=DEFAULT_META)
+    parser.add_argument("--oos", type=Path, default=DEFAULT_OOS)
+    parser.add_argument("--fps", type=int, default=int(os.environ.get("MINDVIS_FPS", "18")))
+    parser.add_argument("--stride", type=int, default=3)
+    parser.add_argument("--dt", type=float, default=1.0)
+    parser.add_argument("--max-step-frac", type=float, default=0.01)
+    parser.add_argument("--speed-scale", type=float, default=1.0)
+    parser.add_argument("--margin", type=float, default=0.0)
+    parser.add_argument("--respawn-jitter", type=float, default=0.015)
+    parser.add_argument("--oos-seed-limit", type=int, default=50000)
+    parser.add_argument("--oos-fill-count", type=int, default=10000)
+    parser.add_argument("--overlap-frac", type=float, default=0.01)
+    parser.add_argument("--overlap-jitter", type=float, default=0.002)
+    parser.add_argument("--overlap-limit", type=int, default=200000)
+    parser.add_argument("--no-far-from-oos", action="store_true")
+    parser.add_argument("--oos-dist-grid", type=int, default=96)
+    parser.add_argument("--oos-dist-thresh-frac", type=float, default=0.009)
+    parser.add_argument("--oos-dist-gamma", type=float, default=3.0)
+    parser.add_argument("--oos-death-boost", type=float, default=8.0)
+    parser.add_argument("--multi-probe", type=int, default=1)
+    parser.add_argument("--branching", action="store_true")
+    parser.add_argument("--window-size", type=int, nargs=2, default=[1320, 820])
+    parser.add_argument("--model", default=os.environ.get("OPENAI_MODEL", "gpt-5.4-mini"))
+    parser.add_argument("--rag", action="store_true")
+    return parser
+
+
+def main() -> None:
+    ensure_ssl()
+    args = build_arg_parser().parse_args()
+
+    from trame.app import get_server
+    from trame.ui.vuetify3 import SinglePageLayout
+    from trame.widgets import html, vtk as vtk_widgets, vuetify3
+
+    app = LiveMindVisualizer(args)
+    server = get_server(client_type="vue3")
+    state, ctrl = server.state, server.controller
+    state.trame__title = "MindVisualizer Live"
+    state.status = app.status
+
+    def refresh_status() -> None:
+        state.status = app.status
+        state.flush()
+
+    def update_view() -> None:
+        if hasattr(ctrl, "view_update"):
+            ctrl.view_update()
+        refresh_status()
+
+    @ctrl.add("toggle_pause")
+    def toggle_pause(**_):
+        app.paused = not app.paused
+        update_view()
+
+    @ctrl.add("cycle_field")
+    def cycle_field(**_):
+        app.cycle_field()
+        update_view()
+
+    @ctrl.add("cycle_colour")
+    def cycle_colour(**_):
+        app.cycle_colour()
+        update_view()
+
+    @ctrl.add("cycle_cmap")
+    def cycle_cmap(**_):
+        app.cmap_mode = "RAINBOW" if app.cmap_mode == "TURBO" else "TURBO"
+        update_view()
+
+    @ctrl.add("mesh_prev")
+    def mesh_prev(**_):
+        if app.flow_mesh:
+            app.flow_mesh.cycle(-1)
+        update_view()
+
+    @ctrl.add("mesh_next")
+    def mesh_next(**_):
+        if app.flow_mesh:
+            app.flow_mesh.cycle(+1)
+        update_view()
+
+    @ctrl.add("mesh_hide")
+    def mesh_hide(**_):
+        if app.flow_mesh:
+            app.flow_mesh.hide()
+        update_view()
+
+    @ctrl.add("mesh_alpha_down")
+    def mesh_alpha_down(**_):
+        if app.flow_mesh:
+            app.flow_mesh.set_opacity(1.0 / 1.25)
+        update_view()
+
+    @ctrl.add("mesh_alpha_up")
+    def mesh_alpha_up(**_):
+        if app.flow_mesh:
+            app.flow_mesh.set_opacity(1.25)
+        update_view()
+
+    @ctrl.add("toggle_oos")
+    def toggle_oos(**_):
+        if app.o_actor is not None:
+            if app.oos_visible:
+                app.ren.RemoveActor(app.o_actor)
+            else:
+                app.ren.AddActor(app.o_actor)
+            app.oos_visible = not app.oos_visible
+        update_view()
+
+    @ctrl.add("place_probe")
+    def place_probe(**_):
+        app.place_probe_center()
+        update_view()
+
+    @ctrl.add("analyze_probe")
+    def analyze_probe(**_):
+        app.analyze_probe(use_rag=args.rag)
+        update_view()
+
+    @ctrl.add("clear_probe")
+    def clear_probe(**_):
+        app.probe_sys.clear()
+        app.text_overlay.clear_log()
+        app.text_overlay.hide_gpt()
+        update_view()
+
+    @ctrl.add("reset_camera")
+    def reset_camera(**_):
+        if hasattr(ctrl, "view_reset_camera"):
+            ctrl.view_reset_camera()
+        update_view()
+
+    async def animation_loop():
+        delay = 1.0 / max(1, int(args.fps))
+        while True:
+            app.step()
+            if hasattr(ctrl, "view_update"):
+                ctrl.view_update()
+            state.status = app.status
+            state.flush()
+            await asyncio.sleep(delay)
+
+    ctrl.on_server_ready.add(lambda **_: asyncio.create_task(animation_loop()))
+
+    with SinglePageLayout(server) as layout:
+        layout.title.set_text("MindVisualizer Live")
+        with layout.toolbar:
+            vuetify3.VBtn("Pause", click=ctrl.toggle_pause, density="compact", variant="tonal")
+            vuetify3.VBtn("Field", click=ctrl.cycle_field, density="compact", variant="tonal")
+            vuetify3.VBtn("Colour", click=ctrl.cycle_colour, density="compact", variant="tonal")
+            vuetify3.VBtn("Cmap", click=ctrl.cycle_cmap, density="compact", variant="tonal")
+            vuetify3.VDivider(vertical=True, classes="mx-2")
+            vuetify3.VBtn("Mesh -", click=ctrl.mesh_prev, density="compact", variant="tonal")
+            vuetify3.VBtn("Mesh +", click=ctrl.mesh_next, density="compact", variant="tonal")
+            vuetify3.VBtn("Hide", click=ctrl.mesh_hide, density="compact", variant="tonal")
+            vuetify3.VBtn("Alpha -", click=ctrl.mesh_alpha_down, density="compact", variant="tonal")
+            vuetify3.VBtn("Alpha +", click=ctrl.mesh_alpha_up, density="compact", variant="tonal")
+            vuetify3.VDivider(vertical=True, classes="mx-2")
+            vuetify3.VBtn("OOS", click=ctrl.toggle_oos, density="compact", variant="tonal")
+            vuetify3.VBtn("Probe", click=ctrl.place_probe, density="compact", variant="tonal")
+            vuetify3.VBtn("Analyze", click=ctrl.analyze_probe, density="compact", variant="tonal")
+            vuetify3.VBtn("Clear", click=ctrl.clear_probe, density="compact", variant="tonal")
+            vuetify3.VSpacer()
+            html.Div("{{ status }}", classes="text-caption text-medium-emphasis")
+
+        with layout.content:
+            with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height", style="background: #000;"):
+                view = vtk_widgets.VtkRemoteView(
+                    app.win,
+                    ref="view",
+                    interactive_ratio=0.65,
+                    interactive_quality=55,
+                )
+                ctrl.view_update = view.update
+                ctrl.view_reset_camera = view.reset_camera
+
+    server.start(host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

data/brain_alignment.json

@@ -0,0 +1,28 @@
+{
+  "matrix": [
+    [
+      -0.03483789662196803,
+      -0.1654855793300339,
+      0.9305766368497694,
+      -68.4377205759064
+    ],
+    [
+      -0.9422190580860553,
+      -0.06752555868994387,
+      -0.047281905216520856,
+      106.73199000287599
+    ],
+    [
+      0.0747101104018069,
+      -0.9287770749837014,
+      -0.16236864674663903,
+      115.80117022013123
+    ],
+    [
+      0.0,
+      0.0,
+      0.0,
+      1.0
+    ]
+  ]
+}

data/extra_parcellation/README.md

@@ -0,0 +1,53 @@
+# Extra Parcellation Data
+
+Provides fine-grained subregion labels alongside the primary Allen atlas meshes.
+
+## Setup (recommended)
+
+Run the setup script to build the combined atlas automatically:
+
+```bash
+python scripts/setup_extra_parcellation.py
+```
+
+This downloads and merges three complementary MNI-space atlases via nilearn:
+
+| Layer | Source | Regions | Role |
+|-------|--------|---------|------|
+| 1 | Harvard-Oxford Cortical | 48 | Broad cortical coverage |
+| 2 | Harvard-Oxford Subcortical | 17 | Thalamus, putamen, caudate, hippocampus, amygdala, etc. |
+| 3 | **Julich-Brain** (highest priority) | 62 | Cytoarchitectonic: motor BA4a/4p, somatosensory BA1-3, visual V1-V5, auditory, Broca's, hippocampal subfields |
+
+**Total: 127 labeled regions**, Julich-Brain labels override coarser Harvard-Oxford
+where available.
+
+Output files (auto-detected by flow mode):
+- `combined_atlas.nii.gz` — NIfTI volume (~700KB)
+- `combined_atlas_labels.json` — label ID to name map
+
+## How it works
+
+The combined atlas is in MNI152 1mm space. The Allen atlas scene space is
+approximately MNI-aligned, so probe coordinates can be used directly for lookups.
+When the exact voxel is unlabeled, a nearby-search fallback finds the closest
+labeled region within a few mm.
+
+When both the primary Allen mesh and the extra parcellation cover a probe position,
+both are highlighted: the Allen mesh in red, the extra parcellation subregion in
+orange. The subregion name is included in the LLM context as additional detail.
+
+## Custom atlas
+
+You can also provide any NIfTI atlas in MNI space:
+
+```bash
+python examples/flow_probe_example.py \
+    --extra-parcellation my_atlas.nii.gz \
+    --extra-parcellation-labels my_atlas_labels.json
+```
+
+## Requirements
+
+```bash
+pip install nilearn nibabel scikit-image
+```

data/extra_parcellation/combined_atlas.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68b7dbb0b9949e0e3021d60db9d6f1499615560cba955e0a2f6ab2e41962d25a
+size 693799

data/extra_parcellation/combined_atlas_labels.json

@@ -0,0 +1,129 @@
+{
+  "1": "Frontal Pole",
+  "2": "Insular Cortex",
+  "3": "Superior Frontal Gyrus",
+  "4": "Middle Frontal Gyrus",
+  "5": "Inferior Frontal Gyrus, pars triangularis",
+  "6": "Inferior Frontal Gyrus, pars opercularis",
+  "7": "Precentral Gyrus",
+  "8": "Temporal Pole",
+  "9": "Superior Temporal Gyrus, anterior division",
+  "10": "Superior Temporal Gyrus, posterior division",
+  "11": "Middle Temporal Gyrus, anterior division",
+  "12": "Middle Temporal Gyrus, posterior division",
+  "13": "Middle Temporal Gyrus, temporooccipital part",
+  "14": "Inferior Temporal Gyrus, anterior division",
+  "15": "Inferior Temporal Gyrus, posterior division",
+  "16": "Inferior Temporal Gyrus, temporooccipital part",
+  "17": "Postcentral Gyrus",
+  "18": "Superior Parietal Lobule",
+  "19": "Supramarginal Gyrus, anterior division",
+  "20": "Supramarginal Gyrus, posterior division",
+  "21": "Angular Gyrus",
+  "22": "Lateral Occipital Cortex, superior division",
+  "23": "Lateral Occipital Cortex, inferior division",
+  "24": "Intracalcarine Cortex",
+  "25": "Frontal Medial Cortex",
+  "26": "Juxtapositional Lobule Cortex (formerly Supplementary Motor Cortex)",
+  "27": "Subcallosal Cortex",
+  "28": "Paracingulate Gyrus",
+  "29": "Cingulate Gyrus, anterior division",
+  "30": "Cingulate Gyrus, posterior division",
+  "31": "Precuneous Cortex",
+  "32": "Cuneal Cortex",
+  "33": "Frontal Orbital Cortex",
+  "34": "Parahippocampal Gyrus, anterior division",
+  "35": "Parahippocampal Gyrus, posterior division",
+  "36": "Lingual Gyrus",
+  "37": "Temporal Fusiform Cortex, anterior division",
+  "38": "Temporal Fusiform Cortex, posterior division",
+  "39": "Temporal Occipital Fusiform Cortex",
+  "40": "Occipital Fusiform Gyrus",
+  "41": "Frontal Opercular Cortex",
+  "42": "Central Opercular Cortex",
+  "43": "Parietal Opercular Cortex",
+  "44": "Planum Polare",
+  "45": "Heschl's Gyrus (includes H1 and H2)",
+  "46": "Planum Temporale",
+  "47": "Supracalcarine Cortex",
+  "48": "Occipital Pole",
+  "103": "Left Lateral Ventricle",
+  "104": "Left Thalamus",
+  "105": "Left Caudate",
+  "106": "Left Putamen",
+  "107": "Left Pallidum",
+  "108": "Brain-Stem",
+  "109": "Left Hippocampus",
+  "110": "Left Amygdala",
+  "111": "Left Accumbens",
+  "114": "Right Lateral Ventricle",
+  "115": "Right Thalamus",
+  "116": "Right Caudate",
+  "117": "Right Putamen",
+  "118": "Right Pallidum",
+  "119": "Right Hippocampus",
+  "120": "Right Amygdala",
+  "121": "Right Accumbens",
+  "201": "Amygdala_centromedial group",
+  "202": "Amygdala_laterobasal group",
+  "203": "Amygdala_superficial group",
+  "204": "Anterior intra-parietal sulcus hIP1",
+  "205": "Anterior intra-parietal sulcus hIP2",
+  "206": "Anterior intra-parietal sulcus hIP3",
+  "207": "Broca's area BA44",
+  "208": "Broca's area BA45",
+  "209": "Hippocampus cornu ammonis",
+  "210": "Hippocampus dentate gyrus",
+  "211": "Hippocampus entorhinal cortex",
+  "212": "Hippocampus hippocampal-amygdaloid transition area",
+  "213": "Hippocampus subiculum",
+  "214": "Inferior parietal lobule PF",
+  "215": "Inferior parietal lobule PFcm",
+  "216": "Inferior parietal lobule PFm",
+  "217": "Inferior parietal lobule PFop",
+  "218": "Inferior parietal lobule PFt",
+  "219": "Inferior parietal lobule PGp",
+  "220": "Inferior parietal lobule Pga",
+  "221": "Insula Id1",
+  "222": "Insula Ig1",
+  "223": "Insula Ig2",
+  "224": "Lateral geniculate body",
+  "225": "Mamillary body",
+  "226": "Medial geniculate body",
+  "227": "Premotor cortex BA6",
+  "228": "Primary auditory cortex TE1.0",
+  "229": "Primary auditory cortex TE1.1",
+  "230": "Primary auditory cortex TE1.2",
+  "231": "Primary motor cortex BA4a",
+  "232": "Primary motor cortex BA4p",
+  "233": "Primary somatosensory cortex BA1",
+  "234": "Primary somatosensory cortex BA2",
+  "235": "Primary somatosensory cortex BA3a",
+  "236": "Primary somatosensory cortex BA3b",
+  "237": "Secondary somatosensory cortex / Parietal operculum OP1",
+  "238": "Secondary somatosensory cortex / Parietal operculum OP2",
+  "239": "Secondary somatosensory cortex / Parietal operculum OP3",
+  "240": "Secondary somatosensory cortex / Parietal operculum OP4",
+  "241": "Superior parietal lobule 5Ci",
+  "242": "Superior parietal lobule 5L",
+  "243": "Superior parietal lobule 5M",
+  "244": "Superior parietal lobule 7A",
+  "245": "Superior parietal lobule 7M",
+  "246": "Superior parietal lobule 7P",
+  "247": "Superior parietal lobule 7PC",
+  "248": "Visual cortex V1 BA17",
+  "249": "Visual cortex V2 BA18",
+  "250": "Visual cortex V3V",
+  "251": "Visual cortex V4",
+  "252": "Visual cortex V5",
+  "253": "WM: Acoustic radiation",
+  "254": "WM: Callosal body",
+  "255": "WM: Cingulum",
+  "256": "WM: Corticospinal tract",
+  "257": "WM: Fornix",
+  "258": "WM: Inferior occipito-frontal fascicle",
+  "259": "WM: Optic radiation",
+  "260": "WM: Superior longitudinal fascicle",
+  "261": "WM: Superior occipito-frontal fascicle",
+  "262": "WM: Uncinate fascicle"
+}

data/label_grid_cache.keys.json

@@ -0,0 +1 @@
+["", "10159", "10292", "10306", "10307", "10308", "10311", "10313", "10327", "10329", "10330", "10331", "10332", "10333", "10334", "10335", "10336", "10337", "10338", "10339", "10342", "10343", "10344", "10346", "10349", "10361", "10383", "10384", "10389", "10390", "10465", "10466", "10467", "10595", "10596", "10597", "10598", "10599", "10600", "10602", "10648", "10649", "10650", "10651", "10653", "10654", "10655", "10656", "10657", "10658", "10659", "10660", "10661", "10662", "10669", "12114", "12115", "12116", "12117", "12118", "12119", "12121", "12122", "12123", "12124", "12125", "12126", "12127", "12132", "12133", "12136", "12137", "12138", "12140", "12142", "12143", "12144", "12145", "12146", "12147", "12148", "12149", "12150", "12151", "12152", "12153", "12154", "12155", "12156", "12157", "12158", "12159", "12160", "12162", "12163", "12164", "12165", "12166", "12170", "12171", "12173", "12174", "12176", "12177", "12178", "12179", "12181", "12195", "12291", "12292", "12305", "12330", "12354", "12369", "12384", "12390", "12405", "12416", "12535", "12538", "12805", "12826", "13229", "13230", "146034872", "146034876", "146034884", "146034888", "266441657"]

data/label_grid_cache.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab71af20799b4cefb9986791337fcb609105b4653141cde9285d486cbfaa4791
+size 101223

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_entropy.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2dc61d9b05f915dad3e8ade5e5d9e5f1df27983cbeaf34c0232010ab7e0008d7
+size 7812500

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_mean_xyz3.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34525f6bf4a68ac06f87801aa180b57cfea10c8c8559ea67d23d66ea54865109
+size 23437500

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_meta.json

@@ -0,0 +1 @@
+{"grid":125,"axis_min":[-69.5,-104.5625,-54.25],"axis_max":[70.0625,76.09375,81.8125],"files":{"mean_xyz3":"mdn_particles_rdcim_teacher_edge_hq_grid125_mean_xyz3.bin","pi":"mdn_particles_rdcim_teacher_edge_hq_grid125_pi_xyz6.bin","entropy":"mdn_particles_rdcim_teacher_edge_hq_grid125_entropy.bin","mu1_xyz3":"mdn_particles_rdcim_teacher_edge_hq_grid125_mu1_xyz3.bin","mu2_xyz3":"mdn_particles_rdcim_teacher_edge_hq_grid125_mu2_xyz3.bin","mu3_xyz3":"mdn_particles_rdcim_teacher_edge_hq_grid125_mu3_xyz3.bin","mu4_xyz3":"mdn_particles_rdcim_teacher_edge_hq_grid125_mu4_xyz3.bin","mu5_xyz3":"mdn_particles_rdcim_teacher_edge_hq_grid125_mu5_xyz3.bin","mu6_xyz3":"mdn_particles_rdcim_teacher_edge_hq_grid125_mu6_xyz3.bin"},"dtype":"float32","layout":"C-order (x,y,z,3) for *_xyz3; (x,y,z,K) for pi_xyzK; (x,y,z) for entropy","endianness":"little","mixture_mean_field":true,"model":{"quality":"hq","components":6},"mdn_source":"particles/rdcim_teacher_edge","bounds_mode":"full_brain","mode":"field","notes":"Trained on teacher segments (XYZ→ΔS) with optional rDCM conditioning and ROI embeddings","training_points_npy":"mdn_particles_rdcim_teacher_edge_hq_training_points.npy"}

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_mu1_xyz3.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44c45d1ccd4c2afb936d7a4622493b1d363df9664f6ce53cb26cd5bd892b79e8
+size 23437500

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_mu2_xyz3.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f1b9505a5ae611528425d57b09387e35dd921c20377a3b232a4267133b19baf
+size 23437500

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_mu3_xyz3.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53b0999649dfccf31f8726695c4d5a738009f408389a16954144be89d2a58c87
+size 23437500

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_mu4_xyz3.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afd81e6a49823e2ddb42f8e4256f2bf58f268f5fbf83d95fbf0dc0f0eedef559
+size 23437500

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_mu5_xyz3.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68c1f5eceb934435f58ea77c3b623abb114256cfc23affaa2dba1a202139a4aa
+size 23437500

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_mu6_xyz3.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9827f9f7a923994c84e1a44773fc2fe88dd91fd7905e718083dc752d24a31f4d
+size 23437500

data/mdn/mdn_particles_rdcim_teacher_edge_hq_grid125_pi_xyz6.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffb8a88b783e3a9aefeb8b7c14cd925769fcd3b4ef7d9ca029e4a8f71cd25265
+size 46875000

data/mdn/mdn_particles_rdcim_teacher_edge_hq_training_points.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f4ac819327e772ab01ed85b81150d2a28111df1ba4ebd9b2b3af200a011849b
+size 14400128

data/meshes/.keep

@@ -0,0 +1 @@
+placeholder so code paths that check data/meshes exist keep working; actual OBJ meshes are in data/meshes_obj.

data/meshes_obj/10153.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03245194c13e6081c41f81bfafb018f9aa819af57642f1729d6830db236912cb
+size 9316827

data/meshes_obj/10154.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0026eafd072ba11e02f3f4eab7f768ebcf89f32f5a0144fa38d8774576a1baff
+size 13523828

data/meshes_obj/10155.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89e07d4dc266bd9c69404da5b1ce8a1ea23dd2a41560e30f350b3c49a23e4c65
+size 13523828

data/meshes_obj/10156.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8dd907bcc3ed5f654395b9b2bec702f2f00355d6e7a9d208e18e01766f2782eb
+size 12090622

data/meshes_obj/10157.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c1432ccc092ed2e7b1495e506a11179420fcfb0919519824bb35329ee8171002
+size 3291242

data/meshes_obj/10158.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be09e3ec39b5cacb24af0e9f7d8e69086fd35853899daea7729bf7f048bb5c6d
+size 1992516

data/meshes_obj/10159.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa7c48344b0af6f41f069450f319e9c360ef8b45fe8f36dded24cb45e7ba0aef
+size 149484

data/meshes_obj/10292.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2c4b4771c184c4512cfadef75b152e0bcbe9d816a62102d7b93349c967d0d955
+size 112083

data/meshes_obj/10306.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aef8de5471788784415bdd77b44e5c532cabc79f5fc3f3c4be37e9dd6c5222e8
+size 112083

data/meshes_obj/10307.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:25a071fd3a955681fcd64f6d28fd917c921e9558b792f622649f93ebace11aa6
+size 19205

data/meshes_obj/10308.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:83c6c01f3d02a6980403f340692930dbe47339c03784b4c6a41d6cc8bcf45dd2
+size 28542

data/meshes_obj/10311.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e94088b6a00b31e0077ecb75f28d21621f8b8f4ae1a033b76756713b66737fe
+size 57711

data/meshes_obj/10313.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22a69c74d7c982a8372ac63c49df436bf8bc0fc1edb401710c4939c85fd9866f
+size 48263

data/meshes_obj/10327.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:61602d7e56749544c6773467d7b8af22aa7788de7640de8c0b18e6fc9630239a
+size 48263

data/meshes_obj/10329.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f145efd0531e791a5f2059f89a4c649a83b12ffee4bd06648569cc36396bbd3c
+size 17345

data/meshes_obj/10330.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8d96c21416298bac87134b1f41f762ac122854cd66a93f53bd97a8d833f7b99c
+size 36168

data/meshes_obj/10331.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e092fe926797259b4568d792ea0439daf36297ab5c9946a689892abe4c3b9aa
+size 1853173

data/meshes_obj/10332.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5030b54f80cad2316a5cc57db2649ac44e38d31d61677bda1710ebb29e1418f
+size 1027691

data/meshes_obj/10333.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df7e6a6ae97116b644f5090984b56ddcf5da574b5387c22bb8c554f9fff089ce
+size 949235

data/meshes_obj/10334.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a16d8d4d1fcb2cc0ac4be610e5f200c6efd910b3de982492432f563c39f6c2b9
+size 498360

data/meshes_obj/10335.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f4c64f991bb22248463cf2415ab33c6cf89235bb85fa26425672958c6362708
+size 225016

data/meshes_obj/10336.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:88b46eb320fe5c91aa1da562277d436caaabace45b0547a1b0d71e13cfa86d81
+size 157144

data/meshes_obj/10337.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f60b0f68b013cfca7c50fc2afd63db26e64098d8e6476990d7cbc339613d68eb
+size 162134

data/meshes_obj/10338.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a913a6bd57ddc20209c2a7d0c873705c234eb0f116ae0dfbb7fa88a7074d017
+size 374785

data/meshes_obj/10339.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0521f9f55fd1c10d2d9560fff80cb2385a6a9fab003bea1c524e4db1a154bcbb
+size 74905

data/meshes_obj/10342.obj

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0864087632dbee936a66dd7d0ab48f208db7fc57118bdef6a1b37e0dbe38b162
+size 142593