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

pynibs/expio/signal_ced.py

@@ -1,7 +1,13 @@
-""" """
+"""Import functions for CED Signal data."""
+import re
 import os
+import json
 import h5py
+import datetime
+import warnings
 import numpy as np
+import pandas as pd
+from scipy import io as spio
 import pynibs
 
 
@@ -41,7 +47,7 @@ def cfs2hdf5(fn_cfs, fn_hdf5=None):
     sweeps = int(cfs_header[sweep_index + 18:comma_index])
     records = emg.shape[0]
     samples = int(records / sweeps)
-    sampling_rate = pynibs.get_mep_sampling_rate(fn_cfs)
+    sampling_rate = pynibs.expio.get_mep_sampling_rate(fn_cfs)
     emg = np.reshape(emg, (sweeps, samples))
     time = np.linspace(0, samples, samples) / sampling_rate
 
@@ -49,3 +55,340 @@ def cfs2hdf5(fn_cfs, fn_hdf5=None):
         f.create_dataset("emg", data=emg)
         f.create_dataset("time", data=time)
         f.create_dataset("sampling_rate", data=np.array([sampling_rate]))
+
+
+def read_biosig_emg_data(fn_data, include_first_trigger=False, filetype="cfs"):
+    """
+    Reads EMG data from a biosig file.
+
+    Parameters
+    ----------
+    fn_data : str
+        Path to the biosig file.
+    include_first_trigger : bool, default: False
+        Whether to include the first trigger event in the data (default: False).
+    filetype : str, default: 'cfs'
+        Type of the biosig file.
+
+    Returns
+    -------
+    emg_data : np.ndarray
+        (num_sweeps, num_channels, samples_per_sweep) EMG data with shape.
+    time_diff_list : list
+        Time differences between trigger events in seconds.
+    num_sweeps : int
+        Number of sweeps in the EMG data.
+    num_channels : int
+        Number of channels in the EMG data.
+    samples_per_sweep : int
+        Number of samples per sweep in the EMG data.
+    sampling_rate : int
+        Sampling rate of the EMG data.
+    """
+    try:
+        import biosig
+    except ImportError:
+        ImportError("Please install biosig from pynibs/pkg/biosig folder!")
+        return
+
+    if type == "cfs":  # TODO: also move the TXT reader here?
+        cfs_fn = fn_data
+        cfs_header = json.loads(biosig.header(cfs_fn))
+        cfs_emg = biosig.data(cfs_fn)
+
+        num_sweeps = cfs_header["NumberOfSweeps"]
+        num_channels = cfs_emg.shape[1]
+
+        total_num_samples = cfs_header["NumberOfSamples"]
+        samples_per_sweep = int(total_num_samples / num_sweeps)
+        sampling_rate = int(cfs_header["Samplingrate"])
+
+        # get timestamps
+        tms_pulse_timedelta = datetime.timedelta()
+        # get hour, minute and second
+        time_mep_list = []
+        time_diff_list = []
+        trigger_event_idcs = []
+        if include_first_trigger:
+            trigger_event_idcs.append(0)
+            time_diff_list.append(0)
+            time_mep_list.append(
+                datetime.datetime.strptime(
+                    cfs_header["EVENT"][0]["TimeStamp"], '%Y-%b-%d %H:%M:%S'
+                )
+                -
+                datetime.timedelta(
+                    seconds=float(cfs_header["EVENT"][0]["POS"])
+                )
+            )
+
+        # convert time string into integer
+        for event in cfs_header["EVENT"]:
+            date = datetime.datetime.strptime(event["TimeStamp"], '%Y-%b-%d %H:%M:%S')
+
+            # we are interested in the tms pulse time, so add it to ts
+            date += tms_pulse_timedelta
+            time_mep_list.append(date)
+            time_diff_list.append((date - time_mep_list[0]).total_seconds())
+
+            # compute indices in data block corresponding to the events
+            if event["TYP"] == "0x7ffe":
+                trigger_event_idcs.append(
+                    round(event["POS"] * cfs_header["Samplingrate"])
+                )
+
+        num_sweeps = min(num_sweeps, len(trigger_event_idcs))
+
+        emg_data = np.zeros((num_sweeps, num_channels, samples_per_sweep), dtype=np.float32)
+
+        for c_idx in range(num_channels):
+            # Use emg data starting from the index of the first trigger event
+            # assumptions:
+            # - after an initial offset all emg data were captured consecutively
+            # - the first emg data frame may be captured without an explicit TMS
+            #   tigger (e.g. by checking the "write to disk" option)
+            # - if we had dropouts in between the emg data block (not just at the
+            #   beginning) we would need to adhere to the entire trigger_event_indices
+            #   list.
+            emg_data[:, c_idx, :] = np.reshape(
+                cfs_emg[trigger_event_idcs[0]:, c_idx],
+                (num_sweeps, samples_per_sweep)
+            )
+
+        return emg_data, time_diff_list, num_sweeps, num_channels, samples_per_sweep, sampling_rate
+
+
+def get_mep_elements(mep_fn, tms_pulse_time, drop_mep_idx=None, cfs_data_column=0, channels=None, time_format="delta",
+                     plot=False, start_mep=18, end_mep=35):
+    """
+    Read EMG data from CED .cfs or .txt file and returns MEP amplitudes.
+
+    Parameters
+    ----------
+    mep_fn : string
+        path to .cfs-file or .txt file (Signal export).
+    tms_pulse_time : float
+        Time in [s] of TMS pulse as specified in signal.
+    drop_mep_idx : List of int or None, optional
+        Which MEPs to remove before matching.
+    cfs_data_column : int or list of int, default: 0
+        Column(s) of dataset in cfs file. +1 for .txt.
+    channels : list of str, optional
+        Channel names.
+    time_format : str, default: "delta"
+        Format of mep time stamps in time_mep_lst to return.
+
+        * ``"delta"`` returns list of datetime.timedelta in seconds.
+        * ``"hms"`` returns datetime.datetime(year, month, day, hour, minute, second, microsecond).
+
+    plot : bool, default: False
+        Plot MEPs.
+    start_mep : float, default: 18
+        Start of time frame after TMS pulse where p2p value is evaluated (in ms).
+    end_mep : float, default: 35
+        End of time frame after TMS pulse where p2p value is evaluated (in ms).
+
+    Returns
+    -------
+    p2p_arr : np.ndarray of float
+        (N_channel, N_stim) Peak to peak values of N sweeps.
+    time_pulse_lst : list of datetime.timedelta
+        TMS pulse timestamps
+    mep_raw_data : np.ndarray of float
+        (N_channel, N_stim, N_samples) Raw (unfiltered) MEP data.
+    mep_filt_data : np.ndarray of float
+        (N_channel, N_stim, N_samples) Filtered MEP data (Butterworth lowpass filter).
+    emg_time_axes : np.ndarray of float
+        (N_samples) Time axis corresponding to EMG data.
+    mep_onset_arr : np.ndarray of float
+        (S_samples) MEP onset after TMS pulse.
+    """
+    # convert pulse time to datetime object in case of "delta"
+    if time_format == "delta":
+        tms_pulse_timedelta = datetime.timedelta(milliseconds=tms_pulse_time * 1000)
+    elif time_format == "hms":
+        tms_pulse_timedelta = datetime.timedelta()
+    else:
+        raise NotImplementedError("Specified time_format not implemented yet...")
+
+    if mep_fn.endswith('.cfs'):
+        # get data from cfs file
+        import biosig
+        mep_raw_data_tmp = biosig.data(mep_fn)
+        mep_raw_data_tmp = mep_raw_data_tmp[:, cfs_data_column]  # get first channel
+
+        # get header from cfs file
+        cfs_header = biosig.header(mep_fn)
+
+        # get timestamps
+        # get all indices of timestamps from cfs header
+        ts_mep_lst = [timestamp.start() for timestamp in re.finditer('TimeStamp', cfs_header)]
+        # get hour, minute and second
+        time_pulse_lst = []
+        # convert time string into integer
+        for index in ts_mep_lst:
+            hour = int(cfs_header[index + 26:index + 28])
+            minute = int(cfs_header[index + 29:index + 31])
+            second = int(cfs_header[index + 32:index + 34])
+            # fix bug with second 60
+            if second == 60:
+                ts = datetime.datetime(1900, 1, 1, hour, minute, 59)
+                ts += datetime.timedelta(seconds=1)
+            else:
+                ts = datetime.datetime(1900, 1, 1, hour, minute, second)
+
+            # we are interested in the tms pulse time, so add it to ts
+            ts += tms_pulse_timedelta
+            time_pulse_lst.append(ts)
+
+        if time_format == "delta":
+            time_pulse_lst = [time_pulse_lst[i] - time_pulse_lst[0] for i in range(len(time_pulse_lst))]
+        if time_format == "hms":
+            pass
+
+        # add first timestamp (not saved by signal) and shift other by isi
+        time_pulse_lst = [datetime.timedelta(seconds=0)] + [
+            t + time_pulse_lst[1] - time_pulse_lst[0] for t in time_pulse_lst]
+
+        # get peak-to-peak values
+        # get the ratio of samples per sweep
+        sweep_index = cfs_header.find('NumberOfSweeps')
+        comma_index = cfs_header.find(',', sweep_index)
+        n_sweeps = int(cfs_header[sweep_index + 18:comma_index])
+        record_index = cfs_header.find('NumberOfRecords')
+        comma_index = cfs_header.find(',', record_index)
+        records = int(cfs_header[record_index + 19:comma_index])
+        n_samples = int(records / n_sweeps)
+        if not isinstance(n_samples, int):
+            print('Warning: Number of samples is not an integer.')
+            # TODO: Correct get_mep_elements() sample number check. This does not work as expected (from Ole)
+
+        # reshape numpy array
+        mep_raw_arr = np.zeros((len(cfs_data_column), n_sweeps, n_samples))
+
+        for i in cfs_data_column:
+            mep_raw_arr[i, :, :] = np.reshape(mep_raw_data_tmp[:, i], (n_sweeps, n_samples))
+
+        sampling_rate = pynibs.expio.get_mep_sampling_rate(mep_fn)
+
+    elif mep_fn.endswith('.mat'):
+        mep_data = spio.loadmat(mep_fn, struct_as_record=False, squeeze_me=True)
+
+        # find data
+        for k in mep_data.keys():
+            if isinstance(mep_data[k], spio.matlab.mio5_params.mat_struct):
+                mep_data = mep_data[k].__dict__
+                break
+
+        n_samples = mep_data['points']
+        mep_raw_arr = mep_data['values'].transpose(1, 2, 0)
+        time_pulse_lst = [datetime.timedelta(seconds=f.__dict__['start']) for f in mep_data['frameinfo']]
+        sampling_rate = pynibs.expio.get_mep_sampling_rate(mep_fn)
+
+    elif mep_fn.endswith('.txt'):
+        warnings.warn(".txt import is deprecated - use .mat or .cfs.", DeprecationWarning)
+        print("Reading MEP from .txt file")
+        # The Signal text export looks like this:
+        #
+        # "s"\t"ADC 0"\t"ADC 1"
+        # 0.00000000\t-0.066681\t-0.047607
+        # 0.00025000\t-0.066376\t-0.049286
+        # 0.00050000\t-0.066528\t-0.056610
+        #
+        # "s"\t"ADC 0"\t"ADC 1"
+        # 0.00000000\t-0.066681\t-0.047607
+        # 0.00025000\t-0.066376\t-0.049286
+        # 0.00050000\t-0.066528\t-0.056610
+        #
+        # With first column = time, second = 1st electrode, ...
+        # This is an example of 2 sweeps, 3 samples each, sampling rate = 4000
+
+        # Find number of samples per sweep
+        pattern = '"s"'
+        with open(mep_fn, 'r') as f:
+            for line_nr, line in enumerate(f):
+                print(f'{line_nr}: {line}')
+                if pattern in line and line_nr > 0:
+                    # find second occurance of "s" -> end of first sweep
+                    n_samples = line_nr
+                    print(f'{line_nr}: {line}')
+                if line != '\n':
+                    last_sample_time = line
+
+        # extract time (first column) of last samples
+        last_sample_time = float(last_sample_time[0:last_sample_time.find('\t')])
+
+        # subtract 2 because first row is header ("s"\t"ADC 0"\t"ADC 1") and last row is blank
+        n_samples = n_samples - 2
+
+        df_mep = pd.read_csv(mep_fn,
+                             delimiter="\t",
+                             skip_blank_lines=True,
+                             skiprows=lambda x: x % (n_samples + 2) == 0 and x > 0)
+
+        n_sweeps = int(df_mep.shape[0] / n_samples)
+        mep_raw_arr = np.zeros((len(cfs_data_column), n_sweeps, n_samples))
+
+        for i in range(n_sweeps):
+            mep_raw_arr[:, i, :] = df_mep.iloc[i * n_samples:(i + 1) * n_samples, 1:].transpose()
+
+        # get sampling rate by dividing number of sweeps by timing
+        sampling_rate = int(mep_raw_arr.shape[2] - 1) / last_sample_time
+
+        # build time_mep_list
+        # we only have information about the single mep timings, so let's assume signal sticks strictly to the protocol
+        sample_len = last_sample_time + 1 / sampling_rate
+
+        # TODO: The ISI is missing here, do we want to add it to the subject object?
+        time_pulse_lst = [datetime.timedelta(seconds=i * sample_len) +
+                          tms_pulse_timedelta for i in range(mep_raw_arr.shape[1])]
+
+    else:
+        raise ValueError("Unknown MEP file extension. Use .cfs or .txt.")
+
+    # get peak to peak value of every sweep and plot results in mep/plots/channels
+    if channels is None:
+        channels = [str(i) for i in cfs_data_column]
+
+    tmp = np.zeros((mep_raw_arr.shape[0], mep_raw_arr.shape[1], 3)).astype(object)
+    for i_channel in range(mep_raw_arr.shape[0]):
+        print(f"Calculating p2p values for channel: {channels[i_channel]}")
+
+        for i_zap in range(mep_raw_arr.shape[1]):
+            tmp[i_channel, i_zap, 0], \
+                tmp[i_channel, i_zap, 1], \
+                tmp[i_channel, i_zap, 2] = pynibs.expio.calc_p2p(sweep=mep_raw_arr[i_channel, i_zap, :],
+                                                                 tms_pulse_time=tms_pulse_time,
+                                                                 sampling_rate=sampling_rate,
+                                                                 fn_plot=None,
+                                                                 start_mep=start_mep,
+                                                                 end_mep=end_mep)
+
+    p2p_arr = np.zeros((tmp.shape[0], tmp.shape[1]))
+    mep_onset_arr = np.zeros((tmp.shape[0], tmp.shape[1]))
+    mep_filt_arr = np.zeros(mep_raw_arr.shape)
+
+    emg_time_axes = np.arange(mep_raw_arr.shape[2]) / sampling_rate
+
+    for idx_channel in cfs_data_column:
+        for i, t in enumerate(tmp[idx_channel, :, :]):
+            p2p_arr[idx_channel, i] = tmp[idx_channel, i, 0]
+            mep_onset_arr[idx_channel, i] = tmp[idx_channel, i, 2]
+            mep_filt_arr[idx_channel, i, :] = tmp[idx_channel, i, 1]
+
+    if time_format == "delta":
+        time_pulse_lst = [time_pulse_lst[i] - time_pulse_lst[0] for i in range(len(time_pulse_lst))]
+    elif time_format == "hms":
+        pass
+
+    # remove MEPs according to drop_mep_idx and reset time
+    if drop_mep_idx is not None:
+        p2p_arr = np.delete(p2p_arr, drop_mep_idx)
+        mep_onset_arr = np.delete(mep_onset_arr, drop_mep_idx)
+        time_pulse_lst = np.delete(time_pulse_lst, drop_mep_idx)
+
+    keep_mep_idx = [i for i in range(mep_raw_arr.shape[1]) if i not in np.array(drop_mep_idx)]
+    mep_raw_arr = mep_raw_arr[:, keep_mep_idx, :]
+    mep_filt_arr = mep_filt_arr[:, keep_mep_idx, :]
+
+    return p2p_arr, time_pulse_lst, mep_raw_arr, mep_filt_arr, emg_time_axes, mep_onset_arr

pynibs/expio/visor.py

@@ -17,12 +17,12 @@ except (ImportError, SyntaxError):
 
 def read_nlr(fname):
     """
-    Reads NLR coordinates from *_recording.mri file.
+    Reads NLR coordinates from _recording.mri file.
 
     Parameters
     ----------
     fname : str
-        FIle path of the NLR recording MRI file.
+        File path of the NLR recording MRI file.
 
     Returns
     -------
@@ -62,6 +62,7 @@ def get_instrument_marker(im_path, verbose=False):
     Return all instrument markers from visor .cnt file.
 
     Coordinate system in raw ANT space (NLR) is defined as:
+
     - origin: intersection between line of ear fiducials and nasion
     - x-axis: origin -> nasion
     - y-axis: origin -> left ear
@@ -83,6 +84,7 @@ def get_instrument_marker(im_path, verbose=False):
         * StimulusID: int
         * etc...
 
+
     Raises
     ------
     AssertionError
@@ -161,7 +163,6 @@ def get_cnt_data(fn, channels='all', trigger_val='1', max_duration=10,
     data_lst: list of np.ndarray, optional
         (samples,channels), List of EEG/EMG data. Only returned if "fn_hdf5" is not None.
     """
-
     f = libeep.read_cnt(fn)
     n_trig = f.get_trigger_count()
     n_samples = f.get_sample_count()
@@ -360,7 +361,6 @@ def filter_emg(emg, fs):
     emg_filt : list of np.ndarray
         (n_stimuli), Filtered EMG data.
     """
-
     # 5 Hz Butterworth high pass
     ############################
     b_butterhigh, a_butterhigh = signal.butter(N=5, Wn=5, btype='high', analog=False, fs=fs)
@@ -439,6 +439,7 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
         * "phys_data/raw/EEG": Raw EEG data
         * "phys_data/postproc/EMG": Post-processed EMG data (e.g. filtered, p2p, etc.)
         * "phys_data/postproc/EEG": Post-processed EEG data (e.g. filtered, p2p, etc.)
+
     """
     # mep_paths_lst = subject.exp[exp_id]['fn_data']
 
@@ -466,12 +467,12 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
 
         fn_fiducials = subject.exp[exp_id]['fn_fiducials'][0]
 
-        ims_list = pynibs.visor.get_instrument_marker(fn_visor_cnt)
-        ims_dict = pynibs.list2dict(ims_list)
+        ims_list = get_instrument_marker(fn_visor_cnt)
+        ims_dict = pynibs.util.utils.list2dict(ims_list)
         n_stim = len(ims_list)
 
         # read fiducials and transform to simnibs space
-        fiducials = pynibs.visor.read_nlr(fn_fiducials)
+        fiducials = read_nlr(fn_fiducials)
 
         # fiducial correction
         if 'fiducial_corr' in subject.exp[exp_id]:
@@ -484,7 +485,7 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
 
         matsimnibs_raw = np.dstack(ims_dict["coil_mean_raw"])
 
-        matsimnibs = pynibs.nnav2simnibs(fn_exp_nii=fn_exp_nii,
+        matsimnibs = pynibs.expio.nnav2simnibs(fn_exp_nii=fn_exp_nii,
                                          fn_conform_nii=subject.mesh[mesh_idx]['fn_mri_conform'],
                                          m_nnav=matsimnibs_raw,
                                          nnav_system="visor",
@@ -505,7 +506,7 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
                      "condition": [f"{(i - 1):04d}" for i in ims_dict["StimulusID"]]}
 
         df_stim_data = pd.DataFrame.from_dict(stim_data)
-        df_stim_data.to_hdf(fn_exp_hdf5, "stim_data")
+        df_stim_data.to_hdf(fn_exp_hdf5, key="stim_data")
 
         print(f"Writing stim_data dataframe to {fn_exp_hdf5}")
 
@@ -534,7 +535,7 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
         fn_emg_cnt = subject.exp[exp_id]['fn_emg_cnt'][0]
 
         # read info
-        cnt_info = pynibs.get_cnt_infos(fn_emg_cnt)
+        cnt_info = get_cnt_infos(fn_emg_cnt)
 
         phys_data_info_emg = dict()
         for key in cnt_info.keys():
@@ -544,11 +545,11 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
         phys_data_info_emg["emg_channels"] = emg_channels
 
         df_phys_data_info_emg = pd.DataFrame.from_dict(phys_data_info_emg)
-        df_phys_data_info_emg.to_hdf(fn_exp_hdf5, "phys_data/info/EMG")
+        df_phys_data_info_emg.to_hdf(fn_exp_hdf5, key="phys_data/info/EMG")
         print(f"Writing EMG info dataframe (phys_data/info/EMG) to {fn_exp_hdf5}")
 
         # read raw emg data from cnt file and write to hdf5 file
-        emg = pynibs.visor.get_cnt_data(fn_emg_cnt,
+        emg = get_cnt_data(fn_emg_cnt,
                                         channels=emg_channels,
                                         max_duration=max_duration,
                                         trigger_val=emg_trigger_value,
@@ -560,7 +561,7 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
         print(f"Writing EMG raw dataframe (phys_data/raw/EMG) to {fn_exp_hdf5}")
 
         # filter data
-        emg_filt = pynibs.visor.filter_emg(emg=emg, fs=phys_data_info_emg["sampling_rate"])
+        emg_filt = filter_emg(emg=emg, fs=phys_data_info_emg["sampling_rate"])
         df_phys_data_postproc_emg = pd.DataFrame.from_dict({"filtered": emg_filt})
 
         # calc p2p
@@ -568,7 +569,7 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
         # p2p = calc_p2p(emg_filt)
         # df_phys_data_postproc_emg["p2p"] = p2p
 
-        df_phys_data_postproc_emg.to_hdf(fn_exp_hdf5, "phys_data/postproc/EMG")
+        df_phys_data_postproc_emg.to_hdf(fn_exp_hdf5, key="phys_data/postproc/EMG")
         print(f"Writing EMG postproc dataframe (phys_data/postproc/EMG) to {fn_exp_hdf5}")
 
     # read eeg
@@ -606,7 +607,7 @@ def merge_exp_data_visor(subject, exp_id=0, mesh_idx=0, verbose=False, start_mep
         phys_data_info_eeg["eeg_channels"] = eeg_channels
 
         df_phys_data_info_eeg = pd.DataFrame.from_dict(phys_data_info_eeg)
-        df_phys_data_info_eeg.to_hdf(fn_exp_hdf5, "phys_data/info/EEG")
+        df_phys_data_info_eeg.to_hdf(fn_exp_hdf5, key="phys_data/info/EEG")
         print(f"Writing EEG info dataframe (phys_data/info/EEG) to {fn_exp_hdf5}")
 
         # read raw eeg data from cnt file and write to hdf5 file

pynibs/freesurfer.py

@@ -47,7 +47,7 @@ def read_curv_data(fname_curv, fname_inf, raw=False):
     points_inf, con_inf = nibabel.freesurfer.read_geometry(fname_inf)
 
     # interpolate point data to element centers
-    curv = pynibs.data_nodes2elements(curv_points, con_inf)
+    curv = pynibs.mesh.data_nodes2elements(curv_points, con_inf)
 
     # normalize curvature data, optional
     if not raw:
@@ -81,7 +81,7 @@ def make_group_average(subjects=None, subject_dir=None, average=None, hemi="lh",
         Which hemisphere: ``lh`` or ``rh``.
 
         .. deprecated:: 0.0.1
-            Don't use any more.
+            Don't use anymore.
     template : str, default: 'mytemplate'
         Basename of new template.
     steps : int, default: 2
@@ -114,7 +114,7 @@ def make_group_average(subjects=None, subject_dir=None, average=None, hemi="lh",
     for i, subject in enumerate(subjects):
         if not os.path.exists(os.path.join(subject_dir, subject_names[i])):
             print(('Generating symlink of subject {} in {}'.format(subject_names[i], subject_dir)))
-            pynibs.bash('ln -s ' + subject + ' ' + subject_dir)
+            pynibs.util.utils.bash('ln -s ' + subject + ' ' + subject_dir)
 
     os.chdir(subject_dir)
 
@@ -140,15 +140,15 @@ def make_group_average(subjects=None, subject_dir=None, average=None, hemi="lh",
             # print [command, "{}/surf/{}.sphere {}{}.tif {}.sphere.myreg{}".format(subject,
             # hemi, template, i, hemi, i)]
             processes.add(subprocess.Popen(
-                    [f'{command} '
-                     f'{os.path.split(subject)[1]}{os.sep}surf{os.sep}lh.sphere lh{template}{i}.tif '
-                     f'{"lh"}.sphere.{template}{i}'],
-                    shell=True))
+                [f'{command} '
+                 f'{os.path.split(subject)[1]}{os.sep}surf{os.sep}lh.sphere lh{template}{i}.tif '
+                 f'{"lh"}.sphere.{template}{i}'],
+                shell=True))
             processes.add(subprocess.Popen(
-                    [f"{command} "
-                     f"{os.path.split(subject)[1]}{os.sep}surf{os.sep}rh.sphere rh{template}{i}.tif "
-                     f"{'rh'}.sphere.{template}{i}"],
-                    shell=True))
+                [f"{command} "
+                 f"{os.path.split(subject)[1]}{os.sep}surf{os.sep}rh.sphere rh{template}{i}.tif "
+                 f"{'rh'}.sphere.{template}{i}"],
+                shell=True))
 
             # check if n_cpu processes are reached
             if len(processes) >= n_cpu:
@@ -203,7 +203,6 @@ def make_average_subject(subjects, subject_dir, average_dir, fn_reg='sphere.reg'
     <Files> : .tif and .reg files
         Average template in average_dir and registered curvature files, ``?h.sphere.reg`` in subjects/surf folders.
     """
-
     subject_names = [os.path.split(subjects[i])[1] for i in range(len(subjects))]
 
     # check for right operating system
@@ -221,7 +220,7 @@ def make_average_subject(subjects, subject_dir, average_dir, fn_reg='sphere.reg'
     for i, subject in enumerate(subjects):
         if not os.path.exists(os.path.join(subject_dir, subject_names[i])):
             print(('Generating symlink of subject {} in {}'.format(subject_names[i], subject_dir)))
-            pynibs.bash('ln -s ' + subject + ' ' + subject_dir)
+            pynibs.util.utils.bash('ln -s ' + subject + ' ' + subject_dir)
 
     # make average template
     if os.path.exists(f'{subject_dir}{os.sep}avg_template'):
@@ -308,19 +307,19 @@ def data_sub2avg(fn_subject_obj, fn_average_obj, hemisphere, fn_in_hdf5_data, da
 
     # filename of mapped subject data in nodes in .curv format for freesurfer (will be generated)
     fn_data_sub_nodes_mapped_curv = [os.path.join(
-            os.path.split(fn_out_hdf5_geo)[0],
-            hemisphere + '.' +
-            os.path.split(subject_dir)[1] +
-            '_' +
-            data_label[i] +
-            '.curv')
+        os.path.split(fn_out_hdf5_geo)[0],
+        hemisphere + '.' +
+        os.path.split(subject_dir)[1] +
+        '_' +
+        data_label[i] +
+        '.curv')
         for i in range(len(data_label))]
 
     # filename of mapped subject data in nodes on average template in .curv format for freesurfer (will be generated)
     fn_data_sub_nodes_mapped_avg_curv = [os.path.join(
-            os.path.split(fn_data_sub_nodes_mapped_curv[i])[0],
-            os.path.splitext(os.path.split(fn_data_sub_nodes_mapped_curv[i])[1])[0] +
-            '_avg.curv')
+        os.path.split(fn_data_sub_nodes_mapped_curv[i])[0],
+        os.path.splitext(os.path.split(fn_data_sub_nodes_mapped_curv[i])[1])[0] +
+        '_avg.curv')
         for i in range(len(data_label))]
 
     if verbose:
@@ -353,7 +352,7 @@ def data_sub2avg(fn_subject_obj, fn_average_obj, hemisphere, fn_in_hdf5_data, da
             if verbose:
                 print('> Transforming subject data from element centers to nodes')
             # data_sub_nodes = [pynibs.data_elements2nodes(data_sub[i], con_ROI) for i in range(len(data_label))]
-            data_sub_nodes = pynibs.data_elements2nodes(data_sub, con_roi)
+            data_sub_nodes = pynibs.mesh.data_elements2nodes(data_sub, con_roi)
 
         else:
             data_sub_nodes = data_sub
@@ -365,15 +364,17 @@ def data_sub2avg(fn_subject_obj, fn_average_obj, hemisphere, fn_in_hdf5_data, da
         if subject.roi[mesh_idx][roi_idx]['fn_mask']:
             if verbose:
                 print('> Mapping point data of ROI to whole brain surface')
-            data_sub_nodes_mapped = pynibs.map_data_to_surface(datasets=data_sub_nodes,
-                                                               points_datasets=[points_roi] * len(data_sub_nodes),
-                                                               con_datasets=[con_roi] * len(data_sub_nodes),
-                                                               fname_fsl_gm=os.path.join(mesh_folder_sub, fn_sub_gm),
-                                                               fname_fsl_wm=os.path.join(mesh_folder_sub, fn_sub_wm),
-                                                               delta=subject.roi[mesh_idx][roi_idx]['delta'],
-                                                               input_data_in_center=False,
-                                                               return_data_in_center=False,
-                                                               data_substitute=data_substitute)
+            data_sub_nodes_mapped = pynibs.mesh.map_data_to_surface(datasets=data_sub_nodes,
+                                                                    points_datasets=[points_roi] * len(data_sub_nodes),
+                                                                    con_datasets=[con_roi] * len(data_sub_nodes),
+                                                                    fname_fsl_gm=os.path.join(mesh_folder_sub,
+                                                                                              fn_sub_gm),
+                                                                    fname_fsl_wm=os.path.join(mesh_folder_sub,
+                                                                                              fn_sub_wm),
+                                                                    delta=subject.roi[mesh_idx][roi_idx]['delta'],
+                                                                    input_data_in_center=False,
+                                                                    return_data_in_center=False,
+                                                                    data_substitute=data_substitute)
         else:
             data_sub_nodes_mapped = data_sub_nodes
 
@@ -428,7 +429,7 @@ def data_sub2avg(fn_subject_obj, fn_average_obj, hemisphere, fn_in_hdf5_data, da
     if verbose:
         print('> Transforming mapped nodal data to element centers')
     for i in range(len(data_label)):
-        data_avg_centers_mapped[i] = pynibs.data_nodes2elements(data_avg_nodes_mapped[i], con_avg)[:, np.newaxis]
+        data_avg_centers_mapped[i] = pynibs.mesh.data_nodes2elements(data_avg_nodes_mapped[i], con_avg)[:, np.newaxis]
 
     # create .hdf5 geometry file
     if verbose: