pyNIBS 0.2024.8__py3-none-any.whl

pynibs/tests/test_regressdata.py

@@ -0,0 +1,289 @@
+import os
+import pynibs
+import numpy as np
+import unittest
+import yaml
+from inspect import getmembers, isfunction, getfullargspec
+
+import pynibs
+
+
+class TestRegressData(unittest.TestCase):
+    """
+    Test pynibs.regress_data()
+    """
+    np.random.seed(1)
+
+    n_elm_small = 10
+    # n_elm_large = 100000
+    n_mep_small = 10
+    # n_mep_large = 100
+    n_signed = 25  # because function run_select_signed_data needs > 20 data points
+
+    e_small = np.zeros((n_mep_small, n_elm_small))
+    e_small[:] = 1
+    e_small *= np.linspace(0.1, 5, n_mep_small)[:, np.newaxis]
+    e_small *= np.linspace(0.1, 5, n_elm_small)
+
+    e_signed = np.zeros((n_signed, n_signed))
+    e_signed[:] = 1
+    e_signed[0] = -1
+    e_signed *= np.linspace(0.1, 5, n_signed)[:, np.newaxis]
+    e_signed *= np.linspace(0.1, 5, n_signed)
+
+    mep_small = np.linspace(0.1, 5, n_mep_small)
+
+    mep_signed = np.linspace(0.1, 5, n_signed)
+
+    con_small = np.array([[i, i + 1, i + 2] for i in range(n_elm_small)])
+
+    def test_raise_assert_if_no_con(self):
+        """
+        When refit_discontinuities=True, con cannot be None
+        """
+        with self.assertRaises(AssertionError):
+            pynibs.regress_data(self.e_small, self.mep_small)
+
+    def test_all_default(self):
+        r2 = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False)
+        assert r2.max() > .9
+        assert r2.shape == (self.n_elm_small,)
+
+    def test_return_fits(self):
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       return_fits=True)
+        assert r2.max() > .9
+        assert r2.shape == (self.n_elm_small,)
+        assert len(fits) == self.n_elm_small
+        assert type(fits[0]) == dict
+        for k in ['x0', 'r', 'amp', 'y0']:
+            assert k in fits[0]
+
+    def test_elm_idx_list(self):
+        elm_idx_list = list(range(0, int(self.n_elm_small / 2)))
+        r2 = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                 elm_idx_list=elm_idx_list)
+        assert r2.max() > .9
+        assert r2.shape == (len(elm_idx_list),)
+
+    def test_zap_idx(self):
+        zap_idx = range(int(self.n_mep_small / 2), self.n_mep_small)
+        r2 = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                 zap_idx=zap_idx)
+        assert r2.max() > .9
+        assert r2.shape == (self.n_elm_small,)
+
+    def test_element_list_linear(self):
+        """
+        Gives regress_data() an element_list AND fun=linear
+        """
+        element_list = [pynibs.Element(x=self.e_small[:, ele_id],
+                                       y=self.mep_small,
+                                       ele_id=ele_id,
+                                       fun=pynibs.expio.fit_funs.linear,
+                                       score_type="R2",
+                                       select_signed_data=False,
+                                       constants=None) for ele_id in range(self.n_elm_small)]
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       element_list=element_list, return_fits=True)
+        assert r2.max() > .9
+        assert r2.shape == (self.n_elm_small,)
+        # let's check if really linear fits have been used
+        assert 'm' in fits[0]
+        assert 'n' in fits[0]
+
+    def test_refit_discontinuities(self):
+        r2 = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=True, n_cpu=1,
+                                 con=self.con_small)
+        assert r2.max() > .9
+        assert r2.shape == (self.n_elm_small,)
+
+    def test_n_refit(self):
+        r2 = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                 n_refit=0)
+        assert r2.max() > .9
+        assert r2.shape == (self.n_elm_small,)
+
+    def test_workhorses(self):  # and verbose
+        # Suppress output message in run_select_signed_data()
+        # suppress_text = io.StringIO()
+        # sys.stdout = suppress_text
+
+        r2 = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=4,
+                                 n_refit=0, verbose=True)
+        assert r2.max() > .9
+        assert r2.shape == (self.n_elm_small,)
+
+        # Enable output messages again
+        # sys.stdout = sys.__stdout__
+
+    def test_score_type(self):
+        sr = pynibs.regress_data(self.e_small, self.mep_small, score_type='SR', refit_discontinuities=False, n_cpu=1,
+                                 n_refit=0)
+        assert sr.max() > .9
+        assert sr.shape == (self.n_elm_small,)
+
+        rho = pynibs.regress_data(self.e_small, self.mep_small, score_type='rho', refit_discontinuities=False, n_cpu=1,
+                                  n_refit=0)
+        assert rho.max() > .9
+        assert rho.shape == (self.n_elm_small, 2)
+
+        with self.assertRaises(NotImplementedError):
+            pynibs.regress_data(self.e_small, self.mep_small, score_type='abc', refit_discontinuities=False, n_cpu=1,
+                                n_refit=0)
+
+    def test_select_signed_data(self):
+        # Suppress output message in run_select_signed_data()
+        # suppress_text = io.StringIO()
+        # sys.stdout = suppress_text
+
+        # Test with mostly positive data
+        r2_pos = pynibs.regress_data(self.e_signed, self.mep_signed, select_signed_data=True,
+                                     refit_discontinuities=False, n_refit=0)
+        assert r2_pos.max() > 0.9
+        assert r2_pos.shape == (self.n_signed,)
+
+        # Test with mostly negative data
+        r2_neg = pynibs.regress_data(-self.e_signed, self.mep_signed, select_signed_data=True,
+                                     refit_discontinuities=False, n_refit=0)
+        assert r2_neg.max() > 0.9
+        assert r2_neg.shape == (self.n_signed,)
+
+        # Enable output messages again
+        # sys.stdout = sys.__stdout__
+
+    # ***** Testing all regression functions: *****
+
+    def test_dummy_fun(self):
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       n_refit=0, fun=pynibs.expio.fit_funs.dummy_fun, return_fits=True)
+        assert r2.shape == (self.n_elm_small,)
+        assert 'a' in fits[0]
+
+    def test_sigmoid(self):
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       n_refit=0, fun=pynibs.expio.fit_funs.sigmoid, return_fits=True)
+        assert r2.max() > 0.90
+        assert r2.shape == (self.n_elm_small,)
+        assert 'x0' in fits[0]
+        assert 'r' in fits[0]
+        assert 'amp' in fits[0]
+
+    def test_sigmoid_negative_values(self):
+        r2 = pynibs.regress_data(-self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                 n_refit=0, fun=pynibs.expio.fit_funs.sigmoid)
+        assert r2.max() > 0.90
+        assert r2.shape == (self.n_elm_small,)
+
+    def test_sigmoid_log(self):
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       n_refit=0, fun=pynibs.expio.fit_funs.sigmoid_log, return_fits=True)
+        assert r2.max() > 0.9
+        assert r2.shape == (self.n_elm_small,)
+        assert 'x0' in fits[0]
+        assert 'r' in fits[0]
+        assert 'amp' in fits[0]
+
+    def test_sigmoid4_log(self):
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       n_refit=0, fun=pynibs.expio.fit_funs.sigmoid4_log, return_fits=True)
+        assert r2.max() > 0.9
+        assert r2.shape == (self.n_elm_small,)
+        assert 'x0' in fits[0]
+        assert 'r' in fits[0]
+        assert 'amp' in fits[0]
+        assert 'y0' in fits[0]
+
+    def test_exp(self):
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       n_refit=0, fun=pynibs.expio.fit_funs.exp0, return_fits=True)
+        assert r2.max() > 0.90
+        assert r2.shape == (self.n_elm_small,)
+        assert 'x0' in fits[0]
+        assert 'r' in fits[0]
+
+    def test_raise_assert_if_false_fun(self):
+        with self.assertRaises(NotImplementedError):
+            pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                n_refit=0, fun=pynibs.expio.fit_funs.linear_log)
+
+    # ***** Testing use of yaml-configuration files: *****
+
+    def test_yaml_sigmoid4(self):
+        yaml_config = os.path.join(pynibs.__datadir__, 'configuration_sigmoid4.yaml')
+        with open(yaml_config, "r") as yamlfile:
+            config = yaml.load(yamlfile, Loader=yaml.FullLoader)
+        r2 = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                 n_refit=0, fun=pynibs.expio.fit_funs.sigmoid4, **config)
+        assert r2.max() > 0.90
+        assert r2.shape == (self.n_elm_small,)
+
+    def test_yaml_linear_MEP(self):
+        yaml_config = os.path.join(pynibs.__datadir__, 'configuration_linear_MEP.yaml')
+        with open(yaml_config, "r") as yamlfile:
+            config = yaml.load(yamlfile, Loader=yaml.FullLoader)
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       n_refit=0, fun=pynibs.expio.fit_funs.linear, return_fits=True, **config)
+        assert r2.max() > 0.90
+        assert r2.shape == (self.n_elm_small,)
+        assert 'm' in fits[0]
+        assert 'n' in fits[0]
+
+    def test_yaml_linear_RT(self):
+        yaml_config = os.path.join(pynibs.__datadir__, 'configuration_linear_RT.yaml')
+        with open(yaml_config, "r") as yamlfile:
+            config = yaml.load(yamlfile, Loader=yaml.FullLoader)
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       n_refit=0, fun=pynibs.expio.fit_funs.linear, return_fits=True, **config)
+        assert r2.max() > 0.90
+        assert r2.shape == (self.n_elm_small,)
+        assert 'm' in fits[0]
+        assert 'n' in fits[0]
+
+    def test_yaml_exp(self):
+        yaml_config = os.path.join(pynibs.__datadir__, 'configuration_exp0.yaml')
+        with open(yaml_config, "r") as yamlfile:
+            config = yaml.load(yamlfile, Loader=yaml.FullLoader)
+        r2, fits = pynibs.regress_data(self.e_small, self.mep_small, refit_discontinuities=False, n_cpu=1,
+                                       n_refit=0, fun=pynibs.expio.fit_funs.exp0, return_fits=True, **config)
+        assert r2.max() > 0.90
+        assert r2.shape == (self.n_elm_small,)
+        assert 'x0' in fits[0]
+        assert 'r' in fits[0]
+
+
+class TestSingleFit(unittest.TestCase):
+
+    def setUp(self):
+        self.x = x = np.array(range(1, 100))
+        self.args = {'a': 1,
+                     'x0': 0,
+                     'r': .2,
+                     'amp': 5,
+                     'y0': 0,
+                     'm': 5,
+                     'n': 1}
+
+    def test_single_fit(self):
+        for fun_id, fun in getmembers(pynibs.expio.fit_funs):
+            if isfunction(fun):
+                if fun_id == 'dummy_fun':
+                    continue
+
+                fun_params = getfullargspec(fun)[0]
+                print(f"Testing {fun_id} with: {fun_params}")
+                fun_args = {k: self.args[k] for k in fun_params if k != 'x'}
+                y = fun(self.x, **fun_args)
+
+                fit = pynibs.single_fit(self.x, y, fun)
+                for k in fun_params:
+                    if k != 'x':
+                        print(
+                            f"\t{k}: org: {self.args[k]} | "
+                            f"fit: {fit.params[k].value} | "
+                            f"{np.isclose(self.args[k], fit.params[k].value, atol=.1)}")
+                print(f"R2: {fit.rsquared}")
+
+
+if __name__ == '__main__':
+    unittest.main()

pynibs/tests/test_roi.py

@@ -0,0 +1,17 @@
+import unittest
+import pynibs
+
+
+class TestRegIonOfInterestSurface(unittest.TestCase):
+
+    def test_regionofinterestsurface(self):
+        roi = pynibs.RegionOfInterestSurface()
+        for field in ["X_ROI", "Y_ROI", "Z_ROI"]:
+            assert hasattr(roi, field)
+        for field in ["x_roi", "x_roi", "x_roi"]:
+            assert not hasattr(roi, field)
+
+
+class TestRegionOfInterestVolume(unittest.TestCase):
+    def test_regionofinterestvolume(self):
+        roi = pynibs.RegionOfInterestVolume()

pynibs/tests/test_rotations.py

@@ -0,0 +1,86 @@
+import unittest
+import pynibs
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+
+
+class TestUtilsRotationsbases2rotmat(unittest.TestCase):
+    mat = np.array(([1., 0., 0., 0.],
+                    [0., 1., 0., 0.],
+                    [0., 0., 1., 0.],
+                    [10., 20., 30., 1.])).T
+
+    def test_bases2rotmat(self):
+        v1 = np.array(([0, 0, 1], [0, 1, 0], [1, 0, 0]))
+        v2 = np.array(([1, 0, 0], [0, 1, 0], [0, 0, 1]))
+        res = R.from_matrix(pynibs.bases2rotmat(v1, v2)).as_euler('xyz', degrees=True)
+        assert (res == np.array([180., 0., 180.])).all()
+
+    def test_roatate_matsimnibs_euler_no_rot(self):
+        for axis in ['x', 'y', 'z']:
+            assert (self.mat == pynibs.rotate_matsimnibs_euler(axis=axis, angle=0, matsimnibs=self.mat,
+                                                               metric='rad')).all()
+            assert (self.mat == pynibs.rotate_matsimnibs_euler(axis=axis, angle=0, matsimnibs=self.mat,
+                                                               metric='deg')).all()
+
+            assert np.allclose(
+                    pynibs.rotate_matsimnibs_euler(axis=axis, angle=2 * np.pi, matsimnibs=self.mat, metric='rad'),
+                    self.mat)
+            assert np.allclose(pynibs.rotate_matsimnibs_euler(axis=axis, angle=360, matsimnibs=self.mat, metric='deg'),
+                               self.mat)
+
+    def test_identity(self):
+        # Test if the function returns identity matrix for the same input
+        identity = np.eye(3)
+        result = pynibs.bases2rotmat(identity, identity)
+        np.testing.assert_array_almost_equal(result, identity)
+
+    def test_rotation(self):
+        # Test if the function correctly calculates rotation matrix
+        rot = R.from_euler('xyz', [80, 0, 0], degrees=True)
+        base = np.eye(3)
+        target = rot.as_matrix()
+        result = pynibs.bases2rotmat(target, base)
+        np.testing.assert_array_almost_equal(result, target)
+
+    def test_rotate_matsimnibs_euler_180(self):
+        assert np.allclose(pynibs.rotate_matsimnibs_euler(axis='x', angle=np.pi, matsimnibs=self.mat, metric='rad'),
+                           np.array([[1., 0., 0., 10.],
+                                     [0., -1., -0., 20.],
+                                     [0., 0., -1., 30.],
+                                     [0., 0., 0., 1.]])
+                           )
+        assert np.allclose(pynibs.rotate_matsimnibs_euler(axis='y', angle=np.pi, matsimnibs=self.mat, metric='rad'),
+                           np.array([[-1., 0., 0., 10.],
+                                     [0., 1., 0., 20.],
+                                     [-0., 0., -1., 30.],
+                                     [0., 0., 0., 1.]]))
+        assert np.allclose(pynibs.rotate_matsimnibs_euler(axis='z', angle=np.pi, matsimnibs=self.mat, metric='rad'),
+                           np.array([[-1., -0., 0., 10.],
+                                     [0., -1., 0., 20.],
+                                     [0., 0., 1., 30.],
+                                     [0., 0., 0., 1.]]))
+
+
+class TestUtilsRotationsrotmatfromvecs(unittest.TestCase):
+    def test_rotmat_from_vecs(self):
+        vec1 = np.array([1, 0, 0])
+        vec2 = np.array([0, 1, 0])
+        expected_result = R.from_euler('z', 90, degrees=True)
+        result = pynibs.rotmat_from_vecs(vec1, vec2)
+        np.testing.assert_array_almost_equal(result.as_matrix(), expected_result.as_matrix())
+
+
+class TestUtilsRotationsrotMattoEulerAngles(unittest.TestCase):
+    def test_rotation_matrix_to_euler_angles(self):
+        # Define some Euler angles
+        euler_angles = np.array([np.pi / 2, np.pi / 3, np.pi / 4])
+
+        # Convert the Euler angles to a rotation matrix
+        rotation_matrix = pynibs.euler_angles_to_rotation_matrix(euler_angles)
+
+        # Pass the rotation matrix to the function and get the output Euler angles
+        output_euler_angles = pynibs.rotation_matrix_to_euler_angles(rotation_matrix)
+
+        # Check that the output Euler angles match the original Euler angles
+        np.testing.assert_array_almost_equal(output_euler_angles, euler_angles)

pynibs/tests/test_subject.py

@@ -0,0 +1,71 @@
+import unittest
+import tempfile
+import pynibs
+import sys
+import shutil
+import os
+
+
+class TestSubject(unittest.TestCase):
+    """
+    Test pynibs.subject.* functions.
+    """
+    subject_id = 'testsub'
+    mesh_names = ['charm_refm1_sm', 'headreco', 'headreco_refined_m1']
+    create_subject_fn = "create_subject_testsub.py"
+    create_subject_fn_org = os.path.join(pynibs.__testdatadir__, create_subject_fn)
+
+    # get temporary folder and move create_subject.py theree
+    folder = tempfile.TemporaryDirectory()
+    fn_create_subject = os.path.join(folder.name, create_subject_fn)
+    fn_subject_object = os.path.join(folder.name, f"{subject_id}.hdf5")
+    shutil.copyfile(create_subject_fn_org, fn_create_subject)
+
+    def test_01_create_subject(self):
+        cmd = f"{sys.executable} {self.fn_create_subject}"
+        assert os.system(cmd) == 0, f"Creating subject failed"
+
+    def test_02_load_subject(self):
+        subject = pynibs.load_subject(self.fn_subject_object)
+        for mesh_id in self.mesh_names:
+            assert mesh_id in subject.mesh.keys(), f"{mesh_id} not found in {self.fn_subject_object}"
+
+    def test_03_load_subject_h5(self):
+        no_hdf5_suffix = os.path.join(self.folder.name, 'test.h5')
+        shutil.copyfile(self.fn_subject_object, no_hdf5_suffix)
+        with self.assertRaises(NotImplementedError):
+            pynibs.load_subject(no_hdf5_suffix)
+        subject = pynibs.load_subject(no_hdf5_suffix, filetype='hdf5')
+        for mesh_id in self.mesh_names:
+            assert mesh_id in subject.mesh.keys(), f"{mesh_id} not found in {self.fn_subject_object}"
+
+    def test_04_save_subject(self):
+        subject = pynibs.load_subject(self.fn_subject_object)
+        fn_new = self.fn_subject_object.replace('.hdf5', '_new.hdf5')
+        pynibs.save_subject(subject_id=self.subject_id,
+                            subject_folder=self.folder.name,
+                            fname=fn_new,
+                            mri_dict=subject.mri,
+                            mesh_dict=subject.mesh,
+                            roi_dict=subject.roi,
+                            exp_dict=subject.exp,
+                            ps_dict=subject.ps,
+                            overwrite=True,
+                            check_file_exist=False,
+                            verbose=False)
+        subject = pynibs.load_subject(fn_new)
+        for mesh_id in self.mesh_names:
+            assert mesh_id in subject.mesh.keys(), f"{mesh_id} not found in {self.fn_subject_object}"
+
+    # def test_06_add_stuff(self):
+    #     subject = pynibs.load_subject(self.fn_subject_object)
+    #     mri = subject.mri[0]
+    #     subject.add_mri_info(mri)
+    #
+    #     exp = {'TMS_localite': subject.exp['TMS_localite']}
+    #     exp['fn_coil'] = exp['TMS_localite']['fn_coil'][0][0]
+    #     subject.add_experiment_info(exp)
+
+    def test_05_print_subject(self):
+        subject = pynibs.load_subject(self.fn_subject_object)
+        print(subject)

pynibs/tests/test_util.py

@@ -0,0 +1,24 @@
+import pynibs
+import unittest
+from scipy.spatial.transform import Rotation as rot
+import numpy as np
+
+
+class TestIntersectionVecPlan(unittest.TestCase):
+    def test_intersection(self):
+        r = rot.from_rotvec([45, 0, 0], degrees=True)
+
+        # Define plane
+        plane_n = np.array([0, 0, 1])
+        plane_p = np.array([0, 0, 20])  # Any point on the plane
+
+        # Define ray
+        ray_dir = r.apply([0, 0, 1])  # np.array([0, -1, -1])
+        ray_origin = np.array([0, 0, 0])  # Any point along the ray
+
+        ret = pynibs.intersection_vec_plan(ray_dir, ray_origin, plane_n, plane_p, eps=1e-6)
+        assert np.all(np.isclose(np.array([0., -20., 20.]), np.array(ret)))
+
+
+if __name__ == '__main__':
+    unittest.main()

pynibs/tms_pulse.py

@@ -0,0 +1,34 @@
+import numpy as np
+
+
+def biphasic_pulse(t, R=0.0338, L=15.5*1e-6, C=193.6*1e-6, alpha=1089.8, f=2900):
+    """
+    Returns normalized single biphasic pulse waveform of electric field (first derivative of coil current)
+
+    Parameters
+    ----------
+    t: ndarray of float [n_t]
+        Time array in seconds
+    R: float, optional, default: 0.0338 Ohm
+        Resistance of coil in (Ohm)
+    L: float, optional, default: 15.5*1e-6 H
+        Inductance of coil in (H)
+    C: float, optional, default: 193.6*1e-6
+        Capacitance of coil in (F)
+    alpha: float, optional, default: 1089.8 1/s
+        Damping coefficient in (1/s)
+    f: float, optional, default: 2900 Hz
+        Frequency in (Hz)
+
+    Returns
+    -------
+    e: ndarray of float [n_t]
+        Normalized electric field time course (can be scaled with electric field)
+    """
+
+    omega = 2 * np.pi * f
+    i = 1/(omega*L) * np.exp(-alpha*t) * np.sin(omega*t)
+    e = np.gradient(i)
+    e = e/np.max(e)
+
+    return i, e

pynibs/util/__init__.py

@@ -0,0 +1,4 @@
+from .util import *
+from .quality_measures import *
+from .rotations import *
+from .simnibs import *