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

pynibs/regression/regression.py

@@ -3,10 +3,10 @@ import time
 import h5py
 import inspect
 import warnings
-import multiprocessing
 import pandas as pd
 import numpy as np
 import scipy.stats
+import multiprocessing
 from lmfit import Model
 from scipy.linalg import svd
 from functools import partial
@@ -21,11 +21,13 @@ class Element(object):
     """ 
     Fit Element object class
     """
-    def __init__(self, x, y, ele_id, fun=pynibs.expio.fit_funs.sigmoid4, score_type="R2", select_signed_data=False, constants=None,
+    def __init__(self, x, y, ele_id, fun=None, score_type="R2", select_signed_data=False, constants=None,
                  **kwargs):
         """
         Initializes Fit Element instance
         """
+        if fun is None:
+            fun=pynibs.expio.sigmoid4
         self.x = x
         self.y = y
         self.y_passed = self.y
@@ -129,15 +131,28 @@ class Element(object):
 
         elif self.fun == pynibs.expio.fit_funs.exp0:
             if self.limits == {}:
-                self.set_limits({"x0": [0, 1000], "r": [1e-12, 100]})
+                self.set_limits({"x0": [0, 100], "r": [1e-12, 100]})
             else:
                 self.set_limits(self.limits)
             if self.init_vals == {}:
                 self.set_init_vals({"x0": 10, "r": .1})
             else:
                 self.set_init_vals(self.init_vals)
+
+            if self.random_vals_init_range == {}:
+                self.random_vals_init_range = {"x0": [0, 100], "r": [0, .2], "y0": [0, 10]}
+
+        elif self.fun == pynibs.expio.fit_funs.exp:
+            if self.limits == {}:
+                self.set_limits({"x0": [0, 100], "r": [1e-12, 100], "y0": [1e-12, 100]})
+            else:
+                self.set_limits(self.limits)
+            if self.init_vals == {}:
+                self.set_init_vals({"x0": 10, "r": .1, "y0": 1e-12})
+            else:
+                self.set_init_vals(self.init_vals)
             if self.random_vals_init_range == {}:
-                self.random_vals_init_range = {"x0": [0, 10], "r": [0, .2]}
+                self.random_vals_init_range = {"x0": [0, 100], "r": [0, 1], "y0": [0, 10]}
 
         elif self.fun in [pynibs.expio.fit_funs.sigmoid, pynibs.expio.fit_funs.sigmoid_log,
                           pynibs.expio.fit_funs.sigmoid4, pynibs.expio.fit_funs.sigmoid4_log]:
@@ -148,7 +163,8 @@ class Element(object):
 
             if self.fun == pynibs.expio.fit_funs.sigmoid4_log and y_min <= 0:
                 y0 = 1e-3
-            elif (self.fun == pynibs.expio.fit_funs.sigmoid4_log and y_min > 0) or self.fun == pynibs.expio.fit_funs.sigmoid4:
+            elif ((self.fun == pynibs.expio.fit_funs.sigmoid4_log and y_min > 0) or
+                  self.fun == pynibs.expio.fit_funs.sigmoid4):
                 y0 = y_min
             else:
                 y0 = 0
@@ -237,6 +253,17 @@ class Element(object):
 
             if "a" not in self.random_vals_init_range:
                 self.random_vals_init_range["a"] = [0, 1]
+        elif self.fun == pynibs.expio.fit_funs.step:
+            if self.limits == {}:
+                self.set_limits({"a": [-100, 100]})
+            else:
+                self.set_limits(self.limits)
+            if self.init_vals == {}:
+                self.set_init_vals({"a": 40})
+            else:
+                self.set_init_vals(self.init_vals)
+            if self.random_vals_init_range == {}:
+                self.random_vals_init_range = {"a": [0, 200]}
         else:
             raise NotImplementedError(self.fun)
 
@@ -271,7 +298,7 @@ class Element(object):
             r2_pos = 1 - np.var(residual) / np.var(self.y[mask_pos])
         else:
             p_pos = 1
-            r2_pos = np.NaN
+            r2_pos = np.nan
             b_pos = -1
 
         # fit negative data (perform the regression when we have at least 20 data points to stabilize results)
@@ -283,11 +310,11 @@ class Element(object):
             r2_neg = 1 - np.var(residual) / np.var(self.y[mask_neg])
         else:
             p_neg = 1
-            r2_neg = np.NaN
+            r2_neg = np.nan
             b_neg = 1
 
         # only use data with p < 0.001 and when slopes show an increase of y-data with increasing |x|-data otherwise,
-        # set status to False to indicate that the fit is omitted and set score to NaN
+        # set status to False to indicate that the fit is omitted and set score to nan
         pos_valid = False
         neg_valid = False
 
@@ -314,7 +341,7 @@ class Element(object):
                 self.r2_lin = r2_neg
         else:
             self.status = False
-            self.score = np.NaN
+            self.score = np.nan
 
         self.var_y = np.var(self.y)
         self.norm_y = np.linalg.norm(self.y)
@@ -375,8 +402,8 @@ def workhorse_element_init(ele_id, e_matrix, mep, fun, score_type, select_signed
     return element
 
 
-def regress_data(e_matrix, mep, elm_idx_list=None, element_list=None, fun=pynibs.expio.fit_funs.sigmoid4, n_cpu=4, con=None,
-                 n_refit=50, zap_idx=None, return_fits=False, score_type="R2",
+def regress_data(e_matrix, mep, elm_idx_list=None, element_list=None, fun=pynibs.expio.fit_funs.sigmoid4, n_cpu=4,
+                 con=None, n_refit=50, zap_idx=None, return_fits=False, score_type="R2",
                  verbose=False, pool=None, refit_discontinuities=True, select_signed_data=False,
                  mp_context="fork", **kwargs):
     """
@@ -395,7 +422,7 @@ def regress_data(e_matrix, mep, elm_idx_list=None, element_list=None, fun=pynibs
         (n_zaps,) List containing the element indices the fit is performed for.
     element_list : list of Element object instances, optional
         [n_ele] pynibs.Element objects ot skip initialization here.
-    fun : pynibs.exp.Mep, default: pynibs.sigmoid4
+    fun : pynibs.exp.Mep, default: pynibs.expio.sigmoid4
         A pynibs.exp.Mep function (exp0, sigmoid, sigmoid4, ...).
     n_cpu : int, default: 4
         Number of threads, if n_cpu=1 no parallel pool will be opened and all calculations are done in serial.
@@ -517,19 +544,18 @@ def regress_data(e_matrix, mep, elm_idx_list=None, element_list=None, fun=pynibs
                                     ) for ele_id in elm_idx_list]
 
         else:
+            # element_list = tqdm.tqdm(pool.imap(workhorse_init_partial, elm_idx_list), total=len(elm_idx_list))
             element_list = pool.map(workhorse_init_partial, elm_idx_list)
         stop = time.time()
         if verbose:
             print(f"Initialized {len(elm_idx_list)} elements: {stop - start:2.2f} s")
 
     # run fit
-    ####################################################################
-    start = time.time()
-
     if n_cpu <= 1:
         for ele in element_list:
             ele.run_fit(max_nfev=10 * len(ele.x))
     else:
+        # element_list = tqdm.tqdm(pool.imap(workhorse_partial, element_list), total=len(element_list))
         element_list = pool.map(workhorse_partial, element_list)
 
     stop = time.time()
@@ -596,11 +622,11 @@ def regress_data(e_matrix, mep, elm_idx_list=None, element_list=None, fun=pynibs
         if len(element_list) > 1:
             score = np.array([ele.score for ele in element_list])
             not_fitted_elms = np.array([idx for idx, ele in enumerate(element_list) if np.isnan(ele.score)])
-            idx_disc, idx_neighbor = pynibs.get_indices_discontinuous_data(data=score,
-                                                                           con=con,
-                                                                           neighbor=True,
-                                                                           deviation_factor=2,
-                                                                           not_fitted_elms=not_fitted_elms)
+            idx_disc, idx_neighbor = pynibs.mesh.get_indices_discontinuous_data(data=score,
+                                                                                con=con,
+                                                                                neighbor=True,
+                                                                                deviation_factor=2,
+                                                                                not_fitted_elms=not_fitted_elms)
             element_list_disc = [element_list[i_ele] for i_ele in idx_disc]
 
             if len(idx_disc) > 0:
@@ -1145,7 +1171,7 @@ def fit_elms(elm_idx_list, e_matrix, mep, zap_idx=None,
             param_hints[p]['value'] = constants_elmwise[p][i]
         make_params()
 
-        # perform fit (for some reason, sigmoid4_log function generates NaN, which I can not reproduce)
+        # perform fit (for some reason, sigmoid4_log function generates nan, which I can not reproduce)
         # I catch the fitting error (ValueError) and set an r2 score of -1, such that it will go into the refit
 
         e_elm = e_matrix[:, elm_idx]
@@ -1201,7 +1227,7 @@ def fit_elms(elm_idx_list, e_matrix, mep, zap_idx=None,
 #         Electric field matrix
 #     mep : np.ndarray of float [n_zaps]
 #         Motor evoked potentials for every stimulation
-#     zap_idx : np.array [n_zaps], default: None
+#     zap_idx : np.ndarray [n_zaps], default: None
 #         Indices of zaps the congruence factor is calculated with (default: all)
 #     fun : str
 #         A function name of pynibs.exp.Mep (exp0, sigmoid)
@@ -1306,7 +1332,7 @@ def fit_elms(elm_idx_list, e_matrix, mep, zap_idx=None,
 #
 #         make_params()
 #
-#         # perform fit (for some reason, sigmoid4_log function generates NaN, which I can not reproduce)
+#         # perform fit (for some reason, sigmoid4_log function generates nan, which I can not reproduce)
 #         # I catch the fitting error (ValueError) and set an r2 score of -1, such that it will go into the refit
 #
 #         try:
@@ -1439,7 +1465,7 @@ def nl_hdf5(elm_idx_list=None, fn_reg_hdf5=None, qoi_path_hdf5=None, e_matrix=No
         if verbose:
             print(" > Using provided pool object")
     if n_cpu > 1:
-        elm_idx_list_chunks = pynibs.compute_chunks(elm_idx_list, n_cpu)
+        elm_idx_list_chunks = pynibs.util.utils.compute_chunks(elm_idx_list, n_cpu)
     elif len(elm_idx_list) == 1:
         elm_idx_list_chunks = [elm_idx_list]
     elif n_cpu == 1:
@@ -1530,8 +1556,9 @@ def nl_hdf5(elm_idx_list=None, fn_reg_hdf5=None, qoi_path_hdf5=None, e_matrix=No
                                 #                        max_vals_refit[p][idx_re] * (np.random.rand() - 0.5)
 
                         if n_cpu > 1:
-                            elm_idx_list_chunks_zero = pynibs.compute_chunks(np.array(elm_idx_list)[idx_refit].tolist(),
-                                                                             n_cpu)
+                            elm_idx_list_chunks_zero = pynibs.util.utils.compute_chunks(
+                                    np.array(elm_idx_list)[idx_refit].tolist(),
+                                    n_cpu)
                         elif len(elm_idx_list[idx_refit]) == 1:
                             elm_idx_list_chunks_zero = [elm_idx_list[idx_refit]]
                         else:  # n_cpu == 1:
@@ -1584,10 +1611,10 @@ def nl_hdf5(elm_idx_list=None, fn_reg_hdf5=None, qoi_path_hdf5=None, e_matrix=No
             # find discontinuities and refit
             ##################################################################
             if refit_discontinuities and len(c) > 1:
-                idx_disc, idx_neighbor = pynibs.get_indices_discontinuous_data(data=c,
-                                                                               con=con,
-                                                                               neighbor=True,
-                                                                               deviation_factor=2)
+                idx_disc, idx_neighbor = pynibs.mesh.get_indices_discontinuous_data(data=c,
+                                                                                    con=con,
+                                                                                    neighbor=True,
+                                                                                    deviation_factor=2)
                 idx_disc = np.array(idx_disc)
 
                 if len(idx_disc) > 0:
@@ -1602,8 +1629,8 @@ def nl_hdf5(elm_idx_list=None, fn_reg_hdf5=None, qoi_path_hdf5=None, e_matrix=No
                                 init_vals[p][idx_re] = best_values[idx_ne][p]
 
                         if n_cpu > 1:
-                            elm_idx_list_chunks_disc = pynibs.compute_chunks(np.array(elm_idx_list)[idx_disc].tolist(),
-                                                                             n_cpu)
+                            elm_idx_list_chunks_disc = pynibs.util.utils.compute_chunks(np.array(elm_idx_list)[idx_disc].tolist(),
+                                                                                        n_cpu)
                         elif len(elm_idx_list[idx_disc]) == 1:
                             elm_idx_list_chunks_disc = [elm_idx_list[idx_disc]]
                         else:  # n_cpu == 1:
@@ -1845,7 +1872,7 @@ def nl_hdf5_single_core_write(i, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=N
     mep : pandas.DataFrame, optional
         The motor evoked potential (MEP) data.
     fun : function, default: sigmoid4
-        The non-linear optimization function to use (default: pynibs.sigmoid4).
+        The non-linear optimization function to use (default: pynibs.expio.sigmoid4).
     con : object, optional
         Constraints for optimization, if applicable.
     n_refit : int, default: 50
@@ -1973,8 +2000,8 @@ def get_bad_elms(x, y, method="lstsq", verbose=False):
         raise NotImplementedError(f'Method {method} unknown.')
 
     if verbose:
-        print(
-                f"Proc{str_pref}:  > {len(idx)}/{x.shape[1]} bad elms removed from fitting ({time.time() - start:2.4} s).")
+        print(f"Proc{str_pref}:  > {len(idx)}/{x.shape[1]} "
+              f"bad elms removed from fitting ({time.time() - start:2.4} s).")
 
     return idx
 
@@ -2086,7 +2113,7 @@ def nl_hdf5_single_core(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=N
     # get e field stats
     e_stats_dicts = None
     if return_e_field_stats:
-        mc = pynibs.mutual_coherence(e_matrix.transpose())
+        mc = pynibs.util.utils.mutual_coherence(e_matrix.transpose())
         _, sv_rat, _ = svd(e_matrix)
         sv_rat = np.max(sv_rat) / np.min(sv_rat)
         e_stats_dicts = {'mc': mc,
@@ -2189,9 +2216,9 @@ def nl_hdf5_single_core(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=N
 
                 # find discontinuities and refit
 
-                idx_disc, idx_neighbor = pynibs.get_indices_discontinuous_data(data=c, con=con, neighbor=True,
-                                                                               deviation_factor=2, min_val=1e-12,
-                                                                               not_fitted_elms=bad_elm_idx)
+                idx_disc, idx_neighbor = pynibs.mesh.get_indices_discontinuous_data(data=c, con=con, neighbor=True,
+                                                                                    deviation_factor=2, min_val=1e-12,
+                                                                                    not_fitted_elms=bad_elm_idx)
                 idx_disc = np.setdiff1d(idx_disc, bad_elm_idx)
 
                 if len(idx_disc) > 0:
@@ -2271,7 +2298,7 @@ def stepdown_approach(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=Non
         (n_zaps, n_ele) Electric field matrix.
     mep : np.ndarray of float
         (n_zaps) Motor evoked potentials for every stimulation.
-    zap_idx : np.array, optional
+    zap_idx : np.ndarray, optional
         (n_zaps) Indices of zaps the congruence factor is calculated with (default: all).
     fun : function object
         A function of pynibs.exp.Mep (exp0, sigmoid).
@@ -2297,6 +2324,7 @@ def stepdown_approach(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=Non
         * "R2": R2 score (Model variance / Total variance); linear fits: [0, 1], 1 ... perfect fit
         * "SR": Relative standard error of regression (1 - Error 2-norm / Data 2-norm); [-Inf, 1], 1 ... perfect fit
         * "rho": Spearman correlation coefficient [-1, 1]; finds any monotonous correlation (0 means no correlation)
+
     return_progress : bool, default: False
         Return c maps for all steps to allow visualization over e-fitting over timesteps.
     smooth_data : bool, default: False
@@ -2307,18 +2335,21 @@ def stepdown_approach(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=Non
     Returns
     -------
     dict:
+        A dictionary containing the following elements:
 
         * r2 : np.ndarray of float
             (n_roi, n_qoi) R2 for each element in elm_idx_list.
         * best_values: list of dict
-            Fit information, if wanted.
+            Fit information, if requested.
         * stats : dict
-            If wanted:
-            'mc': float
+            If requested:
+
+            ``mc``: float
                 Mutual coherence for e fields.
-            'sv_rat' : float
+            ``sv_rat`` : float
                 SVD singular value ratio.
         * progress : cmaps for each step.
+
     """
     starttime = time.time()
 
@@ -2380,7 +2411,7 @@ def stepdown_approach(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=Non
     e_stats_dicts = None
     if return_e_field_stats:
         stats_start = time.time()
-        mc = pynibs.mutual_coherence(e_matrix.transpose())
+        mc = pynibs.util.utils.mutual_coherence(e_matrix.transpose())
 
         sv_rat = svd(e_matrix, check_finite=False, compute_uv=False)
         sv_rat = np.max(sv_rat) / np.min(sv_rat)
@@ -2436,7 +2467,7 @@ def stepdown_approach(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=Non
         if verbose:
             print(f"Proc{str_pref}:  > Initial c-factor map done. ({stop - start:2.2f} s)")
 
-        # pick the best elements and compute their neibors' fits
+        # pick the best elements and compute their neighbors' fits
         n_top = int(len(start_sample) * .2)
 
         elms_done = start_sample[np.argpartition(c[start_sample], -n_top)[-n_top:]]
@@ -2497,13 +2528,13 @@ def stepdown_approach(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=Non
                     # refit already here some elements
                     not_fitted_elms = c[np.array(list(elms_done))] <= 0
                     # get random neighbor to refit
-                    idx_disc, idx_neighbor = pynibs.get_indices_discontinuous_data(data=c[np.array(list(elms_done))],
-                                                                                   con=con[np.array(list(elms_done))],
-                                                                                   neighbor=True,
-                                                                                   deviation_factor=3, min_val=1e-12,
-                                                                                   not_fitted_elms=not_fitted_elms,
-                                                                                   crit='randmax',
-                                                                                   neigh_style='point')
+                    idx_disc, idx_neighbor = pynibs.mesh.get_indices_discontinuous_data(data=c[np.array(list(elms_done))],
+                                                                                        con=con[np.array(list(elms_done))],
+                                                                                        neighbor=True,
+                                                                                        deviation_factor=3, min_val=1e-12,
+                                                                                        not_fitted_elms=not_fitted_elms,
+                                                                                        crit='randmax',
+                                                                                        neigh_style='point')
                     idx_disc = np.setdiff1d(idx_disc, bad_elm_idx)
                     # set init values from neighbors best values
                     for p in params:
@@ -2547,10 +2578,10 @@ def stepdown_approach(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=Non
 
         # refit the discontinues elemens
         not_fitted_elms = c == 0
-        idx_disc, idx_neighbor = pynibs.get_indices_discontinuous_data(data=c, con=con[elm_idx_list], neighbor=True,
-                                                                       deviation_factor=3, min_val=1e-12,
-                                                                       not_fitted_elms=not_fitted_elms, crit='max',
-                                                                       neigh_style='point')
+        idx_disc, idx_neighbor = pynibs.mesh.get_indices_discontinuous_data(data=c, con=con[elm_idx_list], neighbor=True,
+                                                                            deviation_factor=3, min_val=1e-12,
+                                                                            not_fitted_elms=not_fitted_elms, crit='max',
+                                                                            neigh_style='point')
         idx_disc = np.setdiff1d(idx_disc, bad_elm_idx)
 
         disc_fit_i, last_disc_idx = 1, idx_disc
@@ -2580,10 +2611,10 @@ def stepdown_approach(zap_idx, elm_idx_list, fn_reg_hdf5=None, qoi_path_hdf5=Non
 
             # prepare the next iteration
             last_disc_n = len(idx_disc)
-            idx_disc, idx_neighbor = pynibs.get_indices_discontinuous_data(data=c, con=con[elm_idx_list], neighbor=True,
-                                                                           deviation_factor=3, min_val=1e-12,
-                                                                           not_fitted_elms=not_fitted_elms, crit='max',
-                                                                           neigh_style='point')
+            idx_disc, idx_neighbor = pynibs.mesh.get_indices_discontinuous_data(data=c, con=con[elm_idx_list], neighbor=True,
+                                                                                deviation_factor=3, min_val=1e-12,
+                                                                                not_fitted_elms=not_fitted_elms, crit='max',
+                                                                                neigh_style='point')
             idx_disc = np.setdiff1d(idx_disc, bad_elm_idx)
             if np.all(last_disc_idx == idx_disc):
                 break

pynibs/roi/__init__.py

@@ -1,2 +1,5 @@
-from .roi import *
+"""
+Functions that operate on region of interest (ROI) data.
+"""
+from .roi_utils import *
 from .roi_structs import *

pynibs/roi/roi_structs.py

@@ -6,7 +6,6 @@ import math
 import scipy
 import skimage
 import tqdm
-import trimesh
 import warnings
 import numpy as np
 import nibabel as nib
@@ -560,7 +559,6 @@ class RegionOfInterestSurface:
         """
         Initialize RegionOfInterestSurface class instance
         """
-
         self.node_coord_up = np.empty(0)
         self.node_coord_mid = np.empty(0)
         self.node_coord_low = np.empty(0)
@@ -702,7 +700,7 @@ class RegionOfInterestSurface:
         tri_center_coord_low : np.ndarray of float [N_roi_tri x 3]
             Coordinates (x, y, z) of triangle center of lower epsilon layer of ROI surface
         fn_mask : str
-            Filename for freesurfer mask. If given, this is used instead of *_ROIs
+            Filename for freesurfer mask. If given, this is used instead of \\*_ROIs
         X_ROI : list of float
             Region of interest [Xmin, Xmax], whole X range if empty [0,0] or None
             (left - right)
@@ -720,6 +718,7 @@ class RegionOfInterestSurface:
             make_GM_WM_surface(self, gm_surf_fname, wm_surf_fname, delta, X_ROI, Y_ROI, Z_ROI)
             make_GM_WM_surface(self, gm_surf_fname, wm_surf_fname, delta, mask_fn, layer=3)
         """
+        import trimesh
         self.gm_surf_fname = gm_surf_fname
         self.wm_surf_fname = wm_surf_fname
         self.midlayer_surf_fname = midlayer_surf_fname
@@ -893,12 +892,12 @@ class RegionOfInterestSurface:
             mesh.export(roi_fn)
 
             roi_refined_fn = os.path.join(self.mesh_folder, "roi", "tmp", "roi_refined.stl")
-            pynibs.refine_surface(fn_surf=roi_fn,
-                                  fn_surf_refined=roi_refined_fn,
-                                  center=[0, 0, 0],
-                                  radius=np.inf,
-                                  verbose=True,
-                                  repair=False)
+            pynibs.mesh.refine_surface(fn_surf=roi_fn,
+                                       fn_surf_refined=roi_refined_fn,
+                                       center=[0, 0, 0],
+                                       radius=np.inf,
+                                       verbose=True,
+                                       repair=False)
 
             roi = trimesh.load(roi_refined_fn)
             con_cropped_reform = roi.faces
@@ -912,12 +911,12 @@ class RegionOfInterestSurface:
                                            faces=con_cropped_reform)
                     mesh.export(roi_fn)
 
-                    pynibs.refine_surface(fn_surf=roi_fn,
-                                          fn_surf_refined=roi_refined_fn,
-                                          center=[0, 0, 0],
-                                          radius=np.inf,
-                                          verbose=True,
-                                          repair=False)
+                    pynibs.mesh.refine_surface(fn_surf=roi_fn,
+                                               fn_surf_refined=roi_refined_fn,
+                                               center=[0, 0, 0],
+                                               radius=np.inf,
+                                               verbose=True,
+                                               repair=False)
 
                     roi.append(trimesh.load(roi_refined_fn))
 
@@ -1004,7 +1003,7 @@ class RegionOfInterestSurface:
         RegionOfInterestSurface.tet_idx_node_coord_mid : np.ndarray
             (N_tri) Tetrahedra indices of TetrahedraLinear object instance where the nodes of the middle
             surface are.
-     """
+        """
         # determine tetrahedra indices of triangle center points of upper, middle and lower surface
         if self.tri_center_coord_low != [] and self.tri_center_coord_up != []:
             points = [self.tri_center_coord_low,
@@ -1049,7 +1048,7 @@ class RegionOfInterestSurface:
         ele_idx : np.ndarray of float
             [approx. fraction * n_ele] Element indices of the subsampled surface; sorted.
         """
-
+        import trimesh
         mesh = trimesh.Trimesh(
             vertices=self.node_coord_mid,
             faces=self.node_number_list
@@ -1079,7 +1078,6 @@ class RegionOfInterestSurface:
         ele_idx : ndarray of float
             (n_ele) Element indices of the subsampled surface.
         """
-
         # load sphere surface
         sphere_coords, sphere_faces = nib.freesurfer.io.read_geometry(fn_sphere)
 
@@ -1140,7 +1138,6 @@ class RegionOfInterestVolume:
         the ROI mesh is not the same as the head mesh, the triangle center of the ROI mesh are always lying in a
         tetrahedra of the head mesh (these indices are given in this case).
     """
-
     def __init__(self):
         """ Initialize RegionOfInterestVolume class instance """
 
@@ -1165,10 +1162,12 @@ class RegionOfInterestVolume:
 
             - type = 'box': [Xmin, Xmax] (in mm), whole X range if empty [0,0] or None (left - right)
             - type = 'sphere': origin [x,y,z]
+
         y_roi: list of float
 
             - type = 'box': [Ymin, Ymax] (in mm), whole Y range if empty [0,0] or None (anterior - posterior)
             - type = 'sphere': radius (in mm)
+
         z_roi: list of float
 
             - type = 'box': [Zmin, Zmax] (in mm), whole Z range if empty [0,0] or None (inferior - superior)
@@ -1189,12 +1188,11 @@ class RegionOfInterestVolume:
             lying in
         RegionOfInterestVolume.tet_idx_triangle_center : np.ndarray [N_tri_roi]
             Tetrahedra indices of TetrahedraLinear object instance where the center points of the ROI triangle are
-           . If the ROI is directly generated from the msh instance using "make_roi_volume_from_msh", these
+            If the ROI is directly generated from the msh instance using "make_roi_volume_from_msh", these
             indices are the triangle indices of the head mesh since the ROI mesh and the head mesh are overlapping. If
             the ROI mesh is not the same as the head mesh, the triangle center of the ROI mesh are always. a
             tetrahedra of the head mesh (these indices are given in this case)
         """
-
         if volume_type == 'box':
             roi_mask_bool = (msh.points[:, 0] > min(x_roi)) & (msh.points[:, 0] < max(x_roi)) & \
                             (msh.points[:, 1] > min(y_roi)) & (msh.points[:, 1] < max(y_roi)) & \