infant-brain-viewer 0.1.0__tar.gz

infant_brain_viewer-0.1.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: infant-brain-viewer
+Version: 0.1.0
+Summary: Infant brain visualization, EEG analysis and effective connectivity
+Author: Alessandro Crimi
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/alecrimi/infantconnect
+Project-URL: Repository, https://github.com/alecrimi/infantconnect
+Project-URL: Issues, https://github.com/alecrimi/infantconnect/issues
+Keywords: infant-brain,neuroimaging,EEG,brain-connectivity,neuroscience,PyVista
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: mne
+Requires-Dist: pyvista
+Requires-Dist: pyvistaqt
+Requires-Dist: vtk
+Requires-Dist: PySide6
+Requires-Dist: pooch
+Requires-Dist: nibabel
+Requires-Dist: edfio
+
+# Infant Brain 3D Visualizer
+
+A Python desktop application for visualizing infant brain surfaces, scalp and EEG electrode positions, and brain tractography in a shared 3D view. The viewer supports age-specific infant templates and can optionally compute and display effective connectivity from EEG recordings.
+
+## Features
+
+- Interactive 3D visualization of cortical surfaces and tractography.
+- Infant scalp and skull geometry with EEG electrode locations.
+- Age/template selection for infant head geometry (from birth to 2 years in the supplied templates; the viewer's age control extends to 72 months).
+- Overlay of electrodes and tractography for spatial inspection.
+- Optional effective-connectivity analysis using **Granger causality** or **transfer entropy** from EEG data.
+- Loading of local atlas and surface files from the repository.
+
+## Screenshots
+
+### EEG electrode locations
+
+The scalp and EEG electrode positions are shown in 3D.
+
+![EEG electrodes on the infant scalp](EEG_electrodes.png)
+
+### Brain tractography and electrode overlay
+
+Example screenshot showing the brain tractography together with the EEG electrode overlay.
+
+![Brain tractography overlaid with EEG electrodes](tracts.png)
+
+> Keep `EEG_electrodes.png` and `tracts.png` in the repository root (alongside this README) so GitHub can display the images.
+
+## Repository files
+
+- `infant_connect.py` — main interactive 3D viewer and application entry point.
+- `generate_cortex.py` — prepares/generates the cortical surface files used by the viewer.
+- `fetch_tract_atlas.py` — fetches the tractography atlas used for the tract overlay.
+- `atlas.json` — atlas manifest/configuration used by the viewer.
+- `tract_atlases/` — directory for tractography atlas data.
+- `effconn.py` — standalone effective-connectivity implementation (optional alternative to installing `effconnpy`).
+- `requirements.txt` — Python dependencies for the viewer.
+- `EEG_electrodes.png` — screenshot/figure showing EEG electrode positions.
+- `tracts.png` — screenshot/figure showing the tractography and electrode overlay.
+
+The cortical surfaces should be prepared with `generate_cortex.py`, and the tractography atlas should be retrieved with `fetch_tract_atlas.py` before launching the viewer. The scalp, skull, and electrode/montage template data are downloaded automatically by the viewer when needed and cached locally.
+
+## Requirements
+
+- Python 3.10 or newer is recommended.
+- A desktop environment capable of running Qt and rendering VTK/PyVista 3D scenes.
+- Python packages listed in `requirements.txt`.
+
+## Installation
+
+Clone the repository and enter its directory:
+
+```bash
+git clone <YOUR-REPOSITORY-URL>
+cd <YOUR-REPOSITORY-DIRECTORY>
+```
+
+Create and activate a virtual environment (recommended):
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+```
+
+On Windows, activate it with:
+
+```powershell
+.venv\Scripts\Activate.ps1
+```
+
+Install the dependencies:
+
+```bash
+python -m pip install --upgrade pip
+python -m pip install -r requirements.txt
+```
+
+## Prepare the data
+
+Run the preparation scripts from the repository root:
+
+```bash
+python generate_cortex.py
+python fetch_tract_atlas.py
+```
+
+These scripts prepare the cortical surfaces and fetch the tractography atlas, respectively. Check their console output for any download or preparation errors. Make sure the resulting files are placed where the viewer expects them, and that `atlas.json` and `tract_atlases/` are present.
+
+The viewer downloads the required infant scalp, skull, and electrode/montage template data on demand. An internet connection is needed the first time each template is requested. Downloaded template files are cached locally for later runs.
+
+## Run the viewer
+
+From the repository root, run:
+
+```bash
+python infant_connect.py
+```
+
+Run the command from the repository root after completing the preparation steps above.
+
+Use the viewer controls to toggle the scalp/electrodes, cortical surfaces, and tractography layers. Available controls and displayed options may depend on the atlas and surface files that have been prepared.
+
+## Effective connectivity
+
+The viewer can compute and display effective connectivity from an EEG recording using **Granger causality** or **transfer entropy**.
+
+There are two ways to provide the implementation:
+
+1. **Install `effconnpy`** from [piwheels](https://www.piwheels.org/project/effconnpy/):
+
+   ```bash
+   python -m pip install effconnpy
+   ```
+
+   The installed package must expose `compute_effective_connectivity` from the `effconn` module, as expected by the viewer.
+
+2. **Use the standalone implementation** included in this repository as `effconn.py`. Keep `effconn.py` alongside the main viewer script so that `from effconn import compute_effective_connectivity` can resolve locally. If you choose this option, you generally do not need to install a separate package providing the same module.
+
+To run the analysis, load an EEG recording through the viewer and enable the effective-connectivity control. The available methods are Granger causality and transfer entropy. The recording's channel names need to correspond to the electrode labels supported by the selected montage/template for the electrode positions to be fitted correctly.
+
+## Data and attribution
+
+The infant scalp/skull and montage templates are downloaded from the public [infant template paper repository](https://github.com/christian-oreilly/infant_template_paper/) when required. The cortical surfaces and tractography atlas are prepared or fetched by the scripts and should retain the licensing and attribution requirements of their original sources. Check the source projects and data licences before redistribution.
+
+## Troubleshooting
+
+- **Missing surface or atlas files:** run `generate_cortex.py` and `fetch_tract_atlas.py` from the repository root and check their output.
+- **Missing Python module:** activate the intended environment and reinstall dependencies with `python -m pip install -r requirements.txt`.
+- **Qt/VTK display problems:** run the viewer in a desktop session with working graphics support; headless environments may not support the interactive window.
+- **Effective-connectivity import error:** ensure either the repository's `effconn.py` is alongside the viewer or the compatible `effconnpy` package is installed.
+- **Electrodes do not align with the recording:** check the EEG channel names and the montage/template selected in the viewer.
+
+## Citation
+
+If you use this software in research, please cite this repository and the original sources of any cortical surfaces, infant templates, and tractography atlas data used. Add a formal software citation (for example, a Zenodo DOI) here when one is available.
+
+## Licence
+
+**The repository's software licence must be specified in a `LICENSE` file before public release.** Do not assume that third-party templates, cortical surfaces, or tractography atlas data are covered by the same licence as this code. Check each source project's terms and preserve any required attribution and usage restrictions.
+
+If you intend to release your own code under a permissive licence such as MIT, add the corresponding `LICENSE` file and confirm that this is compatible with all code you authored and redistributed. The licence for this repository does not automatically relicense external datasets or assets.

infant_brain_viewer-0.1.0/README.md

@@ -0,0 +1,142 @@
+# Infant Brain 3D Visualizer
+
+A Python desktop application for visualizing infant brain surfaces, scalp and EEG electrode positions, and brain tractography in a shared 3D view. The viewer supports age-specific infant templates and can optionally compute and display effective connectivity from EEG recordings.
+
+## Features
+
+- Interactive 3D visualization of cortical surfaces and tractography.
+- Infant scalp and skull geometry with EEG electrode locations.
+- Age/template selection for infant head geometry (from birth to 2 years in the supplied templates; the viewer's age control extends to 72 months).
+- Overlay of electrodes and tractography for spatial inspection.
+- Optional effective-connectivity analysis using **Granger causality** or **transfer entropy** from EEG data.
+- Loading of local atlas and surface files from the repository.
+
+## Screenshots
+
+### EEG electrode locations
+
+The scalp and EEG electrode positions are shown in 3D.
+
+![EEG electrodes on the infant scalp](EEG_electrodes.png)
+
+### Brain tractography and electrode overlay
+
+Example screenshot showing the brain tractography together with the EEG electrode overlay.
+
+![Brain tractography overlaid with EEG electrodes](tracts.png)
+
+> Keep `EEG_electrodes.png` and `tracts.png` in the repository root (alongside this README) so GitHub can display the images.
+
+## Repository files
+
+- `infant_connect.py` — main interactive 3D viewer and application entry point.
+- `generate_cortex.py` — prepares/generates the cortical surface files used by the viewer.
+- `fetch_tract_atlas.py` — fetches the tractography atlas used for the tract overlay.
+- `atlas.json` — atlas manifest/configuration used by the viewer.
+- `tract_atlases/` — directory for tractography atlas data.
+- `effconn.py` — standalone effective-connectivity implementation (optional alternative to installing `effconnpy`).
+- `requirements.txt` — Python dependencies for the viewer.
+- `EEG_electrodes.png` — screenshot/figure showing EEG electrode positions.
+- `tracts.png` — screenshot/figure showing the tractography and electrode overlay.
+
+The cortical surfaces should be prepared with `generate_cortex.py`, and the tractography atlas should be retrieved with `fetch_tract_atlas.py` before launching the viewer. The scalp, skull, and electrode/montage template data are downloaded automatically by the viewer when needed and cached locally.
+
+## Requirements
+
+- Python 3.10 or newer is recommended.
+- A desktop environment capable of running Qt and rendering VTK/PyVista 3D scenes.
+- Python packages listed in `requirements.txt`.
+
+## Installation
+
+Clone the repository and enter its directory:
+
+```bash
+git clone <YOUR-REPOSITORY-URL>
+cd <YOUR-REPOSITORY-DIRECTORY>
+```
+
+Create and activate a virtual environment (recommended):
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+```
+
+On Windows, activate it with:
+
+```powershell
+.venv\Scripts\Activate.ps1
+```
+
+Install the dependencies:
+
+```bash
+python -m pip install --upgrade pip
+python -m pip install -r requirements.txt
+```
+
+## Prepare the data
+
+Run the preparation scripts from the repository root:
+
+```bash
+python generate_cortex.py
+python fetch_tract_atlas.py
+```
+
+These scripts prepare the cortical surfaces and fetch the tractography atlas, respectively. Check their console output for any download or preparation errors. Make sure the resulting files are placed where the viewer expects them, and that `atlas.json` and `tract_atlases/` are present.
+
+The viewer downloads the required infant scalp, skull, and electrode/montage template data on demand. An internet connection is needed the first time each template is requested. Downloaded template files are cached locally for later runs.
+
+## Run the viewer
+
+From the repository root, run:
+
+```bash
+python infant_connect.py
+```
+
+Run the command from the repository root after completing the preparation steps above.
+
+Use the viewer controls to toggle the scalp/electrodes, cortical surfaces, and tractography layers. Available controls and displayed options may depend on the atlas and surface files that have been prepared.
+
+## Effective connectivity
+
+The viewer can compute and display effective connectivity from an EEG recording using **Granger causality** or **transfer entropy**.
+
+There are two ways to provide the implementation:
+
+1. **Install `effconnpy`** from [piwheels](https://www.piwheels.org/project/effconnpy/):
+
+   ```bash
+   python -m pip install effconnpy
+   ```
+
+   The installed package must expose `compute_effective_connectivity` from the `effconn` module, as expected by the viewer.
+
+2. **Use the standalone implementation** included in this repository as `effconn.py`. Keep `effconn.py` alongside the main viewer script so that `from effconn import compute_effective_connectivity` can resolve locally. If you choose this option, you generally do not need to install a separate package providing the same module.
+
+To run the analysis, load an EEG recording through the viewer and enable the effective-connectivity control. The available methods are Granger causality and transfer entropy. The recording's channel names need to correspond to the electrode labels supported by the selected montage/template for the electrode positions to be fitted correctly.
+
+## Data and attribution
+
+The infant scalp/skull and montage templates are downloaded from the public [infant template paper repository](https://github.com/christian-oreilly/infant_template_paper/) when required. The cortical surfaces and tractography atlas are prepared or fetched by the scripts and should retain the licensing and attribution requirements of their original sources. Check the source projects and data licences before redistribution.
+
+## Troubleshooting
+
+- **Missing surface or atlas files:** run `generate_cortex.py` and `fetch_tract_atlas.py` from the repository root and check their output.
+- **Missing Python module:** activate the intended environment and reinstall dependencies with `python -m pip install -r requirements.txt`.
+- **Qt/VTK display problems:** run the viewer in a desktop session with working graphics support; headless environments may not support the interactive window.
+- **Effective-connectivity import error:** ensure either the repository's `effconn.py` is alongside the viewer or the compatible `effconnpy` package is installed.
+- **Electrodes do not align with the recording:** check the EEG channel names and the montage/template selected in the viewer.
+
+## Citation
+
+If you use this software in research, please cite this repository and the original sources of any cortical surfaces, infant templates, and tractography atlas data used. Add a formal software citation (for example, a Zenodo DOI) here when one is available.
+
+## Licence
+
+**The repository's software licence must be specified in a `LICENSE` file before public release.** Do not assume that third-party templates, cortical surfaces, or tractography atlas data are covered by the same licence as this code. Check each source project's terms and preserve any required attribution and usage restrictions.
+
+If you intend to release your own code under a permissive licence such as MIT, add the corresponding `LICENSE` file and confirm that this is compatible with all code you authored and redistributed. The licence for this repository does not automatically relicense external datasets or assets.

infant_brain_viewer-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "infant-brain-viewer"
+version = "0.1.0"
+description = "Infant brain visualization, EEG analysis and effective connectivity"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "Apache-2.0"
+
+authors = [
+    { name = "Alessandro Crimi" }
+]
+
+keywords = [
+    "infant-brain",
+    "neuroimaging",
+    "EEG",
+    "brain-connectivity",
+    "neuroscience",
+    "PyVista"
+]
+
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Medical Science Apps.",
+    "Topic :: Scientific/Engineering :: Visualization", 
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent"
+]
+
+dependencies = [
+    "numpy",
+    "scipy",
+    "mne",
+    "pyvista",
+    "pyvistaqt",
+    "vtk",
+    "PySide6",
+    "pooch",
+    "nibabel",
+    "edfio"
+]
+
+[project.urls]
+Homepage = "https://github.com/alecrimi/infantconnect"
+Repository = "https://github.com/alecrimi/infantconnect"
+Issues = "https://github.com/alecrimi/infantconnect/issues"
+
+[project.gui-scripts]
+infant-brain-viewer = "infant_brain_viewer.infant_brain_viewer:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+infant_brain_viewer = [
+    "*.json",
+    "*.png",
+    "data/**/*",
+    "tract_atlases/**/*",
+    "mne_templates/**/*"
+]
+

infant_brain_viewer-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

infant_brain_viewer-0.1.0/setup.py

@@ -0,0 +1,4 @@
+from setuptools import setup
+
+if __name__ == "__main__":
+    setup()

infant_brain_viewer-0.1.0/src/ infant_brain_viewer/__init__.py

@@ -0,0 +1,7 @@
+
+"""InfantConnect: infant brain visualization and connectivity tools."""
+
+__version__ = "0.1.0"
+__author__ = "Alessandro Crimi"
+
+__all__ = ["__version__", "__author__"]

infant_brain_viewer-0.1.0/src/ infant_brain_viewer/bundle_animation.py

@@ -0,0 +1,248 @@
+"""Bundle-style tract animation seeded at EEG sensors.
+
+Usage in your main script:
+
+    from bundle_animation import BundleAnimationMixin
+    class InfantBrainViewer(BundleAnimationMixin, QMainWindow):
+        ...
+
+The mixin overrides _setup_animation() and _animate_step(), so the old versions
+(and _polyline_between / _point_on_streamline / _move_actor_to) can be deleted
+or left in place; they are no longer used.
+"""
+import numpy as np
+import pyvista as pv
+
+N_BUNDLES = 3            # bundles glowing at the same time, each at its own sensor
+FIBERS_PER_BUNDLE = 40   # fibers travelling together in one bundle
+CANDIDATES = 200         # nearest fibers considered around the sensor
+DIRECTION_COHERENCE = 0.6  # min |cos| between a fiber and the lead fiber direction
+TRAIL_SAMPLES = 24
+FRAME_DT = 0.03
+SPEED_FACTOR = 2     # bundle speed in median-fiber-lengths per second  
+
+
+class BundleAnimationMixin:
+
+    # ------------------------------------------------------------------ setup
+    def _animation_electrodes(self):
+        """Electrode positions in the same (brain-fitted) frame as the tracts."""
+        requested_age = self.age_slider.value()
+        age = self._nearest_age(requested_age)
+        name = self._pick_scalp_template(requested_age)
+        if name is None:
+            return {}
+        scalp = self.scalp_templates[name]
+        electrodes = self.electrode_templates[name]
+        parts = [m for m in (self._get_mesh(age, h, "outer") for h in ("left", "right"))
+                 if m is not None]
+        if not parts:
+            return {}
+        reference = parts[0] if len(parts) == 1 else parts[0].merge(parts[1:])
+        _, electrodes_fit = fit_template_to_brain_ref(scalp, electrodes, reference)
+        return electrodes_fit
+
+    def _setup_animation(self, tract_mesh):
+        self.anim_timer.stop()
+        self.anim_pulses.clear()
+        self._anim_rng = np.random.default_rng()
+
+        if tract_mesh.n_cells < 1:
+            return
+
+        electrodes = self._animation_electrodes()
+        if not electrodes:
+            return
+        self._anim_electrodes = electrodes
+
+        # Per-fiber point arrays (ordered along the streamline).
+        fibers = []
+        for cid in range(tract_mesh.n_cells):
+            try:
+                pts = np.asarray(tract_mesh.get_cell(cid).points, dtype=float)
+            except Exception:
+                continue
+            if len(pts) >= 3:
+                fibers.append(pts)
+        if not fibers:
+            return
+        self._anim_fibers = fibers
+        self._anim_all_pts = np.vstack(fibers)
+        self._anim_cell_of_pt = np.concatenate(
+            [np.full(len(p), i, dtype=np.int64) for i, p in enumerate(fibers)]
+        )
+        self._anim_pt_in_cell = np.concatenate(
+            [np.arange(len(p), dtype=np.int64) for p in fibers]
+        )
+
+        used = set()
+        for b in range(N_BUNDLES):
+            bundle = self._make_bundle(b, avoid=used)
+            if bundle is None:
+                continue
+            used.add(bundle["electrode"])
+            # Stagger the bundles so they do not all fire in sync.
+            bundle["d"] = -bundle["cycle_len"] * (b / max(N_BUNDLES, 1)) * 0.6
+            self.anim_pulses.append(bundle)
+
+        if self.anim_pulses:
+            self.anim_timer.start(30)
+
+    def _make_bundle(self, slot, avoid=()):
+        """Pick a random sensor and gather the coherent fibers passing near it."""
+        names = [n for n in self._anim_electrodes if n not in avoid]
+        if not names:
+            names = list(self._anim_electrodes)
+        for _ in range(10):  # retry if a sensor has no usable fibers nearby
+            name = names[int(self._anim_rng.integers(len(names)))]
+            e = np.asarray(self._anim_electrodes[name], dtype=float)
+
+            dist = np.linalg.norm(self._anim_all_pts - e, axis=1)
+            order = np.argsort(dist)
+
+            # Nearest point per fiber, for the CANDIDATES nearest fibers.
+            seen, cand = set(), []
+            for pi in order:
+                ci = int(self._anim_cell_of_pt[pi])
+                if ci in seen:
+                    continue
+                seen.add(ci)
+                cand.append((ci, int(self._anim_pt_in_cell[pi])))
+                if len(cand) >= CANDIDATES:
+                    break
+
+            # Local tangent at the closest point; align everything to the lead fiber.
+            tangents = []
+            for ci, k in cand:
+                pts = self._anim_fibers[ci]
+                t = pts[min(k + 1, len(pts) - 1)] - pts[max(k - 1, 0)]
+                n = np.linalg.norm(t)
+                tangents.append(t / n if n > 1e-12 else np.zeros(3))
+            lead = next((t for t in tangents if np.linalg.norm(t) > 0), None)
+            if lead is None:
+                continue
+
+            chosen = []
+            for (ci, k), t in zip(cand, tangents):
+                c = float(np.dot(t, lead))
+                if abs(c) < DIRECTION_COHERENCE:
+                    continue
+                pts = self._anim_fibers[ci]
+                # Orient along the shared direction; start at the sensor-nearest point.
+                path = pts[k:] if c > 0 else pts[:k + 1][::-1]
+                if len(path) < 3:
+                    continue
+                seg = np.linalg.norm(np.diff(path, axis=0), axis=1)
+                arc = np.concatenate(([0.0], np.cumsum(seg)))
+                if arc[-1] <= 1e-9:
+                    continue
+                chosen.append({"pts": path, "arc": arc, "L": float(arc[-1])})
+                if len(chosen) >= FIBERS_PER_BUNDLE:
+                    break
+            if len(chosen) < 5:
+                continue
+
+            lengths = np.array([f["L"] for f in chosen])
+            med = float(np.median(lengths))
+            trail = 0.20 * med
+            for f in chosen:  # small per-fiber lead/lag keeps the bundle organic
+                f["offset"] = float(self._anim_rng.uniform(0.0, 0.04 * med))
+
+            tag = f"{slot}"
+            ph_line = pv.Line((0, 0, 0), (0, 0, 0.001))
+            ph_pts = pv.PolyData(np.zeros((1, 3)))
+            halo = self.plotter.add_mesh(
+                ph_line, color="#00BFFF", line_width=7, opacity=0.25,
+                lighting=False, reset_camera=False, name=f"bundle_halo_{tag}")
+            core = self.plotter.add_mesh(
+                ph_line.copy(), color="#7DEBFF", line_width=2.0, opacity=0.95,
+                lighting=False, reset_camera=False, name=f"bundle_core_{tag}")
+            head_halo = self.plotter.add_mesh(
+                ph_pts, color="#00CFFF", opacity=0.30, point_size=14,
+                render_points_as_spheres=True, lighting=False,
+                reset_camera=False, name=f"bundle_head_halo_{tag}")
+            head_core = self.plotter.add_mesh(
+                ph_pts.copy(), color="#FFF4CF", opacity=1.0, point_size=5,
+                render_points_as_spheres=True, lighting=False,
+                reset_camera=False, name=f"bundle_head_core_{tag}")
+
+            return {
+                "slot": slot, "electrode": name, "fibers": chosen,
+                "d": 0.0, "speed": SPEED_FACTOR * med, "trail": trail,
+                "cycle_len": float(lengths.max()) + trail,
+                "halo": halo, "core": core,
+                "head_halo": head_halo, "head_core": head_core,
+            }
+        return None
+
+    # ---------------------------------------------------------------- frames
+    def _animate_step(self):
+        if not self.tracts_checkbox.isChecked() or not self.animate_checkbox.isChecked():
+            self.anim_timer.stop()
+            return
+
+        for bi, bundle in enumerate(self.anim_pulses):
+            bundle["d"] += bundle["speed"] * FRAME_DT
+
+            # Finished: re-seed this bundle at a new random sensor.
+            if bundle["d"] > bundle["cycle_len"]:
+                others = {b["electrode"] for j, b in enumerate(self.anim_pulses) if j != bi}
+                new = self._make_bundle(bundle["slot"], avoid=others | {bundle["electrode"]})
+                if new is not None:
+                    self.anim_pulses[bi] = bundle = new
+                else:
+                    bundle["d"] = 0.0
+
+            if bundle["d"] < 0:  # staggered start: not launched yet
+                self._set_bundle_geometry(bundle, None, None)
+                continue
+
+            trail = bundle["trail"]
+            all_pts, all_lines, heads = [], [], []
+            base = 0
+            for f in bundle["fibers"]:
+                head = bundle["d"] + f["offset"]
+                if head <= 0:
+                    continue
+                head = min(head, f["L"])
+                tail = max(0.0, head - trail)
+                if f["L"] - tail < 1e-9 or (head >= f["L"] and tail >= f["L"] - 1e-9):
+                    continue
+                dists = np.linspace(tail, head, TRAIL_SAMPLES)
+                coords = np.column_stack(
+                    [np.interp(dists, f["arc"], f["pts"][:, a]) for a in range(3)]
+                )
+                all_pts.append(coords)
+                all_lines.append(np.hstack(
+                    ([TRAIL_SAMPLES], base + np.arange(TRAIL_SAMPLES, dtype=np.int64))))
+                base += TRAIL_SAMPLES
+                if head < f["L"]:
+                    heads.append(coords[-1])
+
+            if not all_pts:
+                self._set_bundle_geometry(bundle, None, None)
+                continue
+
+            trail_poly = pv.PolyData(np.vstack(all_pts), lines=np.concatenate(all_lines))
+            head_poly = pv.PolyData(np.array(heads)) if heads else None
+            self._set_bundle_geometry(bundle, trail_poly, head_poly)
+
+        self.plotter.render()
+
+    @staticmethod
+    def _set_bundle_geometry(bundle, trail_poly, head_poly):
+        empty_lines = pv.Line((0, 0, 0), (0, 0, 1e-6))
+        empty_pts = pv.PolyData(np.zeros((1, 3)))
+        t = trail_poly if trail_poly is not None else empty_lines
+        h = head_poly if head_poly is not None else empty_pts
+        bundle["halo"].mapper.SetInputData(t)
+        bundle["core"].mapper.SetInputData(t.copy())
+        bundle["head_halo"].mapper.SetInputData(h)
+        bundle["head_core"].mapper.SetInputData(h.copy())
+
+
+def fit_template_to_brain_ref(scalp, electrodes, reference):
+    """Late import so this module can sit next to the main script without a cycle."""
+    import importlib
+    main_mod = importlib.import_module("__main__")
+    return main_mod.fit_template_to_brain(scalp, electrodes, reference)

infant_brain_viewer-0.1.0/src/ infant_brain_viewer/edf_granger_cli.py

@@ -0,0 +1,19 @@
+"""Command-line Granger-causality connectome from EDF, saved as CSV.
+
+Uses effconn.compute_granger (pairwise F-test on OLS/VAR residuals):
+  * values are -log10(p); >= 1.3 means p < 0.05; 0 = no test / failed fit
+  * default lag = 5 samples (as in the viewer)
+  * CSV layout follows effconn.py: row i, column j = influence of channel j
+    (source) on channel i (target); add --source-rows to transpose.
+
+Examples:
+  python edf_granger_cli.py rec.edf -o out/
+  python edf_granger_cli.py rec.edf --lag 8 --edge-list --min-strength 1.3
+See edf_effconn_cli.py for all options. Needs effconn.py next to the scripts.
+"""
+import sys
+
+from edf_effconn_cli import main
+
+if __name__ == "__main__":
+    sys.exit(main(fixed_method="granger"))