corticalfields 0.1.1__tar.gz

corticalfields-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 R. Debona
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

corticalfields-0.1.1/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.4
+Name: corticalfields
+Version: 0.1.1
+Summary: Geodesic-aware Gaussian Process normative modeling on cortical surfaces with spectral shape descriptors and information-theoretic surprise maps.
+Author-email: rdneuro <r.debona@ufrj.br>
+License: MIT
+Project-URL: Homepage, https://github.com/rdneuro/corticalfields
+Project-URL: Documentation, https://corticalfields.readthedocs.io
+Keywords: neuroimaging,cortical-surface,gaussian-process,normative-modeling,epilepsy,heat-kernel-signature,laplace-beltrami,surprise-maps,spectral-analysis,bayesian-inference
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: nibabel>=5.0
+Requires-Dist: torch>=2.0
+Requires-Dist: gpytorch>=1.11
+Requires-Dist: scikit-sparse>=0.4
+Requires-Dist: trimesh>=4.0
+Requires-Dist: pyvista>=0.42
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: tqdm>=4.65
+Requires-Dist: joblib>=1.3
+Provides-Extra: full
+Requires-Dist: robust-laplacian>=0.2; extra == "full"
+Requires-Dist: potpourri3d>=0.0.8; extra == "full"
+Requires-Dist: geometric-kernels>=0.2; extra == "full"
+Requires-Dist: pymc>=5.10; extra == "full"
+Requires-Dist: giotto-tda>=0.6; extra == "full"
+Requires-Dist: torch-geometric>=2.4; extra == "full"
+Requires-Dist: surfplot>=0.2; extra == "full"
+Requires-Dist: brainspace>=0.1; extra == "full"
+Requires-Dist: neuromaps>=0.0.4; extra == "full"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Dynamic: license-file
+
+# CorticalFields
+
+**Geodesic-aware Gaussian Process normative modeling on cortical surfaces with spectral shape descriptors and information-theoretic surprise maps.**
+
+CorticalFields extracts rich geometric information from structural MRI (T1w) data — without needing fMRI or dMRI — by treating the cortical surface as a Riemannian manifold and applying principled probabilistic modeling. It was designed for epilepsy research (MTLE-HS) but is applicable to any structural neuroimaging study.
+
+## What it does
+
+Given FreeSurfer-processed T1w data, CorticalFields:
+
+1. **Decomposes the cortical geometry** via the Laplace–Beltrami operator, extracting the intrinsic spectral structure of the cortical mesh.
+2. **Computes spectral shape descriptors** (Heat Kernel Signature, Wave Kernel Signature, Global Point Signature) that capture multi-scale geometric information at every vertex — from local curvature to global lobe membership.
+3. **Builds a spectral Matérn GP** that respects the cortical manifold's geometry (not Euclidean space), producing a proper probabilistic model of "normal" brain morphology.
+4. **Generates vertex-wise surprise maps** — information-theoretic anomaly scores that quantify how unexpected each vertex's morphometry is, given the normative model and the surrounding cortical geometry.
+5. **Aggregates anomalies by functional network** (Yeo-7, Schaefer-200, etc.), enabling statements like *"this patient has anomalous DMN structure"* from T1w data alone.
+
+## Key innovations
+
+- **Geodesic-aware GP kernel**: Uses the spectral Matérn kernel (Borovitskiy et al., NeurIPS 2020) — the only mathematically correct way to define Matérn GPs on curved manifolds. Naïve geodesic distance substitution does NOT yield a valid kernel.
+- **Surprise maps**: Vertex-wise negative log-predictive density from a calibrated probabilistic model — theoretically optimal anomaly scoring that goes beyond z-scores.
+- **Spectral shape descriptors for neuroimaging**: Brings HKS/WKS from computer graphics into clinical brain imaging for the first time.
+- **Scalability to 150k vertices**: Spectral truncation (≤1000 LB eigenpairs) + variational sparse GP (≤1000 inducing points) makes the pipeline tractable on a single GPU.
+
+## Installation
+
+```bash
+# Core installation
+pip install corticalfields
+
+# Full installation (includes optional dependencies)
+pip install corticalfields[full]
+
+# Development installation
+git clone https://github.com/rdneuro/corticalfields.git
+cd corticalfields
+pip install -e ".[full,dev]"
+```
+
+### Requirements
+
+- Python ≥ 3.9
+- PyTorch ≥ 2.0 (with CUDA for GPU acceleration)
+- FreeSurfer (for surface reconstruction via `recon-all`)
+- Core: numpy, scipy, nibabel, gpytorch, matplotlib, pyvista
+- Optional: robust-laplacian, geometric-kernels, pymc, giotto-tda
+
+## Quick start
+
+```python
+import corticalfields as cf
+from corticalfields.spectral import compute_eigenpairs
+from corticalfields.utils import get_device, setup_logging
+
+setup_logging("INFO")
+device = get_device()  # auto-detect CUDA
+
+# 1. Load a FreeSurfer surface
+surf = cf.load_freesurfer_surface(
+    subjects_dir="/data/freesurfer",
+    subject_id="fsaverage",
+    hemi="lh",
+    surface="pial",
+    overlays=["thickness", "curv", "sulc"],
+)
+
+# 2. Compute Laplace–Beltrami eigenpairs
+lb = compute_eigenpairs(
+    surf.vertices, surf.faces,
+    n_eigenpairs=300,  # 300 is a good default
+)
+
+# 3. Compute spectral shape descriptors
+hks = cf.heat_kernel_signature(lb, n_scales=16)
+wks = cf.wave_kernel_signature(lb, n_energies=16)
+gps = cf.global_point_signature(lb, n_components=10)
+
+# 4. Train normative model on reference cohort thickness
+model = cf.CorticalNormativeModel(lb, nu=2.5, n_inducing=512, device=device)
+model.fit(reference_thickness_matrix, feature_name="thickness", n_epochs=100)
+
+# 5. Score a patient
+result = model.predict(patient_thickness)
+print(f"Mean surprise: {result.surprise.mean():.2f}")
+print(f"Fraction anomalous (|z| > 2): {(abs(result.z_score) > 2).mean():.1%}")
+
+# 6. Aggregate by network
+from corticalfields.surprise import compute_surprise
+from corticalfields.utils import load_fsaverage_parcellation
+
+yeo_labels, yeo_names = load_fsaverage_parcellation("yeo_7", hemi="lh")
+surprise_map = compute_surprise(
+    patient_thickness, result.mean, result.variance,
+)
+network_scores = surprise_map.aggregate_by_network(yeo_labels, yeo_names)
+```
+
+## Full pipeline example
+
+See `examples/full_pipeline.py` for a complete walkthrough from raw FreeSurfer outputs to publication-quality surprise map figures.
+
+## Architecture
+
+```
+corticalfields/
+├── surface.py      # Surface I/O (FreeSurfer, GIfTI, mesh utilities)
+├── spectral.py     # Laplace–Beltrami decomposition, HKS, WKS, GPS
+├── kernels.py      # Spectral Matérn kernels for GPyTorch
+├── normative.py    # GP-based normative modeling pipeline
+├── surprise.py     # Information-theoretic anomaly scoring
+├── features.py     # Morphometric feature extraction
+├── graphs.py       # Cortical similarity network construction
+├── viz.py          # Publication-quality surface visualization
+└── utils.py        # Helpers (GPU detection, parcellation, timing)
+```
+
+## Mathematical foundations
+
+The core of CorticalFields rests on three mathematical pillars:
+
+**1. Laplace–Beltrami spectral decomposition.** On a compact Riemannian manifold (Σ, g), the LB operator Δ_g has a discrete spectrum 0 = λ₀ ≤ λ₁ ≤ λ₂ ≤ … with orthonormal eigenfunctions φᵢ. These encode the intrinsic geometry of the surface at all scales — low eigenvalues capture global shape, high eigenvalues capture fine-grained curvature.
+
+**2. Spectral Matérn kernel.** The Matérn kernel on the manifold is defined via the spectral density: k(x,y) = σ² Σᵢ S_ν(λᵢ) φᵢ(x) φᵢ(y), where S_ν(λ) = (2ν/κ² + λ)^{−(ν+d/2)}. This yields a valid positive-definite kernel that respects the manifold geometry, unlike naïve geodesic-distance substitution.
+
+**3. Information-theoretic surprise.** For a GP with posterior predictive p(y*|x,D) = N(μ(x), σ²(x)), the surprise at vertex x is S(x) = −log p(y_obs|x,D) = ½ log(2πσ²) + (y_obs − μ)²/(2σ²). This is the theoretically optimal anomaly score under the model.
+
+## References
+
+- Borovitskiy et al. (2020). Matérn Gaussian Processes on Riemannian Manifolds. NeurIPS.
+- Sun, Ovsjanikov & Guibas (2009). Heat Kernel Signature. SGP.
+- Aubry, Schlickewei & Cremers (2011). Wave Kernel Signature. ICCV.
+- Sharp & Crane (2020). A Laplacian for Nonmanifold Triangle Meshes. SGP.
+- Seidlitz et al. (2018). Morphometric Similarity Networks. Neuron.
+- Marquand et al. (2019). Normative modeling in neuroimaging. Nature Protocols.
+
+## Citation
+
+If you use CorticalFields in your research, please cite:
+
+```bibtex
+@software{corticalfields2026,
+  author = {Velho Mago},
+  title = {CorticalFields: Geodesic-aware GP normative modeling on cortical surfaces},
+  year = {2026},
+  url = {https://github.com/rdneuro/corticalfields},
+}
+```
+
+## License
+
+MIT

corticalfields-0.1.1/README.md

@@ -0,0 +1,150 @@
+# CorticalFields
+
+**Geodesic-aware Gaussian Process normative modeling on cortical surfaces with spectral shape descriptors and information-theoretic surprise maps.**
+
+CorticalFields extracts rich geometric information from structural MRI (T1w) data — without needing fMRI or dMRI — by treating the cortical surface as a Riemannian manifold and applying principled probabilistic modeling. It was designed for epilepsy research (MTLE-HS) but is applicable to any structural neuroimaging study.
+
+## What it does
+
+Given FreeSurfer-processed T1w data, CorticalFields:
+
+1. **Decomposes the cortical geometry** via the Laplace–Beltrami operator, extracting the intrinsic spectral structure of the cortical mesh.
+2. **Computes spectral shape descriptors** (Heat Kernel Signature, Wave Kernel Signature, Global Point Signature) that capture multi-scale geometric information at every vertex — from local curvature to global lobe membership.
+3. **Builds a spectral Matérn GP** that respects the cortical manifold's geometry (not Euclidean space), producing a proper probabilistic model of "normal" brain morphology.
+4. **Generates vertex-wise surprise maps** — information-theoretic anomaly scores that quantify how unexpected each vertex's morphometry is, given the normative model and the surrounding cortical geometry.
+5. **Aggregates anomalies by functional network** (Yeo-7, Schaefer-200, etc.), enabling statements like *"this patient has anomalous DMN structure"* from T1w data alone.
+
+## Key innovations
+
+- **Geodesic-aware GP kernel**: Uses the spectral Matérn kernel (Borovitskiy et al., NeurIPS 2020) — the only mathematically correct way to define Matérn GPs on curved manifolds. Naïve geodesic distance substitution does NOT yield a valid kernel.
+- **Surprise maps**: Vertex-wise negative log-predictive density from a calibrated probabilistic model — theoretically optimal anomaly scoring that goes beyond z-scores.
+- **Spectral shape descriptors for neuroimaging**: Brings HKS/WKS from computer graphics into clinical brain imaging for the first time.
+- **Scalability to 150k vertices**: Spectral truncation (≤1000 LB eigenpairs) + variational sparse GP (≤1000 inducing points) makes the pipeline tractable on a single GPU.
+
+## Installation
+
+```bash
+# Core installation
+pip install corticalfields
+
+# Full installation (includes optional dependencies)
+pip install corticalfields[full]
+
+# Development installation
+git clone https://github.com/rdneuro/corticalfields.git
+cd corticalfields
+pip install -e ".[full,dev]"
+```
+
+### Requirements
+
+- Python ≥ 3.9
+- PyTorch ≥ 2.0 (with CUDA for GPU acceleration)
+- FreeSurfer (for surface reconstruction via `recon-all`)
+- Core: numpy, scipy, nibabel, gpytorch, matplotlib, pyvista
+- Optional: robust-laplacian, geometric-kernels, pymc, giotto-tda
+
+## Quick start
+
+```python
+import corticalfields as cf
+from corticalfields.spectral import compute_eigenpairs
+from corticalfields.utils import get_device, setup_logging
+
+setup_logging("INFO")
+device = get_device()  # auto-detect CUDA
+
+# 1. Load a FreeSurfer surface
+surf = cf.load_freesurfer_surface(
+    subjects_dir="/data/freesurfer",
+    subject_id="fsaverage",
+    hemi="lh",
+    surface="pial",
+    overlays=["thickness", "curv", "sulc"],
+)
+
+# 2. Compute Laplace–Beltrami eigenpairs
+lb = compute_eigenpairs(
+    surf.vertices, surf.faces,
+    n_eigenpairs=300,  # 300 is a good default
+)
+
+# 3. Compute spectral shape descriptors
+hks = cf.heat_kernel_signature(lb, n_scales=16)
+wks = cf.wave_kernel_signature(lb, n_energies=16)
+gps = cf.global_point_signature(lb, n_components=10)
+
+# 4. Train normative model on reference cohort thickness
+model = cf.CorticalNormativeModel(lb, nu=2.5, n_inducing=512, device=device)
+model.fit(reference_thickness_matrix, feature_name="thickness", n_epochs=100)
+
+# 5. Score a patient
+result = model.predict(patient_thickness)
+print(f"Mean surprise: {result.surprise.mean():.2f}")
+print(f"Fraction anomalous (|z| > 2): {(abs(result.z_score) > 2).mean():.1%}")
+
+# 6. Aggregate by network
+from corticalfields.surprise import compute_surprise
+from corticalfields.utils import load_fsaverage_parcellation
+
+yeo_labels, yeo_names = load_fsaverage_parcellation("yeo_7", hemi="lh")
+surprise_map = compute_surprise(
+    patient_thickness, result.mean, result.variance,
+)
+network_scores = surprise_map.aggregate_by_network(yeo_labels, yeo_names)
+```
+
+## Full pipeline example
+
+See `examples/full_pipeline.py` for a complete walkthrough from raw FreeSurfer outputs to publication-quality surprise map figures.
+
+## Architecture
+
+```
+corticalfields/
+├── surface.py      # Surface I/O (FreeSurfer, GIfTI, mesh utilities)
+├── spectral.py     # Laplace–Beltrami decomposition, HKS, WKS, GPS
+├── kernels.py      # Spectral Matérn kernels for GPyTorch
+├── normative.py    # GP-based normative modeling pipeline
+├── surprise.py     # Information-theoretic anomaly scoring
+├── features.py     # Morphometric feature extraction
+├── graphs.py       # Cortical similarity network construction
+├── viz.py          # Publication-quality surface visualization
+└── utils.py        # Helpers (GPU detection, parcellation, timing)
+```
+
+## Mathematical foundations
+
+The core of CorticalFields rests on three mathematical pillars:
+
+**1. Laplace–Beltrami spectral decomposition.** On a compact Riemannian manifold (Σ, g), the LB operator Δ_g has a discrete spectrum 0 = λ₀ ≤ λ₁ ≤ λ₂ ≤ … with orthonormal eigenfunctions φᵢ. These encode the intrinsic geometry of the surface at all scales — low eigenvalues capture global shape, high eigenvalues capture fine-grained curvature.
+
+**2. Spectral Matérn kernel.** The Matérn kernel on the manifold is defined via the spectral density: k(x,y) = σ² Σᵢ S_ν(λᵢ) φᵢ(x) φᵢ(y), where S_ν(λ) = (2ν/κ² + λ)^{−(ν+d/2)}. This yields a valid positive-definite kernel that respects the manifold geometry, unlike naïve geodesic-distance substitution.
+
+**3. Information-theoretic surprise.** For a GP with posterior predictive p(y*|x,D) = N(μ(x), σ²(x)), the surprise at vertex x is S(x) = −log p(y_obs|x,D) = ½ log(2πσ²) + (y_obs − μ)²/(2σ²). This is the theoretically optimal anomaly score under the model.
+
+## References
+
+- Borovitskiy et al. (2020). Matérn Gaussian Processes on Riemannian Manifolds. NeurIPS.
+- Sun, Ovsjanikov & Guibas (2009). Heat Kernel Signature. SGP.
+- Aubry, Schlickewei & Cremers (2011). Wave Kernel Signature. ICCV.
+- Sharp & Crane (2020). A Laplacian for Nonmanifold Triangle Meshes. SGP.
+- Seidlitz et al. (2018). Morphometric Similarity Networks. Neuron.
+- Marquand et al. (2019). Normative modeling in neuroimaging. Nature Protocols.
+
+## Citation
+
+If you use CorticalFields in your research, please cite:
+
+```bibtex
+@software{corticalfields2026,
+  author = {Velho Mago},
+  title = {CorticalFields: Geodesic-aware GP normative modeling on cortical surfaces},
+  year = {2026},
+  url = {https://github.com/rdneuro/corticalfields},
+}
+```
+
+## License
+
+MIT

corticalfields-0.1.1/pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "corticalfields"
+version = "0.1.1"
+description = "Geodesic-aware Gaussian Process normative modeling on cortical surfaces with spectral shape descriptors and information-theoretic surprise maps."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "rdneuro", email = "r.debona@ufrj.br"},
+]
+keywords = [
+    "neuroimaging", "cortical-surface", "gaussian-process",
+    "normative-modeling", "epilepsy", "heat-kernel-signature",
+    "laplace-beltrami", "surprise-maps", "spectral-analysis",
+    "bayesian-inference",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Medical Science Apps.",
+]
+
+dependencies = [
+    "numpy>=1.24",
+    "scipy>=1.10",
+    "nibabel>=5.0",
+    "torch>=2.0",
+    "gpytorch>=1.11",
+    "scikit-sparse>=0.4",
+    "trimesh>=4.0",
+    "pyvista>=0.42",
+    "matplotlib>=3.7",
+    "tqdm>=4.65",
+    "joblib>=1.3",
+]
+
+[project.optional-dependencies]
+full = [
+    "robust-laplacian>=0.2",
+    "potpourri3d>=0.0.8",
+    "geometric-kernels>=0.2",
+    "pymc>=5.10",
+    "giotto-tda>=0.6",
+    "torch-geometric>=2.4",
+    "surfplot>=0.2",
+    "brainspace>=0.1",
+    "neuromaps>=0.0.4",
+]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/rdneuro/corticalfields"
+Documentation = "https://corticalfields.readthedocs.io"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py39"

corticalfields-0.1.1/setup.cfg

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

corticalfields-0.1.1/src/corticalfields/__init__.py

@@ -0,0 +1,75 @@
+"""
+CorticalFields — Geodesic-aware GP normative modeling on cortical surfaces.
+
+A library for computing information-theoretic surprise maps on the cortical
+manifold using spectral Matérn Gaussian Processes, Heat Kernel Signatures,
+and Laplace–Beltrami spectral analysis. Designed for structural MRI (T1w)
+data in clinical neuroimaging, with emphasis on epilepsy (MTLE-HS).
+
+Core pipeline:
+    1. Load FreeSurfer surfaces and morphometric overlays
+    2. Compute Laplace–Beltrami eigenpairs on the cortical mesh
+    3. Extract spectral shape descriptors (HKS, WKS, GPS)
+    4. Build spectral Matérn GP kernels on the manifold
+    5. Fit normative models on a reference cohort
+    6. Generate vertex-wise surprise / anomaly maps for patients
+
+Modules
+-------
+surface     : Surface I/O — FreeSurfer, GIfTI, mesh utilities
+spectral    : Laplace–Beltrami decomposition, HKS, WKS, GPS
+kernels     : Spectral Matérn kernels for GPyTorch
+normative   : GP-based normative modeling pipeline
+surprise    : Information-theoretic anomaly scoring
+features    : Morphometric feature extraction from FreeSurfer
+graphs      : Cortical similarity network construction
+viz         : Publication-quality surface visualization
+"""
+
+__version__ = "0.1.0"
+__author__ = "Velho Mago (rdneuro)"
+
+# ── Lazy imports ────────────────────────────────────────────────────────
+# Heavy dependencies (torch, gpytorch) are only loaded when the modules
+# that need them are first accessed. This keeps `import corticalfields`
+# fast and memory-light for submodule-level usage.
+
+
+def __getattr__(name: str):
+    """Lazy attribute loader — imports submodules on first access."""
+    _MAP = {
+        # surface.py (lightweight — numpy/nibabel only)
+        "CorticalSurface": ("corticalfields.surface", "CorticalSurface"),
+        "load_freesurfer_surface": ("corticalfields.surface", "load_freesurfer_surface"),
+        # spectral.py (lightweight — numpy/scipy only)
+        "LaplaceBeltrami": ("corticalfields.spectral", "LaplaceBeltrami"),
+        "heat_kernel_signature": ("corticalfields.spectral", "heat_kernel_signature"),
+        "wave_kernel_signature": ("corticalfields.spectral", "wave_kernel_signature"),
+        "global_point_signature": ("corticalfields.spectral", "global_point_signature"),
+        # kernels.py (heavy — torch + gpytorch)
+        "SpectralMaternKernel": ("corticalfields.kernels", "SpectralMaternKernel"),
+        # normative.py (heavy — torch + gpytorch)
+        "CorticalNormativeModel": ("corticalfields.normative", "CorticalNormativeModel"),
+        # surprise.py (lightweight — numpy/scipy only)
+        "SurpriseMap": ("corticalfields.surprise", "SurpriseMap"),
+        "compute_surprise": ("corticalfields.surprise", "compute_surprise"),
+        # features.py (lightweight)
+        "MorphometricProfile": ("corticalfields.features", "MorphometricProfile"),
+    }
+    if name in _MAP:
+        module_path, attr = _MAP[name]
+        import importlib
+        mod = importlib.import_module(module_path)
+        return getattr(mod, attr)
+    raise AttributeError(f"module 'corticalfields' has no attribute {name!r}")
+
+
+__all__ = [
+    "CorticalSurface", "load_freesurfer_surface",
+    "LaplaceBeltrami", "heat_kernel_signature",
+    "wave_kernel_signature", "global_point_signature",
+    "SpectralMaternKernel",
+    "CorticalNormativeModel",
+    "SurpriseMap", "compute_surprise",
+    "MorphometricProfile",
+]