pyNIBS 0.2024.8__py3-none-any.whl → 0.2026.1__py3-none-any.whl

pynibs/mesh/transformations.py

@@ -2,9 +2,11 @@ import os
 import meshio
 import trimesh
 import warnings
-import nibabel
+import itertools
 import numpy as np
+from nibabel.affines import apply_affine
 from tqdm import tqdm
+import nibabel as nib
 from scipy.interpolate import griddata
 from vtkmodules.util import numpy_support  # don't import vtk due to opengl issues when running headless
 from vtkmodules.util.vtkConstants import VTK_TRIANGLE
@@ -102,7 +104,7 @@ def data_elements2nodes(data, con, precise=False):
             for i in range(n_elements):
                 c[i, (con[i])] = 1.0 / con.shape[1]
 
-            # filter out NaN from dataset
+            # filter out nan from dataset
             for i in range(len(data)):
                 data[i][np.isnan(data[i])] = 0
 
@@ -159,7 +161,7 @@ def project_on_scalp_hdf5(coords, mesh, scalp_tag=1005):
     """
     # read head mesh and extract skin surface
     if isinstance(mesh, str):
-        mesh = pynibs.load_mesh_hdf5(mesh)
+        mesh = pynibs.hdf5_io.load_mesh_hdf5(mesh)
 
     if coords.ndim == 1:
         coords = coords[np.newaxis,]
@@ -179,26 +181,26 @@ def project_on_scalp_hdf5(coords, mesh, scalp_tag=1005):
 
 def project_on_scalp(coords, mesh, scalp_tag=1005):
     """
-    Find the node in the scalp closest to each coordinate
+    Find the node in the scalp closest to each coordinate.
 
     Parameters
     ----------
     coords: nx3 np.ndarray
-        Vectors to be transformed
+        Vectors to be transformed.
     mesh: pynibs.TetrahedraLinear or simnibs.msh.mesh_io.Msh
-        Mesh structure in simnibs or pynibs format
+        Mesh structure in simnibs or pynibs format.
     scalp_tag: int, default: 1005
         Tag in the mesh where the scalp is to be set.
 
     Returns
     -------
     points_closest: np.ndarry
-        (n, 3) coordinates projected scalp (closest skin points)
+        (n, 3) coordinates projected scalp (closest skin points).
     """
     from simnibs.msh.transformations import project_on_scalp as project_on_scalp_msh
     from simnibs.msh.mesh_io import Msh
 
-    if isinstance(mesh, pynibs.TetrahedraLinear):
+    if isinstance(mesh, pynibs.mesh.TetrahedraLinear):
         points_closest = project_on_scalp_hdf5(coords=coords, mesh=mesh, scalp_tag=scalp_tag)
     elif isinstance(mesh, Msh):
         points_closest = project_on_scalp_msh(coords=coords, mesh=mesh, scalp_tag=scalp_tag, distance=0.)
@@ -453,12 +455,12 @@ def map_data_to_surface(datasets, points_datasets, con_datasets, fname_fsl_gm, f
     Parameters
     ----------
     datasets : np.ndarray of float [N_points x N_data] or list of np.ndarray
-        Data in nodes or center of triangles in ROI (specify this in "data_in_center")
+        Data in nodes or center of triangles in ROI (specify this in "data_in_center").
     points_datasets : np.ndarray of float [N_points x 3] or list of np.ndarray
         Point coordinates (x,y,z) of ROI where data in datasets list is given, the points have to be a subset of the
-        GM/WM surface (has to be provided for each dataset)
+        GM/WM surface (has to be provided for each dataset).
     con_datasets : np.ndarray of int [N_tri x 3] or list of np.ndarray
-        Connectivity matrix of dataset points (has to be provided for each dataset)
+        Connectivity matrix of dataset points (has to be provided for each dataset).
     fname_fsl_gm : str or list of str or list of None
         Filename of pial surface fsl file(s) (one or two hemispheres)
         e.g. in mri2msh: .../fs_ID/surf/lh.pial
@@ -473,18 +475,18 @@ def map_data_to_surface(datasets, points_datasets, con_datasets, fname_fsl_gm, f
         0 -> WM surface
         1 -> GM surface
     input_data_in_center : bool
-        Flag if data in datasets in given in triangle centers or in points (Default: True)
+        Flag if data in datasets in given in triangle centers or in points (Default: True).
     return_data_in_center : bool
-        Flag if data should be returned in nodes or in elements (Default: True)
+        Flag if data should be returned in nodes or in elements (Default: True).
     data_substitute : float
-        Data substitute with this number for all points in the inflated brain, which do not belong to the given data set
+        Data substitute with this number for all points in the inflated brain,
+        which do not belong to the given data set.
 
     Returns
     -------
     data_mapped : np.ndarray of float [N_points_inf x N_data]
-        Mapped data to target brain surface. In points or elements
+        Mapped data to target brain surface. In points or elements.
     """
-
     if type(fname_fsl_gm) is not list:
         fname_fsl_gm = [fname_fsl_gm]
 
@@ -502,8 +504,8 @@ def map_data_to_surface(datasets, points_datasets, con_datasets, fname_fsl_gm, f
         con_idx = 0
 
         for f_gm, f_wm in zip(fname_fsl_gm, fname_fsl_wm):
-            p_gm, c_tar = nibabel.freesurfer.read_geometry(f_gm)
-            p_wm, _ = nibabel.freesurfer.read_geometry(f_wm)
+            p_gm, c_tar = nib.freesurfer.read_geometry(f_gm)
+            p_wm, _ = nib.freesurfer.read_geometry(f_wm)
 
             points_gm.append(p_gm)
             points_wm.append(p_wm)
@@ -528,11 +530,11 @@ def map_data_to_surface(datasets, points_datasets, con_datasets, fname_fsl_gm, f
 
         for f_mid in fname_midlayer:
             if f_mid.endswith('.gii'):
-                img = nibabel.gifti.giftiio.read(f_mid)
+                img = nib.load(f_mid)
                 p_mid = img.agg_data('pointset')
                 c_tar = img.agg_data('triangle')
             else:
-                p_mid, c_tar = nibabel.freesurfer.read_geometry(f_mid)
+                p_mid, c_tar = nib.freesurfer.read_geometry(f_mid)
 
             points.append(p_mid)
             con_target.append(c_tar + con_idx)
@@ -679,7 +681,7 @@ def midlayer_2_surf(midlayer_data, coords_target, coords_midlayer, midlayer_con=
     """
     if not midlayer_data_in_nodes:
         assert midlayer_con is not None
-        midlayer_data = np.squeeze(pynibs.data_elements2nodes(midlayer_data, midlayer_con, precise=precise_map))
+        midlayer_data = np.squeeze(pynibs.mesh.data_elements2nodes(midlayer_data, midlayer_con, precise=precise_map))
 
     data_target = np.zeros((coords_target.shape[0]))
     for i in tqdm(range(data_target.shape[0]), desc='Mapping midlayer2surface'):
@@ -864,3 +866,101 @@ def write_vtu(fn, vtk_grid):
     writer.SetFileName(fn)
     writer.SetInputData(vtk_grid)
     writer.Write()
+
+
+def map_nii2surf(tri_node_coords, nii, datatype=float, nonzeroneighbors=False):
+    """
+    Map nifti data to mesh surface.
+
+    For each surface triangle,
+
+        - the center coordinate is determined
+        - and the corresponding voxel value from the nifti file is extracted.
+
+    Raw, unsmoothed data is returned. Nifti file and mesh needs to be in the same space.
+
+    .. figure:: ../../doc/images/nii_on_surf.png
+       :scale: 60 %
+       :alt: Nifti volume on mesh surface
+
+       Volume data from nifti file is mapped to mesh surface.
+
+    .. code-block:: python
+
+        fn_roi = "geo.hdf5"
+        fn_nii = "some_T_map.nii"
+
+        nii = nib.load(fn_nii)
+
+        with h5py.File(fn_roi, 'r') as f:
+            triangle_number_list = f['/mesh/elm/triangle_number_list'][:]
+            node_coord = f['/mesh/nodes/node_coord'][:]
+
+        nii_data_on_surf = pynibs.map_nii2surf(node_coord[triangle_number_list], nii)
+        output_fn = "some_T_map_on_surf.vtk"
+        point_data = {"T": [nii_data_on_surf]}
+        meshio.Mesh(np.squeeze(node_coord), [('triangle', triangle_number_list)], cell_data=point_data).write(output_fn)
+
+    Parameters
+    ----------
+    tri_node_coords: np.ndarray of int
+        (n,3,3) list of node coordinates for n trianlges (mesh surface).
+    nii: nibabel.Nifti1Image or str
+        Nifti image or filename of nifti.
+    datatype: type, default: float
+        Data type of the output array. For masks, use int.
+    nonzeroneighbors : boolean, default=False
+        If True, zero datapoints are replaced by largest absolute neihbors voxel data.
+        This is useful for masked niftis, where data outside of the mask is zero and you want to pull data
+        only from inside the mask.
+
+    Returns
+    -------
+    np.ndarray of float
+        (n,) array with voxel values from nifti file for each triangle center.
+    """
+    coords_center = np.average(tri_node_coords, axis=1)
+
+    if isinstance(nii, str):
+        nii = nib.load(nii)
+
+    # load nifti data
+    nii_data = nii.get_fdata().copy()
+    affine = nii.affine
+    affine_inv = np.linalg.inv(affine)
+
+    # create empty results arrays
+    fmri_surf = np.zeros_like(coords_center)
+
+    # pull voxel data for each triangle
+    t = tqdm(coords_center)
+    t.set_description("Mapping .nii to mesh")
+    for i, coord in enumerate(t):
+        # we need to apply an array2voxel coordinates transformations
+        fmri_surf[i, :] = apply_affine(affine_inv, coord)
+
+    fmri_stats = np.round(fmri_surf).astype(int)
+    for dim in range(3):
+        fmri_stats[:, dim] = np.clip(fmri_stats[:, dim], 0, nii_data.shape[dim] - 1)
+    # print(np.min(fmri_stats[:,0]), np.max(fmri_stats[:,0]))
+    # print(np.min(fmri_stats[:, 1]), np.max(fmri_stats[:, 1]))
+    # print(np.min(fmri_stats[:,2]), np.max(fmri_stats[:,2]))
+    # a = nii_data[fmri_stats[:, 0], fmri_stats[:, 1], fmri_stats[:, 2]].astype(datatype)
+    # b = nii_data[fmri_stats[:, 0], fmri_stats[:, 1], fmri_stats[:, 2]].astype(datatype)
+    # grab the data
+
+    plusminus = list(itertools.product(*[[1, -1]] * 3))
+
+    mapped_data = nii_data[fmri_stats[:, 0], fmri_stats[:, 1], fmri_stats[:, 2]]
+    for zero_idx in np.where(mapped_data == 0)[0]:
+        offset_data = []
+        zero_arr_coords = fmri_stats[zero_idx]
+        # mapped_data_zero = nii_data[zero_arr_coords[0], zero_arr_coords[1], zero_arr_coords[2]][0]
+        for x,y,z in plusminus:
+            offset_data.append(nii_data[zero_arr_coords[0]+y,
+                               zero_arr_coords[1]+y,
+                               zero_arr_coords[2]+z][0])
+        best_offset = np.argmax(np.abs(offset_data))
+        fmri_stats[zero_idx] += plusminus[best_offset]
+
+    return nii_data[fmri_stats[:, 0], fmri_stats[:, 1], fmri_stats[:, 2]].astype(datatype)