yabplot 0.5.0__tar.gz → 0.5.1__tar.gz

yabplot-0.5.1/CITATION.cff

@@ -0,0 +1,21 @@
+cff-version: 1.2.0
+message: "If you use yabplot in your research, please cite it as below."
+authors:
+- family-names: "Anijärv"
+  given-names: "Toomas Erik"
+  orcid: "https://orcid.org/0000-0002-3650-4230"
+title: "yabplot: yet another brain plot for unified neuroimaging visualization in Python"
+doi: 10.5281/zenodo.18237144
+version: 0.5.1
+url: "https://github.com/teanijarv/yabplot"
+preferred-citation:
+  type: software
+  authors:
+  - family-names: "Anijärv"
+    given-names: "Toomas Erik"
+    orcid: "https://orcid.org/0000-0002-3650-4230"
+  title: "yabplot: yet another brain plot for unified neuroimaging visualization in Python"
+  year: 2026
+  doi: 10.5281/zenodo.18237144
+  url: "https://github.com/teanijarv/yabplot"
+  abstract: "An open-source Python package for 3D neuroimaging visualization."

yabplot-0.5.1/CODE_OF_CONDUCT.md

@@ -0,0 +1,27 @@
+# code of conduct
+
+## our pledge
+in the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## our standards
+examples of behavior that contributes to creating a positive environment include:
+* using welcoming and inclusive language
+* being respectful of differing viewpoints and experiences
+* gracefully accepting constructive criticism
+* focusing on what is best for the community
+* showing empathy towards other community members
+
+examples of unacceptable behavior by participants include:
+* the use of sexualized language or imagery and unwelcome sexual attention or advances
+* trolling, insulting/derogatory comments, and personal or political attacks
+* public or private harassment
+* publishing others' private information, such as a physical or electronic address, without explicit permission
+* other conduct which could reasonably be considered inappropriate in a professional setting
+
+## our responsibilities
+as the maintainers of this project, we are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+we have the right and responsibility to remove, edit, or reject comments, commits, code, docs edits, issues, and other contributions that are not aligned to this code of conduct, or to ban temporarily or permanently any contributor for other behaviors that we deem inappropriate, threatening, offensive, or harmful.
+
+## enforcement
+instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting us at teanijarv@pm.me. all complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. we are obligated to maintain confidentiality with regard to the reporter of an incident.

yabplot-0.5.1/CONTRIBUTING.md

@@ -0,0 +1,34 @@
+# contributing to yabplot
+
+thank you for your interest in contributing to `yabplot`! we welcome contributions from the neuroimaging and open-source communities.
+
+## how to contribute
+
+### reporting bugs
+- use the [github issue tracker](https://github.com/teanijarv/yabplot/issues) to report bugs.
+- include a minimal reproducible example and information about your environment (os, python version, package versions).
+
+### suggesting enhancements
+- open an issue describing the proposed feature and why it would be useful for the community.
+
+### pull requests
+1. fork the repository and create your branch from `main`.
+2. if you've added code that should be tested, add tests in the `tests/` directory.
+3. if you've changed API, update the documentation.
+4. ensure the test suite passes: `uv run pytest tests/`
+5. submit a pull request with a clear description of the changes.
+
+## development setup
+
+we use `uv` for dependency management. to set up your development environment:
+
+```bash
+git clone https://github.com/teanijarv/yabplot.git
+cd yabplot
+uv venv
+uv pip install -e ".[docs]"
+uv pip install pytest
+```
+
+## community
+by contributing, you agree to abide by our [code of conduct](CODE_OF_CONDUCT.md).

yabplot-0.5.1/MANIFEST.in

@@ -0,0 +1,9 @@
+include pyproject.toml
+include README.md
+include LICENSE
+include CITATION.cff
+include CONTRIBUTING.md
+include CODE_OF_CONDUCT.md
+
+recursive-include yabplot *.txt *.json *.md
+recursive-include tests *.py

{yabplot-0.5.0/yabplot.egg-info → yabplot-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yabplot
-Version: 0.5.0
+Version: 0.5.1
 Summary: yet another brain plot
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{yabplot-0.5.0 → yabplot-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yabplot"
-version = "0.5.0"
+version = "0.5.1"
 description = "yet another brain plot"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,3 +32,8 @@ include = ["yabplot*"]
 
 [tool.setuptools.package-data]
 "yabplot" = ["*.txt", "*.json"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+]

yabplot-0.5.1/tests/conftest.py

@@ -0,0 +1,51 @@
+import pytest
+import numpy as np
+import nibabel as nib
+import pyvista as pv
+
+pv.OFF_SCREEN = True
+
+@pytest.fixture
+def synthetic_nifti(tmp_path):
+    """Generates a simple 3D NIfTI file with a sphere of high intensity."""
+    shape = (20, 20, 20)
+    data = np.zeros(shape)
+
+    # create a simple sphere
+    cz, cy, cx = 10, 10, 10
+    r = 5
+    z, y, x = np.ogrid[:shape[0], :shape[1], :shape[2]]
+    mask = (z - cz)**2 + (y - cy)**2 + (x - cx)**2 <= r**2
+    data[mask] = 10.0
+
+    affine = np.eye(4)
+    img = nib.Nifti1Image(data, affine)
+    file_path = tmp_path / "synthetic.nii.gz"
+    nib.save(img, file_path)
+    return str(file_path)
+
+@pytest.fixture
+def synthetic_nifti_4d(tmp_path):
+    """Generates a 4D NIfTI file."""
+    shape = (20, 20, 20, 3)
+    data = np.random.rand(*shape)
+    affine = np.eye(4)
+    img = nib.Nifti1Image(data, affine)
+    file_path = tmp_path / "synthetic_4d.nii.gz"
+    nib.save(img, file_path)
+    return str(file_path)
+
+@pytest.fixture
+def synthetic_tractogram(tmp_path):
+    """Generates a simple tractogram."""
+    from nibabel.streamlines.tractogram import Tractogram
+    from nibabel.streamlines.trk import TrkFile
+
+    streamlines = [
+        np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]], dtype=np.float32),
+        np.array([[10, 10, 10], [11, 10, 10], [12, 10, 10]], dtype=np.float32)
+    ]
+    tractogram = Tractogram(streamlines, affine_to_rasmm=np.eye(4))
+    file_path = tmp_path / "synthetic.trk"
+    TrkFile(tractogram).save(file_path)
+    return str(file_path)

yabplot-0.5.1/tests/test_data.py

@@ -0,0 +1,41 @@
+import pytest
+from yabplot.data import get_available_resources, get_atlas_regions
+
+def test_get_available_resources():
+    """Verify that all resource categories exist and contain data."""
+    # all categories
+    res_all = get_available_resources(None)
+    assert isinstance(res_all, dict)
+
+    expected_categories = ['cortical', 'subcortical', 'tracts', 'bmesh']
+    for cat in expected_categories:
+        assert cat in res_all, f"expected category {cat} to be in resources"
+        assert len(res_all[cat]) > 0
+
+    # specific category
+    res_cortical = get_available_resources('cortical')
+    assert isinstance(res_cortical, list)
+    assert 'aparc' in res_cortical
+
+def test_get_atlas_regions_cortical():
+    """Verify that cortical atlas regions are correctly retrieved."""
+    regions = get_atlas_regions('aparc', 'cortical')
+    assert isinstance(regions, list)
+    assert len(regions) > 0
+
+def test_get_atlas_regions_subcortical():
+    """Verify that subcortical atlas regions are correctly retrieved."""
+    regions = get_atlas_regions('aseg', 'subcortical')
+    assert isinstance(regions, list)
+    assert len(regions) > 0
+
+def test_get_atlas_regions_tracts():
+    """Verify that tract atlas regions are correctly retrieved."""
+    regions = get_atlas_regions('xtract_tiny', 'tracts')
+    assert isinstance(regions, list)
+    assert len(regions) > 0
+
+def test_get_atlas_regions_invalid():
+    """Verify that invalid categories return an empty list gracefully."""
+    regions = get_atlas_regions('aparc', 'invalid_category')
+    assert regions == []

yabplot-0.5.1/tests/test_mapping.py

@@ -0,0 +1,78 @@
+import pytest
+import numpy as np
+import pandas as pd
+from yabplot.mesh import map_values_to_surface
+from yabplot.utils import prep_data
+
+def test_prep_data_array():
+    """Verify that 1D arrays are correctly mapped to a dictionary by position."""
+    regions = ['A', 'B', 'C']
+    data = [1, 2, 3]
+    result = prep_data(data, regions, 'test_atlas', 'cortical')
+    assert isinstance(result, dict)
+    assert result['A'] == 1
+    assert result['C'] == 3
+
+def test_prep_data_dict():
+    """Verify that dictionaries are passed through correctly."""
+    regions = ['A', 'B', 'C']
+    data = {'A': 10, 'B': 20}
+    result = prep_data(data, regions, 'test_atlas', 'cortical')
+    assert isinstance(result, dict)
+    assert result['A'] == 10
+    assert result['B'] == 20
+
+def test_prep_data_series():
+    """Verify that pandas Series are correctly converted using their index."""
+    regions = ['A', 'B', 'C']
+    data = pd.Series([100, 200], index=['A', 'C'])
+    result = prep_data(data, regions, 'test_atlas', 'cortical')
+    assert result['A'] == 100
+    assert result['C'] == 200
+
+def test_prep_data_dataframe():
+    """Verify that pandas DataFrames are correctly handled by index or column mapping."""
+    regions = ['A', 'B', 'C']
+    # 1-col dataframe will use index as labels
+    data_1col = pd.DataFrame({'val': [5, 6]}, index=['B', 'A'])
+    result_1col = prep_data(data_1col, regions, 'test_atlas', 'cortical')
+    assert result_1col['A'] == 6
+    assert result_1col['B'] == 5
+
+    # 2-col dataframe will use first column as labels and second as values
+    df2 = pd.DataFrame({'Region': ['B', 'A'], 'Value': [50, 60]})
+    result_2col = prep_data(df2, regions, 'test_atlas', 'cortical')
+    assert result_2col['A'] == 60
+    assert result_2col['B'] == 50
+
+def test_prep_data_length_mismatch():
+    """Verify that an array length mismatch raises a ValueError."""
+    regions = ['A', 'B', 'C']
+    data = [1, 2] # length mismatch
+    with pytest.raises(ValueError, match="Data length mismatch"):
+        prep_data(data, regions, 'test_atlas', 'cortical')
+
+def test_map_values_to_surface():
+    """Verify that atlas scalar mapping correctly handles data injection and NaNs."""
+    target_labels = np.array([0, 1, 2, 1, 0, 3])
+    lut_ids = np.array([0, 1, 2, 3])
+    dense_lut_names = ['Region0', 'Region1', 'Region2', 'Region3']
+
+    # dict input
+    data_dict = {'Region1': 10.0, 'Region2': 20.0}
+    res_dict = map_values_to_surface(data_dict, target_labels, lut_ids, dense_lut_names)
+    assert np.isnan(res_dict[0]) # region 0 mapped to NaN
+    assert res_dict[1] == 10.0   # region 1 mapped to 10
+    assert res_dict[2] == 20.0   # region 2 mapped to 20
+    assert np.isnan(res_dict[5]) # target 3 -> region 3 mapped to NaN
+
+    # array input
+    data_arr = [0.0, 1.0, 2.0, 3.0]
+    res_arr = map_values_to_surface(data_arr, target_labels, lut_ids, dense_lut_names)
+    assert res_arr[0] == 0.0
+    assert res_arr[1] == 1.0
+    assert res_arr[5] == 3.0
+
+    # mismatch length array
+    with pytest.raises(ValueError):
+        map_values_to_surface([1.0, 2.0], target_labels, lut_ids, dense_lut_names)

yabplot-0.5.1/tests/test_mesh.py

@@ -0,0 +1,24 @@
+import pytest
+import numpy as np
+import pyvista as pv
+from yabplot.mesh import load_nii_as_mesh, make_cortical_mesh
+
+def test_load_nii_as_mesh(synthetic_nifti):
+    """Verify that marching cubes mesh extraction works on a NIfTI volume."""
+    mesh = load_nii_as_mesh(synthetic_nifti, threshold=5.0, blur_sigma=0, smooth_i=0)
+    assert isinstance(mesh, pv.PolyData)
+    assert mesh.n_points > 0
+    assert mesh.n_cells > 0
+
+def test_make_cortical_mesh():
+    """Verify that a manual mesh can be constructed from vertex and face arrays."""
+    verts = np.array([[0,0,0], [1,0,0], [0,1,0], [0,0,1]], dtype=np.float32)
+    faces = np.array([[0,1,2], [0,1,3], [0,2,3], [1,2,3]], dtype=np.int64)
+    scalars = np.array([1, 2, 3, 4], dtype=np.float32)
+    mesh = make_cortical_mesh(verts, faces, scalars, scalar_name='TestData')
+
+    assert isinstance(mesh, pv.PolyData)
+    assert mesh.n_points == 4
+    assert mesh.n_cells == 4
+    assert 'TestData' in mesh.point_data
+    assert np.all(mesh.point_data['TestData'] == scalars)

yabplot-0.5.1/tests/test_plotting.py

@@ -0,0 +1,93 @@
+import pytest
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+import yabplot as yab
+import pyvista as pv
+
+# tell PyVista to run in "off-screen" mode so it doesn't try to open a real window
+pv.OFF_SCREEN = True
+
+def test_version():
+    """Check that the package has a version string."""
+    assert yab.__version__ is not None
+
+def test_none_returns_empty_dict():
+    """Verify that passing None disables the background mesh."""
+    result = yab.mesh.load_bmesh(None)
+    assert result == {}
+
+def test_dict_passthrough():
+    """Verify that custom dictionary keys for hemispheres are properly sanitized."""
+    mesh_l = pv.Sphere()
+    mesh_r = pv.Cube()
+    mesh_other = pv.Cone()
+    d = {'left': mesh_l, 'RIGHT': mesh_r, 'other': mesh_other}
+    result = yab.mesh.load_bmesh(d)
+    expected = {'L': mesh_l, 'R': mesh_r, 'other': mesh_other}
+    assert result == expected
+
+def test_polydata_wrapped_in_both():
+    """Verify that passing a single PyVista mesh safely wraps it."""
+    mesh = pv.Sphere()
+    result = yab.mesh.load_bmesh(mesh)
+    assert 'both' in result
+    assert result['both'] is mesh
+
+def test_plotter_instantiation():
+    """Smoke test: can we create a Plotter without crashing?"""
+    plotter = pv.Plotter(off_screen=True)
+    plotter.add_mesh(pv.Sphere())
+    plotter.show()
+    plotter.close()
+
+def test_plot_cortical():
+    """Smoke test: verify that plot_cortical renders with standard atlas."""
+    yab.plot_cortical(atlas='aparc', display_type='matplotlib')
+
+def test_plot_subcortical():
+    """Smoke test: verify that plot_subcortical renders with standard atlas."""
+    yab.plot_subcortical(atlas='aseg', display_type='matplotlib')
+
+def test_plot_tracts():
+    """Smoke test: verify that plot_tracts renders with standard atlas."""
+    yab.plot_tracts(atlas='xtract_tiny', display_type='matplotlib')
+
+def test_plot_vertexwise():
+    """Smoke test: verify that plot_vertexwise renders with custom meshes."""
+    lh = pv.Sphere()
+    rh = pv.Sphere()
+    lh['Data'] = np.random.rand(lh.n_points)
+    rh['Data'] = np.random.rand(rh.n_points)
+    yab.plot_vertexwise(lh, rh, display_type='matplotlib')
+
+def test_plot_voxelwise(synthetic_nifti):
+    """Smoke test: verify that plot_voxelwise renders with synthetic volume."""
+    yab.plot_voxelwise(synthetic_nifti, threshold=5.0, blur_sigma=0, display_type='matplotlib')
+
+def test_plot_connectome():
+    """Smoke test: verify that plot_connectome renders both nodes-only and matrix modes."""
+    yab.plot_connectome(atlas='aparc', display_type='matplotlib')
+    # plotting with a dummy matrix
+    regions = yab.get_atlas_regions('aparc', 'cortical')
+    n = len(regions)
+    matrix = np.random.rand(n, n)
+    yab.plot_connectome(matrix=matrix, atlas='aparc', edge_threshold=0.5, display_type='matplotlib')
+
+
+def test_matplotlib_ax_compatibility():
+    """Verify that plotting on a provided Matplotlib axis works correctly."""
+    fig, ax = plt.subplots()
+    ret_ax = yab.plot_cortical(atlas='aparc', ax=ax, display_type='matplotlib')
+    assert ret_ax is ax
+    # verify ax is usable
+    ret_ax.set_title("Test Title")
+    assert ret_ax.get_title() == "Test Title"
+    plt.close(fig)
+
+def test_export_path(tmp_path):
+    """Verify that export_path correctly saves a file to disk."""
+    out_file = tmp_path / "test_export.png"
+    yab.plot_cortical(atlas='aparc', display_type='matplotlib', export_path=str(out_file))
+    assert out_file.exists()
+    assert out_file.stat().st_size > 0

yabplot-0.5.1/tests/test_projection.py

@@ -0,0 +1,25 @@
+import pytest
+import numpy as np
+from yabplot.projection import project_vol2surf, project_vol2tract
+
+def test_project_vol2surf(synthetic_nifti):
+    """Verify that a 3D NIfTI can be projected onto the cortical surface."""
+    lh_data, rh_data = project_vol2surf(synthetic_nifti, bmesh='midthickness', mask_medial_wall=False, interpolation='linear')
+    assert isinstance(lh_data, np.ndarray)
+    assert isinstance(rh_data, np.ndarray)
+    assert len(lh_data) > 0
+    assert len(rh_data) > 0
+
+def test_project_vol2tract(synthetic_tractogram, synthetic_nifti):
+    """Verify that a 3D NIfTI can be projected onto a tractogram."""
+    data = project_vol2tract(synthetic_tractogram, synthetic_nifti, interpolation='linear')
+    assert isinstance(data, np.ndarray)
+    assert len(data) > 0
+
+def test_project_invalid_interpolation(synthetic_nifti):
+    """Verify that invalid interpolation modes raise an error."""
+    with pytest.raises(ValueError, match="interpolation must be"):
+        project_vol2surf(synthetic_nifti, bmesh='midthickness', interpolation='invalid')
+
+    with pytest.raises(ValueError, match="interpolation must be"):
+        project_vol2tract("dummy.trk", synthetic_nifti, interpolation='invalid')

{yabplot-0.5.0 → yabplot-0.5.1}/yabplot/projection.py

@@ -7,26 +7,26 @@ def project_vol2surf(nii_path, bmesh='midthickness', mask_medial_wall=True, inte
     """
     Projects a 3D NIfTI volume onto 2D cortical surface vertices.
 
-    It maps volumetric data directly onto surface meshes by converting real-world coordinates 
+    It maps volumetric data directly onto surface meshes by converting real-world coordinates
     using the image affine and sampling the data array at those exact points.
 
     Parameters
     ----------
     nii_path : str
-        absolute path to the 3D or 4D NIfTI volume. 
+        absolute path to the 3D or 4D NIfTI volume.
         if 4D, only the first volume/timepoint is used.
     bmesh : str, dict, or pyvista.PolyData, optional
-        background mesh to use for projection coordinates. accepts a standard 
-        string (e.g., 'midthickness') or a dictionary of custom pyvista meshes 
+        background mesh to use for projection coordinates. accepts a standard
+        string (e.g., 'midthickness') or a dictionary of custom pyvista meshes
         {'L': mesh, 'R': mesh}. default is 'midthickness'.
     mask_medial_wall : bool, optional
-        whether to automatically set the medial wall vertices to NaN to prevent 
-        subcortical signal from bleeding onto the cortical surface. 
+        whether to automatically set the medial wall vertices to NaN to prevent
+        subcortical signal from bleeding onto the cortical surface.
         Note: only supported if `bmesh` is a standard string. default is True.
     interpolation : {'linear', 'nearest'}, optional
-        interpolation method for sampling the volume. 'linear' performs trilinear 
-        interpolation (smoother, good for continuous t-stats), while 'nearest' 
-        snaps to the closest voxel center (strictly required for p-values or atlases). 
+        interpolation method for sampling the volume. 'linear' performs trilinear
+        interpolation (smoother, good for continuous t-stats), while 'nearest'
+        snaps to the closest voxel center (strictly required for p-values or atlases).
         default is 'linear'.
 
     Returns
@@ -42,19 +42,22 @@ def project_vol2surf(nii_path, bmesh='midthickness', mask_medial_wall=True, inte
     # load volume
     img = nib.load(nii_path)
     vol_data = img.get_fdata()
-    
+
     if vol_data.ndim > 3:
         warnings.warn(f"[WARNING] detected {vol_data.ndim}d nifti volume. using the first volume (index 0).")
-        vol_data = vol_data[..., 0] 
-        
+        vol_data = vol_data[..., 0]
+
     inv_affine = np.linalg.inv(img.affine)
 
     # load brain mesh
     loaded_meshes = load_bmesh(bmesh)
-    
+
+    if interpolation not in ['linear', 'nearest']:
+        raise ValueError("interpolation must be 'linear' or 'nearest'")
+
     if 'L' not in loaded_meshes or 'R' not in loaded_meshes:
         raise ValueError("project_vol2surf requires both 'L' and 'R' hemispheres in the bmesh dictionary.")
-        
+
     # extract raw coordinates for math
     lh_v, _ = extract_polydata(loaded_meshes['L'])
     rh_v, _ = extract_polydata(loaded_meshes['R'])
@@ -89,8 +92,8 @@ def project_vol2surf(nii_path, bmesh='midthickness', mask_medial_wall=True, inte
 def project_vol2tract_atlas(nii_path, atlas='xtract_tiny', custom_atlas_path=None, interpolation='linear'):
     """
     Samples a 3D volume across all tracts in a specific atlas.
-    This is a convenience function around `project_vol2tract` that automatically 
-    resolves the atlas paths, loops through all available tractograms, and returns 
+    This is a convenience function around `project_vol2tract` that automatically
+    resolves the atlas paths, loops through all available tractograms, and returns
     a dictionary ready to be passed directly to `plot_tracts`.
 
     Parameters
@@ -110,23 +113,23 @@ def project_vol2tract_atlas(nii_path, atlas='xtract_tiny', custom_atlas_path=Non
         dictionary mapping tract names to their 1D sampled data arrays.
     """
     from .data import _resolve_resource_path, _find_tract_files
-    
+
     # resolve the atlas directory and locate all tract files
     atlas_dir = _resolve_resource_path(atlas, 'tracts', custom_path=custom_atlas_path)
     tract_files = _find_tract_files(atlas_dir)
-    
+
     tract_data = {}
-    
+
     # loop through and map the volume to each tract
     for name, trk_path in tract_files.items():
         tract_data[name] = project_vol2tract(trk_path, nii_path, interpolation)
-        
+
     return tract_data
 
 
 def project_vol2tract(trk_path, nii_path, interpolation='linear'):
     """
-    Samples a 3D volume natively at every vertex of a tractogram. Maps the streamline 
+    Samples a 3D volume natively at every vertex of a tractogram. Maps the streamline
     coordinates directly into the volumetric voxel space using the image affine.
 
     Parameters
@@ -141,29 +144,32 @@ def project_vol2tract(trk_path, nii_path, interpolation='linear'):
     Returns
     -------
     numpy.ndarray
-        1D array of sampled values corresponding exactly to the flattened 
+        1D array of sampled values corresponding exactly to the flattened
         points of the tractogram, ready to be injected into plot_tracts.
     """
+    if interpolation not in ['linear', 'nearest']:
+        raise ValueError("interpolation must be 'linear' or 'nearest'")
+
     # load the 3D volume
     img = nib.load(nii_path)
     vol_data = img.get_fdata()
     if vol_data.ndim > 3:
         vol_data = vol_data[..., 0]
-        
+
     inv_affine = np.linalg.inv(img.affine)
 
     # load the tractogram
     trk = nib.streamlines.load(trk_path)
-    
+
     # stack all streamline coordinates into a single (n_points, 3) array
     points = np.vstack(trk.streamlines)
-    
+
     # convert coordinates using the inverse affine
     coords_homo = np.hstack((points, np.ones((points.shape[0], 1))))
     vox_coords = inv_affine.dot(coords_homo.T)[:3, :]
-    
+
     # sample the volume
     order = 1 if interpolation == 'linear' else 0
     sampled_data = map_coordinates(vol_data, vox_coords, order=order, mode='nearest')
-    
-    return sampled_data
+
+    return sampled_data

{yabplot-0.5.0 → yabplot-0.5.1}/yabplot/utils.py

@@ -15,7 +15,7 @@ def load_gii(gii_path):
 def load_gii2pv(gii_path, smooth_i=0, smooth_f=0.1):
     """
     Load GIfTI and convert to PyVista format with optional smoothing.
-    
+
     Parameters
     ----------
     smooth_i : int
@@ -24,18 +24,18 @@ def load_gii2pv(gii_path, smooth_i=0, smooth_f=0.1):
         Relaxation factor (0.0 to 1.0, e.g. 0.6).
     """
     verts, faces = load_gii(gii_path)
-    
+
     # create pyvista mesh
     faces_pv = np.hstack([np.full((faces.shape[0], 1), 3), faces]).flatten().astype(int)
     mesh = pv.PolyData(verts, faces_pv)
-    
+
     # apply smoothing
     if smooth_i > 0:
         # use Laplacian smoothing (standard vtkSmoothPolyDataFilter)
         # note: higher relaxation factors can shrink the mesh significantly
         # if shrinkage is an issue, could consider mesh.smooth_taubin() instead
         mesh = mesh.smooth(n_iter=smooth_i, relaxation_factor=smooth_f)
-    
+
     return mesh
 
 def array_to_gifti(arr, out_path):
@@ -57,6 +57,8 @@ def prep_data(data, regions, atlas, category):
     if isinstance(data, pd.DataFrame):
         if data.shape[1] >= 2:
             data = dict(zip(data.iloc[:, 0], data.iloc[:, 1]))
+        else:
+            data = data.iloc[:, 0].to_dict()
     elif isinstance(data, pd.Series):
         data = data.to_dict()
     elif isinstance(data, (list, np.ndarray, tuple)):
@@ -94,34 +96,34 @@ def parse_lut(lut_path):
     # load and sort by ID to ensure strict order (1..N)
     df = pd.read_csv(lut_path, sep=r'\s+', header=None)
     df = df.sort_values(by=0)
-    
+
     ids = df[0].values
     names = df[1].tolist()
     rgb = df.iloc[:, 2:5].values / 255.0
-    
+
     max_id = ids.max()
-    
-    lut_colors = np.full((max_id + 1, 3), 0.5) 
+
+    lut_colors = np.full((max_id + 1, 3), 0.5)
     lut_names_list = ["Unknown"] * (max_id + 1)
-    
+
     lut_colors[ids] = rgb
     for idx, name in zip(ids, names):
         lut_names_list[idx] = name
-        
+
     return ids, lut_colors, lut_names_list, max_id
 
 
 def load_tsf(tsf_path: str) -> np.ndarray:
     """
-    Reads an MRtrix3 .tsf (track scalar file). Useful for users who 
-    have already computed tractometry metrics using MRtrix3's `tcksample` 
+    Reads an MRtrix3 .tsf (track scalar file). Useful for users who
+    have already computed tractometry metrics using MRtrix3's `tcksample`
     command and want to plot the resulting values in yabplot.
-    
+
     Parameters
     ----------
     tsf_path : str
         absolute path to the .tsf file.
-        
+
     Returns
     -------
     numpy.ndarray
@@ -129,7 +131,7 @@ def load_tsf(tsf_path: str) -> np.ndarray:
     """
     if not os.path.isfile(tsf_path):
         raise FileNotFoundError(f"File not found: {tsf_path}")
-    
+
     header: dict[str, str] = {}
     data_offset: int | None = None
 

{yabplot-0.5.0 → yabplot-0.5.1/yabplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yabplot
-Version: 0.5.0
+Version: 0.5.1
 Summary: yet another brain plot
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{yabplot-0.5.0 → yabplot-0.5.1}/yabplot.egg-info/SOURCES.txt

@@ -1,8 +1,16 @@
+CITATION.cff
+CODE_OF_CONDUCT.md
+CONTRIBUTING.md
 LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
-tests/test_smoke.py
+tests/conftest.py
+tests/test_data.py
+tests/test_mapping.py
+tests/test_mesh.py
+tests/test_plotting.py
+tests/test_projection.py
 yabplot/__init__.py
 yabplot/atlas_builder.py
 yabplot/mesh.py

yabplot-0.5.0/MANIFEST.in

@@ -1,4 +0,0 @@
-include pyproject.toml
-include README.md
-include LICENSE
-recursive-include yabplot *.txt *.json *.md

yabplot-0.5.0/tests/test_smoke.py

@@ -1,80 +0,0 @@
-import pytest
-import numpy as np
-import yabplot as yab
-import pyvista as pv
-
-# tell PyVista to run in "off-screen" mode so it doesn't try to open a real window
-pv.OFF_SCREEN = True
-
-def test_version():
-    """Check that the package has a version string."""
-    assert yab.__version__ is not None
-
-def test_none_returns_empty_dict():
-    """
-    Unit test: Verify that passing None disables the background mesh 
-    by correctly returning an empty dictionary.
-    """
-    result = yab.mesh.load_bmesh(None)
-    assert result == {}
-
-def test_dict_passthrough():
-    """
-    Unit test: Verify that custom dictionary keys for hemispheres 
-    are properly sanitized to strict 'L' and 'R' keys.
-    """
-    mesh_l = pv.Sphere()
-    mesh_r = pv.Cube()
-    mesh_other = pv.Cone()
-    d = {'left': mesh_l, 'RIGHT': mesh_r, 'other': mesh_other}
-    result = yab.mesh.load_bmesh(d)
-    expected = {'L': mesh_l, 'R': mesh_r, 'other': mesh_other}
-    assert result == expected
-
-def test_polydata_wrapped_in_both():
-    """
-    Unit test: Verify that passing a single PyVista mesh (whole brain) 
-    safely wraps it in a dictionary with the 'both' key.
-    """
-    mesh = pv.Sphere()
-    result = yab.mesh.load_bmesh(mesh)
-    assert 'both' in result
-    assert result['both'] is mesh
-
-def test_plotter_instantiation():
-    """
-    Smoke test: Can we create a Plotter without crashing?
-    This verifies VTK and PyVista are correctly linked to the system display.
-    """
-    plotter = pv.Plotter(off_screen=True)
-    plotter.add_mesh(pv.Sphere())
-    plotter.show()
-    plotter.close()
-
-def test_plot_cortical():
-    """
-    Integration test: Downloads 'aparc' and plots it.
-    """
-    yab.plot_cortical(atlas='aparc', display_type=None)
-
-def test_plot_subcortical():
-    """
-    Integration test: Downloads 'aseg' and plots it.
-    """
-    yab.plot_subcortical(atlas='aseg', display_type=None)
-
-def test_plot_tracts():
-    """
-    Integration test: Downloads 'xtract_tiny' and plots it.
-    """
-    yab.plot_tracts(atlas='xtract_tiny', display_type=None)
-
-def test_plot_vertexwise():
-    """
-    Integration test: plot_vertexwise with synthetic sphere meshes.
-    """
-    lh = pv.Sphere()
-    rh = pv.Sphere()
-    lh['Data'] = np.random.rand(lh.n_points)
-    rh['Data'] = np.random.rand(rh.n_points)
-    yab.plot_vertexwise(lh, rh, display_type=None)