yabplot 0.1.5__tar.gz → 0.2.2__tar.gz

{yabplot-0.1.5/yabplot.egg-info → yabplot-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yabplot
-Version: 0.1.5
+Version: 0.2.2
 Summary: yet another brain plot
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -55,6 +55,9 @@ pip install yabplot --upgrade # to update
 
 dependencies: python 3.11 with ipywidgets, nibabel, pandas, pooch, pyvista, scikit-image, trame, trame-vtk, trame-vuetify
 
+(Connectome Workbench (`wb_command`) is a requirement to create custom cortical atlases unless you plan to only use pre-loaded atlases; see more in docs)
+
+
 ## quick start
 
 please refer to the [documentation](https://teanijarv.github.io/yabplot/) for more comprehensive guides.

{yabplot-0.1.5 → yabplot-0.2.2}/README.md

@@ -32,6 +32,9 @@ pip install yabplot --upgrade # to update
 
 dependencies: python 3.11 with ipywidgets, nibabel, pandas, pooch, pyvista, scikit-image, trame, trame-vtk, trame-vuetify
 
+(Connectome Workbench (`wb_command`) is a requirement to create custom cortical atlases unless you plan to only use pre-loaded atlases; see more in docs)
+
+
 ## quick start
 
 please refer to the [documentation](https://teanijarv.github.io/yabplot/) for more comprehensive guides.

{yabplot-0.1.5 → yabplot-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yabplot"
-version = "0.1.5"
+version = "0.2.2"
 description = "yet another brain plot"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -29,4 +29,4 @@ where = ["."]
 include = ["yabplot*"]
 
 [tool.setuptools.package-data]
-"yabplot" = ["*.txt", "*.json"]
+"yabplot" = ["*.txt", "*.json"]

{yabplot-0.1.5 → yabplot-0.2.2}/yabplot/__init__.py

@@ -1,7 +1,8 @@
 from importlib.metadata import version, PackageNotFoundError
 
 from .plotting import plot_cortical, plot_subcortical, plot_tracts, clear_tract_cache
-from .data import get_available_resources, get_atlas_regions
+from .data import get_available_resources, get_atlas_regions, get_surface_paths
+from .atlas_builder import build_cortical_atlas, build_subcortical_atlas
 
 try:
     __version__ = version("yabplot")

yabplot-0.2.2/yabplot/atlas_builder.py

@@ -0,0 +1,404 @@
+import os
+import glob
+import numpy as np
+import nibabel as nib
+import scipy.sparse as sp
+import pyvista as pv
+from skimage import measure
+from .wrappers import run_wb_import, run_wb_projection
+from .data import get_surface_paths
+from .plotting import plot_cortical, plot_subcortical
+
+### CORTICAL
+
+def _build_adjacency(surf_path, n_vert=32492):
+    """internal helper to build surface adjacency matrix."""
+    surf = nib.load(surf_path)
+    faces = surf.darrays[1].data.astype(int)
+    edges = np.vstack([faces[:, [0, 1]], faces[:, [1, 2]], faces[:, [2, 0]]])
+    row, col = np.concatenate([edges[:, 0], edges[:, 1]]), np.concatenate([edges[:, 1], edges[:, 0]])
+    return sp.coo_matrix((np.ones(len(row), dtype=int), (row, col)), shape=(n_vert, n_vert)).tocsr()
+
+def build_cortical_atlas(nii_path, wb_txt_path, out_dir, include_list=None, exclude_list=None, atlasname='atlas'):
+    """
+    builds a custom yabplot cortical atlas from a volumetric NIfTI file.
+
+    projects a volumetric NIfTI atlas to standard fsLR32k surfaces using connectome workbench, 
+    cleans the medial wall, and applies majority-vote boundary smoothing to remove voxel artifacts.
+
+    parameters
+    ----------
+    nii_path : str
+        absolute path to the 3D NIfTI volume of the atlas.
+    wb_txt_path : str
+        absolute path to the text file formatted specifically for connectome workbench.
+    out_dir : str
+        directory where the final .csv map and .txt LUT will be saved.
+    include_list : list of str, optional
+        keywords of regions to strictly include. all other regions are ignored.
+    exclude_list : list of str, optional
+        keywords of regions to strictly exclude. all other regions are kept.
+    atlasname : str, optional
+        prefix name for the output files. default is 'atlas'.
+
+    raises
+    ------
+    ValueError
+        if both include_list and exclude_list are provided.
+    """
+    if include_list and exclude_list:
+        raise ValueError("please provide either 'include_list' or 'exclude_list', not both.")
+
+    os.makedirs(out_dir, exist_ok=True)
+    
+    # define intermediate and output paths
+    labeled_nii = os.path.join(out_dir, 'temp_labeled.nii.gz')
+    lh_gii = os.path.join(out_dir, 'lh_temp.label.gii')
+    rh_gii = os.path.join(out_dir, 'rh_temp.label.gii')
+    out_csv = os.path.join(out_dir, f'{atlasname}.csv')
+    out_lut = os.path.join(out_dir, f'{atlasname}.txt')
+
+    # fetch standard fsLR32k surfaces and masks via yabplot data system
+    print("fetching standard surfaces...")
+    lh_mid, rh_mid = get_surface_paths('midthickness', 'bmesh')
+    lh_white, rh_white = get_surface_paths('white', 'bmesh')
+    lh_pial, rh_pial = get_surface_paths('pial', 'bmesh')
+    lh_mask_path, rh_mask_path = get_surface_paths('nomedialwall', 'label')
+
+    # run wb_command wrappers
+    print("running volume-to-surface projection...")
+    run_wb_import(nii_path, wb_txt_path, labeled_nii)
+    run_wb_projection(labeled_nii, lh_mid, lh_gii, lh_white, lh_pial)
+    run_wb_projection(labeled_nii, rh_mid, rh_gii, rh_white, rh_pial)
+
+    # extract LUT and apply include/exclude filtering
+    labels_dict = nib.load(lh_gii).labeltable.get_labels_as_dict()
+    valid_ids = []
+    lut_dict = {} 
+    
+    for rid, name in labels_dict.items():
+        if rid == 0 or name == '???': continue 
+        
+        # filter logic
+        if include_list:
+            if not any(inc in name for inc in include_list):
+                continue
+        elif exclude_list:
+            if any(exc in name for exc in exclude_list):
+                continue
+            
+        clean_name = name.replace(' ', '_').replace('/', '-')
+        np.random.seed(rid)
+        r, g, b = np.random.randint(50, 255, 3) 
+        
+        # store the string in the dictionary instead of writing to a file yet
+        lut_dict[rid] = f"{rid}  {clean_name}  {r}  {g}  {b}  0"
+        valid_ids.append(rid)
+        
+    print(f"found {len(valid_ids)} initial cortical regions. mapping and cleaning...")
+
+    # merge LH and RH, then apply masks
+    data = np.concatenate([
+        nib.load(lh_gii).darrays[0].data.astype(int).flatten(),
+        nib.load(rh_gii).darrays[0].data.astype(int).flatten()
+    ])
+    
+    mask = np.concatenate([
+        nib.load(lh_mask_path).darrays[0].data.astype(int).flatten() != 0,
+        nib.load(rh_mask_path).darrays[0].data.astype(int).flatten() != 0
+    ])
+
+    data[~mask] = 0
+    data[~np.isin(data, valid_ids)] = 0
+
+    # build adjacency and run hole-filling
+    print("building surface adjacency and filling holes...")
+    adj = sp.block_diag((_build_adjacency(lh_mid), _build_adjacency(rh_mid))).tocsr()
+    adj.setdiag(1) 
+    n_vert = len(data)
+
+    for _ in range(20): 
+        holes = (data == 0) & mask
+        if not np.any(holes): break
+        
+        unique, inv = np.unique(data, return_inverse=True)
+        one_hot = sp.coo_matrix((np.ones(n_vert), (np.arange(n_vert), inv)), shape=(n_vert, len(unique))).tocsr()
+        votes = (adj @ one_hot).toarray()
+        
+        zero_idx = np.where(unique == 0)[0][0]
+        votes[:, zero_idx] = 0 
+        
+        winner = np.argmax(votes, axis=1)
+        fill_vals = unique[winner]
+        data[holes] = fill_vals[holes]
+
+    # smooth final boundaries
+    print("smoothing boundaries...")
+    for _ in range(10): 
+        unique, inv = np.unique(data, return_inverse=True)
+        one_hot = sp.coo_matrix((np.ones(n_vert), (np.arange(n_vert), inv)), shape=(n_vert, len(unique))).tocsr()
+        winner = np.argmax((adj @ one_hot).toarray(), axis=1)
+        data = unique[winner]
+        data[~mask] = 0
+
+    # save the final vertex map
+    np.savetxt(out_csv, data, fmt='%i')
+    
+    # find out which regions actually survived the smoothing/masking
+    surviving_ids = np.unique(data)
+    
+    # filter the LUT lines to only include survivors
+    final_lines = []
+    dropped_count = 0
+    
+    for rid, line_str in lut_dict.items():
+        if rid in surviving_ids:
+            final_lines.append(line_str)
+        else:
+            region_name = line_str.split()[1]
+            print(f"[WARNING] {region_name} (id {rid}) lost during smoothing/masking. dropping from lut.")
+            dropped_count += 1
+            
+    # write the perfectly clean file
+    with open(out_lut, 'w') as f:
+        f.write("\n".join(final_lines))
+
+    print(f"final polished atlas saved to: {out_dir}")
+    print(f"saved {len(final_lines)} regions ({dropped_count} empty regions dropped).")
+    
+    # cleanup intermediate Workbench files to save space
+    for temp_file in [labeled_nii, lh_gii, rh_gii]:
+        if os.path.exists(temp_file):
+            os.remove(temp_file)
+
+def qc_custom_cortical_atlas(atlas_dir, atlasname='atlas'):
+    """
+    generates a quality control report for a custom cortical atlas.
+    
+    reads the generated vertex map and lookup table, counts the vertices for each region, 
+    saves a summary text file, and generates individual static plots for every region 
+    to help identify mapping dropouts or anatomical bleed.
+
+    parameters
+    ----------
+    atlas_dir : str
+        absolute path to the custom atlas directory containing the .csv and .txt files.
+    atlasname : str, optional
+        prefix name of the files to check. default is 'atlas'.
+    """
+    
+    csv_path = os.path.join(atlas_dir, f"{atlasname}.csv")
+    lut_path = os.path.join(atlas_dir, f"{atlasname}.txt")
+    qc_dir = os.path.join(atlas_dir, "qc_report")
+    
+    os.makedirs(qc_dir, exist_ok=True)
+    
+    # load the mapped data and the lookup table
+    labels = np.loadtxt(csv_path).astype(int)
+    
+    regions = {}
+    with open(lut_path, 'r') as f:
+        for line in f:
+            parts = line.strip().split()
+            if len(parts) >= 2:
+                regions[int(parts[0])] = parts[1]
+                
+    print(f"starting qc for {len(regions)} regions...\n")
+    
+    report_path = os.path.join(qc_dir, "_vertex_counts.txt")
+    
+    with open(report_path, 'w') as f_out:
+        f_out.write("region_name\tid\tvertex_count\n")
+        f_out.write("-" * 40 + "\n")
+        
+        for rid, name in regions.items():
+            count = np.sum(labels == rid)
+            f_out.write(f"{name}\t{rid}\t{count}\n")
+            
+            print(f"[{name}] id: {rid} | vertices: {count}")
+            
+            if count == 0:
+                print(f"[WARNING] {name} is empty! skipping plot.")
+                continue
+            
+            plot_file = os.path.join(qc_dir, f"{rid:03d}_{name}.png")
+            
+            try:
+                plot_cortical(
+                    data={name: 1},
+                    custom_atlas_path=atlas_dir,
+                    cmap='binary',vminmax=[0, 1],
+                    export_path=plot_file
+                )
+            except Exception as e:
+                print(f"  -> failed to plot {name}: {e}")
+                
+    print(f"\nqc complete! check the '{qc_dir}' folder for the report and images.")
+
+
+### SUBCORTICAL
+
+def build_subcortical_atlas(nii_path, labels_dict, out_dir, include_list=None, exclude_list=None,
+                            smooth_i=15, smooth_f=0.6):
+    """
+    extracts 3D subcortical meshes from a volumetric nifti atlas.
+
+    uses the marching cubes algorithm to generate 3D surface meshes for specific 
+    regions, applies laplacian smoothing to remove voxel artifacts, and saves them as .vtk files.
+
+    parameters
+    ----------
+    nii_path : str
+        absolute path to the 3D nifti volume.
+    labels_dict : dict
+        dictionary mapping integer region IDs to string names (e.g., {1: 'thalamus_l'}).
+    out_dir : str
+        directory where the .vtk mesh files will be saved.
+    include_list : list of str, optional
+        keywords of regions to strictly include. all other regions are ignored.
+    exclude_list : list of str, optional
+        keywords of regions to strictly exclude. all other regions are kept.
+    smooth_i : int, optional
+        number of iterations for laplacian mesh smoothing. default is 15.
+    smooth_f : float, optional
+        relaxation factor for laplacian mesh smoothing (0.0 to 1.0). default is 0.6.
+
+    raises
+    ------
+    ValueError
+        if both include_list and exclude_list are provided.
+    """
+    if include_list and exclude_list:
+        raise ValueError("please provide either 'include_list' or 'exclude_list', not both.")
+        
+    os.makedirs(out_dir, exist_ok=True)
+    
+    # apply the include/exclude filters to the provided dictionary
+    targets = {}
+    for rid, name in labels_dict.items():
+        if include_list:
+            if not any(inc in name for inc in include_list):
+                continue
+        elif exclude_list:
+            if any(exc in name for exc in exclude_list):
+                continue
+                
+        targets[rid] = name
+                    
+    print(f"filtered down to {len(targets)} subcortical regions to extract.")
+
+    # load the nifti volume and its affine matrix
+    img = nib.load(nii_path)
+    data = img.get_fdata()
+    affine = img.affine
+
+    # loop through targets, extract meshes, and save
+    for rid, name in targets.items():
+        # create a binary mask for just this region
+        mask = (data == rid).astype(np.uint8)
+        
+        # skip if empty
+        if np.sum(mask) == 0:
+            print(f"[WARNING] {name} is empty in the volume!")
+            continue
+
+        print(f"extracting: {name} (id {rid})...")
+        
+        # run marching cubes to get raw vertices and faces
+        verts, faces, normals, values = measure.marching_cubes(mask, level=0.5)
+
+        # apply the nifti affine matrix cleanly using nibabel
+        verts_mni = nib.affines.apply_affine(affine, verts)
+
+        # format faces for pyvista: [n_points, p1, p2, p3, n_points, p1, p2, p3...]
+        faces_pv = np.column_stack((np.full(len(faces), 3), faces)).flatten()
+        
+        # create the 3d pyvista mesh
+        mesh = pv.PolyData(verts_mni, faces_pv)
+        
+        # apply laplacian smoothing to melt away the blocky voxel edges
+        mesh = mesh.smooth(n_iter=smooth_i, relaxation_factor=smooth_f)
+        mesh.compute_normals(inplace=True)
+
+        # we remove super small structures which would not be visible
+        if mesh.n_points < 4 or abs(mesh.volume) < 0.01:
+            print(f"[WARNING] {name} is too small to form a 3D mesh (volume: {abs(mesh.volume):.4f} mm³). dropping from atlas.")
+            continue
+        
+        # save as a vtk file
+        out_file = os.path.join(out_dir, f"{name}.vtk")
+        mesh.save(out_file)
+
+    print(f"\nsubcortical atlas successfully saved to: {out_dir}")
+
+def qc_custom_subcortical_atlas(atlas_dir):
+    """
+    generates a quality control report for a custom subcortical atlas.
+    
+    reads the generated .vtk meshes, calculates their geometric properties 
+    (vertices, faces, volume), saves a summary text file, and generates 
+    individual static plots for every region to help identify corrupt meshes 
+    or anatomical artifacts.
+
+    parameters
+    ----------
+    atlas_dir : str
+        absolute path to the custom atlas directory containing the .vtk files.
+    """
+    
+    qc_dir = os.path.join(atlas_dir, "qc_report")
+    os.makedirs(qc_dir, exist_ok=True)
+    
+    # find all vtk files in the atlas directory
+    vtk_files = glob.glob(os.path.join(atlas_dir, "*.vtk"))
+    
+    if not vtk_files:
+        print(f"no .vtk files found in {atlas_dir}. cannot run qc.")
+        return
+        
+    print(f"starting qc for {len(vtk_files)} subcortical meshes...\n")
+    
+    report_path = os.path.join(qc_dir, "_mesh_properties.txt")
+    
+    with open(report_path, 'w') as f_out:
+        # header for our text report
+        f_out.write("region_name\tvertices\tfaces\tvolume_mm3\n")
+        f_out.write("-" * 55 + "\n")
+        
+        for vtk_path in sorted(vtk_files):
+            filename = os.path.basename(vtk_path)
+            region_name = os.path.splitext(filename)[0]
+            
+            # read mesh to extract physical properties
+            try:
+                mesh = pv.read(vtk_path)
+                n_verts = mesh.n_points
+                n_faces = mesh.n_cells
+                volume = mesh.volume
+            except Exception as e:
+                print(f"  -> error reading {filename}: {e}")
+                f_out.write(f"{region_name}\tERROR\tERROR\tERROR\n")
+                continue
+                
+            f_out.write(f"{region_name}\t{n_verts}\t{n_faces}\t{volume:.2f}\n")
+            print(f"[{region_name}] vertices: {n_verts} | volume: {volume:.1f} mm³")
+            
+            # check for empty or severely corrupted meshes
+            if n_verts == 0:
+                print(f"[WARNING] {region_name} mesh is empty! skipping plot.")
+                continue
+            
+            plot_file = os.path.join(qc_dir, f"{region_name}.png")
+            
+            try:
+                plot_subcortical(
+                    data={region_name: 1},
+                    custom_atlas_path=atlas_dir,
+                    cmap='binary', vminmax=[0, 1],
+                    nan_alpha=0.2,
+                    export_path=plot_file
+                )
+            except Exception as e:
+                print(f"  -> failed to plot {region_name}: {e}")
+                
+    print(f"\nqc complete! check the '{qc_dir}' folder for the report and images.")

{yabplot-0.1.5 → yabplot-0.2.2}/yabplot/data/__init__.py

@@ -70,6 +70,52 @@ def get_available_resources(category=None):
         
     return all_resources
 
+def get_surface_paths(name, category):
+    """
+    Fetches and returns the paths to the Left and Right hemisphere files 
+    for a given surface resource (meshes or labels).
+    
+    Parameters
+    ----------
+    name : str
+        Name of the resource (e.g., 'midthickness', 'nomedialwall').
+    category : str
+        Must be 'bmesh' or 'label'.
+        
+    Returns
+    -------
+    tuple
+        (lh_path, rh_path) containing absolute paths to the files.
+    """
+    if category not in ['bmesh', 'label']:
+        raise ValueError("Category must be 'bmesh' or 'label' to fetch surface paths.")
+        
+    # Download/unpack the zip and get the folder path
+    directory = _resolve_resource_path(name, category)
+    
+    lh_path = None
+    rh_path = None
+    
+    # Traverse the unzipped directory to find L and R files
+    for root, dirs, files in os.walk(directory):
+        # Ignore hidden folders like .git or __MACOSX
+        dirs[:] = [d for d in dirs if not d.startswith(('.', '__'))]
+        for file in files:
+            # Ignore hidden files
+            if file.startswith('.'): 
+                continue
+            
+            # Robust checking for Left and Right hemisphere indicators
+            if '.L.' in file or '_L_' in file or 'hemi-L' in file:
+                lh_path = os.path.join(root, file)
+            elif '.R.' in file or '_R_' in file or 'hemi-R' in file:
+                rh_path = os.path.join(root, file)
+                
+    if not lh_path or not rh_path:
+        raise FileNotFoundError(f"Could not locate both Left and Right hemisphere files for '{name}' in {directory}")
+        
+    return lh_path, rh_path
+
 def get_atlas_regions(atlas, category, custom_atlas_path=None):
     """
     Returns the list of region names for a given atlas in the specific order 
@@ -191,7 +237,8 @@ def _resolve_resource_path(name, category, custom_path=None):
             'cortical': 'Cortical parcellations (vertices)',
             'subcortical': 'Subcortical segmentations (volumes)', 
             'tracts': 'White matter bundles (tracts)',
-            'bmesh': 'Brain meshes'
+            'bmesh': 'Brain meshes',
+            'label': 'Surface labels'
         }.get(category, category)
         
         raise ValueError(

{yabplot-0.1.5 → yabplot-0.2.2}/yabplot/data/registry.txt

@@ -1,15 +1,18 @@
 cortical-aparc.zip sha256:9e3e4853c580b6ed7c70a2b398b8ddacfc30e05600f04f722d3b5e8ee28ba119 https://osf.io/5btcf/download
-cortical-brainnetome.zip sha256:ecace554a79118534ae95bbaef517a6140e282374a95a5ee1f112794c00bd9e4 https://osf.io/xspn5/download
+cortical-brainnetome.zip sha256:fc4bb0043f2efa133771240f9e7178521be4011e76e5cad8102c9c099fce5ef0 https://osf.io/xspn5/download
 cortical-schaefer_100.zip sha256:041c229b900c86f6b80cc44a05dca74bcfccde9aad5d10878da04a184d0f26ba https://osf.io/yxt5p/download
 cortical-schaefer_200.zip sha256:065ee05afa1881a8884bdecee25a062ddd5fd6283bfeaabb59e6eb696f39563f https://osf.io/v45gq/download
 cortical-schaefer_300.zip sha256:5430c66eaef58f008b9e20dd5c59c670c7f7154b02f4b310dda97250331b6eed https://osf.io/9djtr/download
 cortical-schaefer_400.zip sha256:ae2b7011919d49e9930ee5aed1b19731180427f07f0d1c4497130dd9cd5e878d https://osf.io/pzmc5/download
 cortical-schaefer_1000.zip sha256:a10448f101a874499d41bc62508c3af29120634955f48beb282ece9a4cc2bb0e https://osf.io/j9ygz/download
+cortical-aal3.zip sha256:925e475e099b127925e20e6ec4d179b1a58971f2bc32b2a61f56a479f3e8d4fb https://osf.io/z9jxh/download
 subcortical-aseg.zip sha256:a901a7fc6a39f9bdaf2ef2bafbcde1fbc085b225d99e6730c727650d9be047d5 https://osf.io/5cs7y/download
 subcortical-brainnetome_sc.zip sha256:8301fdf6af109af52a2cf9b06d15486345d457b69cb86169ed38332a34a681c0 https://osf.io/2fsg5/download
 subcortical-jhu.zip sha256:b0ca292589a9f041851dba8159bb605a4657323e4305ba1570a304944b28d0de https://osf.io/x5fhg/download
 subcortical-musus100_dbn.zip sha256:1d865832a35570a8c67f79d5049b58c548d25cf4fe1853164c384193b6712e40 https://osf.io/eutmb/download
 subcortical-tian2020_sc.zip sha256:8b5caf8bf0cdcf8e259a3532fbcb232f8746d68fc734ca9806d10e70cf8707a3 https://osf.io/jrvgp/download
+subcortical-aal3.zip sha256:48abe400656d913cc459ee8766e373cc5eabbeb9e4f770aa7396da3d4a0ab3ca https://osf.io/39ebh/download
+subcortical-aal3_nocer.zip sha256:b87de55861cdd18ddb78934964b0e0855f770560bdc878570fcbb8f27fefb674 https://osf.io/7jdxz/download
 tracts-hcp1065_medium.zip sha256:366bb100074cf7b1e55586e5468653f0c342e42cfdd91dca6d99b6fde82f06ff https://osf.io/kjf8e/download
 tracts-hcp1065_small.zip sha256:020f23059c3a20ee0dda8ad12cd3df99b9fe5d3b37e7a6b9ae34b8a52b4b4346 https://osf.io/ynpa5/download
 tracts-hcp1065_tiny.zip sha256:54380d82f5cd234029c6fc011910e00f0ad859fdb6c22c6aaa6452d055449ae9 https://osf.io/jzk7p/download
@@ -22,4 +25,5 @@ bmesh-midthickness.zip sha256:ef8209853e1dac8804a60b5cde0b653ef2f6c77b6c7536f7ac
 bmesh-pial.zip sha256:5e36ba7883dd2a88485fc45c9166ed48e22db607d45655242961242b51f9f126 https://osf.io/knpg8/download
 bmesh-swm.zip sha256:1a516c070cb63557751d841d5cf75772660872b89ec749ee19c23298d77fa807 https://osf.io/hpbc9/download
 bmesh-very_inflated.zip sha256:8c33a00c718a47f0af118ce2c5804a2adf13d79be05c4665ca26582e3e8dd977 https://osf.io/xp9jr/download
-bmesh-white.zip sha256:b885ac1a4dcdf9e241a97e8d3ca59d7b1c86d8a3ebe17df512993bc5c1c0354a https://osf.io/wfc5t/download
+bmesh-white.zip sha256:b885ac1a4dcdf9e241a97e8d3ca59d7b1c86d8a3ebe17df512993bc5c1c0354a https://osf.io/wfc5t/download
+label-nomedialwall.zip sha256:03bd589b151814a1fc5e48236a78decf1a51791f04c3f4a521d2ed4fb214317b https://osf.io/2rgmc/download

yabplot-0.2.2/yabplot/wrappers.py

@@ -0,0 +1,36 @@
+import subprocess
+import shutil
+import os
+
+def check_workbench():
+    """
+    Checks if Connectome Workbench (wb_command) is installed and available in PATH.
+    
+    Raises
+    ------
+    EnvironmentError
+        If wb_command is not found, providing instructions for installation.
+    """
+    if shutil.which('wb_command') is None:
+        raise EnvironmentError(
+            "Connectome Workbench ('wb_command') was not found in your system PATH.\n"
+            "This is required for volume-to-surface projection (necessary for creating a custom cortical atlas).\n"
+            "Please download it from: https://humanconnectome.org/software/get-connectome-workbench\n"
+            "After installing, ensure the 'bin' folder is added to your PATH environment variable."
+        )
+
+def run_wb_import(input_nii, label_list, output_nii):
+    """Wrapper for wb_command -volume-label-import"""
+    check_workbench()
+    cmd = ["wb_command", "-volume-label-import", input_nii, label_list, output_nii]
+    subprocess.run(cmd, check=True)
+
+def run_wb_projection(input_nii, midthickness, output_gii, white, pial):
+    """Wrapper for wb_command -volume-label-to-surface-mapping (ribbon-constrained)"""
+    check_workbench()
+    cmd = [
+        "wb_command", "-volume-label-to-surface-mapping",
+        input_nii, midthickness, output_gii,
+        "-ribbon-constrained", white, pial
+    ]
+    subprocess.run(cmd, check=True)

{yabplot-0.1.5 → yabplot-0.2.2/yabplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yabplot
-Version: 0.1.5
+Version: 0.2.2
 Summary: yet another brain plot
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -55,6 +55,9 @@ pip install yabplot --upgrade # to update
 
 dependencies: python 3.11 with ipywidgets, nibabel, pandas, pooch, pyvista, scikit-image, trame, trame-vtk, trame-vuetify
 
+(Connectome Workbench (`wb_command`) is a requirement to create custom cortical atlases unless you plan to only use pre-loaded atlases; see more in docs)
+
+
 ## quick start
 
 please refer to the [documentation](https://teanijarv.github.io/yabplot/) for more comprehensive guides.

{yabplot-0.1.5 → yabplot-0.2.2}/yabplot.egg-info/SOURCES.txt

@@ -4,9 +4,11 @@ README.md
 pyproject.toml
 tests/test_smoke.py
 yabplot/__init__.py
+yabplot/atlas_builder.py
 yabplot/plotting.py
 yabplot/scene.py
 yabplot/utils.py
+yabplot/wrappers.py
 yabplot.egg-info/PKG-INFO
 yabplot.egg-info/SOURCES.txt
 yabplot.egg-info/dependency_links.txt