pyNIBS 0.2024.8__py3-none-any.whl

pynibs/tests/test_mesh_transformations.py

@@ -0,0 +1,123 @@
+import unittest
+import numpy as np
+import os
+import meshio
+import tempfile
+from pynibs import (point_data_to_cell_data_vtk,
+                    cell_data_to_point_data_vtk,
+                    cell_data_to_point_data,
+                    data_nodes2elements)
+
+
+class TestMeshFunctions(unittest.TestCase):
+    def setUp(self):
+        # Create a simple mesh for testing
+        self.points = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]])
+        self.con = np.array([[0, 1, 2]])
+        cells = [("triangle", self.con)]
+
+        self.cell_data = {"test": [np.array([[1]])]}
+        self.mesh_cell_data_1d = meshio.Mesh(self.points, cells, cell_data=self.cell_data)
+
+        self.cell_data = {"test": [np.array([[1, 2, 3]])]}
+        self.mesh_cell_data_3d = meshio.Mesh(self.points, cells, cell_data=self.cell_data)
+
+        cell_data = {"test": [np.array([[1, 2, 3]])],
+                     "test2": [np.array([[100, 200, 300]])]}
+        self.mesh_cell_datas_3d = meshio.Mesh(self.points, cells, cell_data=cell_data)
+
+        # Create another mesh for testing with point data
+        self.point_data = {"test": np.array([[1, 2, 3],
+                                             [1, 2, 3],
+                                             [1, 2, 3]])}
+        self.mesh_point_data_3d = meshio.Mesh(self.points, cells, point_data=self.point_data)
+
+        point_data = {"test": np.array([1, 2, 3])}
+        self.mesh_point_data_1d = meshio.Mesh(self.points, cells, point_data=point_data)
+
+        point_data = {"test": np.array([1, 2, 3]),
+                      "test2": np.array([100, 200, 300])}
+        self.mesh_point_datas_1d = meshio.Mesh(self.points, cells, point_data=point_data)
+
+    def test_point_to_cell_data(self):
+        # Test conversion from point data to cell data for both meshes
+        for mesh in [self.mesh_point_data_1d, self.mesh_point_data_3d]:
+            with tempfile.NamedTemporaryFile(suffix=".vtu") as temp_file:
+                cell_data = point_data_to_cell_data_vtk(mesh, fn=temp_file.name)
+                self.assertTrue("test" in cell_data)
+                self.assertEqual(cell_data["test"].shape[0], mesh.cells[0].data.shape[0])
+                self.assertTrue(os.path.exists(temp_file.name))
+
+    def test_cell_to_point_data(self):
+        # Test conversion from cell data to point data for both meshes
+        for mesh in [self.mesh_cell_data_1d, self.mesh_cell_data_3d]:
+            with tempfile.NamedTemporaryFile(suffix=".vtu") as temp_file:
+                point_data = cell_data_to_point_data_vtk(mesh, fn=temp_file.name)
+                self.assertTrue("test" in point_data)
+                self.assertEqual(point_data["test"].shape[0], mesh.points.shape[0])
+                self.assertTrue(os.path.exists(temp_file.name))
+
+    def test_point_to_cell_data_from_con(self):
+        # Test conversion from point data to cell data for both meshes
+        for mesh in [self.mesh_point_data_1d, self.mesh_point_data_3d]:
+            with tempfile.NamedTemporaryFile(suffix=".vtu") as temp_file:
+                cell_data = point_data_to_cell_data_vtk(nodes=self.points,
+                                                        con=self.con,
+                                                        point_data=self.point_data, fn=temp_file.name)
+                self.assertTrue("test" in cell_data)
+                self.assertEqual(cell_data["test"].shape[0], mesh.cells[0].data.shape[0])
+                self.assertTrue(os.path.exists(temp_file.name))
+
+    def test_cell_to_point_data_from_con(self):
+        # Test conversion from cell data to point data for both meshes
+        for mesh in [self.mesh_cell_data_1d, self.mesh_cell_data_3d]:
+            with tempfile.NamedTemporaryFile(suffix=".vtu") as temp_file:
+                point_data = cell_data_to_point_data_vtk(nodes=self.points,
+                                                         con=self.con,
+                                                         cell_data=self.cell_data,
+                                                         fn=temp_file.name)
+                self.assertTrue("test" in point_data)
+                self.assertEqual(point_data["test"].shape[0], mesh.points.shape[0])
+                self.assertTrue(os.path.exists(temp_file.name))
+
+    def test_point_to_cell_multiple_data(self):
+        # Test conversion from point data to cell data for both meshes
+        mesh = self.mesh_point_datas_1d
+        with tempfile.NamedTemporaryFile(suffix=".vtu") as temp_file:
+            cell_data = point_data_to_cell_data_vtk(mesh, fn=temp_file.name)
+            self.assertTrue("test" in cell_data)
+            self.assertEqual(cell_data["test"].shape[0], mesh.cells[0].data.shape[0])
+            self.assertTrue("test2" in cell_data)
+            self.assertEqual(cell_data["test2"].shape[0], mesh.cells[0].data.shape[0])
+            self.assertTrue(os.path.exists(temp_file.name))
+
+    def test_cell_to_point_multiple_data(self):
+        # Test conversion from cell data to point data for both meshes
+        mesh = self.mesh_cell_datas_3d
+        with tempfile.NamedTemporaryFile(suffix=".vtu") as temp_file:
+            point_data = cell_data_to_point_data_vtk(mesh, fn=temp_file.name)
+            self.assertTrue("test" in point_data)
+            self.assertEqual(point_data["test"].shape[0], mesh.points.shape[0])
+            self.assertTrue("test2" in point_data)
+            self.assertEqual(point_data["test2"].shape[0], mesh.points.shape[0])
+            self.assertTrue(os.path.exists(temp_file.name))
+
+    def test_cell_data_to_point_data(self):
+        # Convert the cell data to point data
+        data_nodes = cell_data_to_point_data(self.con, self.cell_data['test'][0], self.points)
+
+        # Check the result
+        self.assertEqual(data_nodes.shape, self.points.shape)
+        self.assertTrue(np.all(data_nodes >= 1) and np.all(data_nodes <= 4))
+
+    def test_data_nodes2elements(self):
+        # Convert the node data to element data
+        data_tris = data_nodes2elements(self.point_data['test'], self.con)
+
+        # Check the result
+        self.assertEqual(data_tris.shape, self.con.shape)
+        self.assertTrue(np.all(data_tris >= 1) and np.all(data_tris <= 4))
+
+
+if __name__ == "__main__":
+    unittest.main()

pynibs/tests/test_mesh_utils.py

@@ -0,0 +1,143 @@
+import os
+import pynibs
+import unittest
+import numpy as np
+
+
+class TestFindNearest(unittest.TestCase):
+    monot_arr = np.array([0, 1, 2, 3, 5, 10])
+    nonmonot_arr = np.array([10, 0, 1, 2, 3, 5, 10])
+    value = 5
+
+    def test_01_find_nearest(self):
+        idx = pynibs.find_nearest(array=self.monot_arr, value=self.value)
+        assert idx == 4
+
+    def test_02_find_nearest_fail(self):
+        idx = pynibs.find_nearest(array=self.nonmonot_arr, value=self.value)
+        assert idx == -1
+
+
+class TestCalcSampleSphere(unittest.TestCase):
+    mesh_hdf5_fn = os.path.join(pynibs.__testdatadir__, 'geo.hdf5')
+    mesh = pynibs.load_mesh_hdf5(mesh_hdf5_fn)
+
+    def test_01_sample_sphere_even(self):
+        with self.assertRaises(AssertionError):
+            pynibs.sample_sphere(n_points=10, r=10)
+
+    def test_02_sample_sphere_odd(self):
+        points = pynibs.sample_sphere(n_points=11, r=10)
+        assert points.shape == (11, 3)
+
+
+class TestCalcTriSurface(unittest.TestCase):
+    mesh_hdf5_fn = os.path.join(pynibs.__testdatadir__, 'geo.hdf5')
+    mesh = pynibs.load_mesh_hdf5(mesh_hdf5_fn)
+
+    def test_01_calc_tri_volume(self):
+        tri_surf = pynibs.calc_tri_surface(points=self.mesh.points[self.mesh.triangles])
+        assert tri_surf.size == self.mesh.triangles.shape[0]
+        assert (tri_surf > 0).all()
+
+
+class TestCalcTetVolume(unittest.TestCase):
+    mesh_hdf5_fn = os.path.join(pynibs.__testdatadir__, 'geo.hdf5')
+    mesh = pynibs.load_mesh_hdf5(mesh_hdf5_fn)
+
+    def test_01_calc_tet_volume_abs(self):
+        tet_vol = pynibs.calc_tet_volume(points=self.mesh.points[self.mesh.tetrahedra])
+        assert tet_vol.size == self.mesh.tetrahedra.shape[0]
+        assert (tet_vol > 0).all()
+
+    def test_02_calc_tet_volume_no_abs(self):
+        tet_vol = pynibs.calc_tet_volume(points=self.mesh.points[self.mesh.tetrahedra],
+                                         abs=False)
+        assert tet_vol.size == self.mesh.tetrahedra.shape[0]
+        assert (tet_vol < 0).any()
+
+
+class TestGetSphere(unittest.TestCase):
+    """
+    Test pynibs.mesh.utils.* functions.
+    """
+    mesh_hdf5_fn = os.path.join(pynibs.__testdatadir__, 'geo.hdf5')
+    target_empty = [10, 20, 30]
+    target_full_tris = [0., 45.2227265, 71.97155693]
+    target_full_tets = [9.51698047, 84.46553784, 0.]
+    radius = 3
+
+    def test_01_get_sphere_fails(self):
+        # no mesh and no mesh_fn
+        with self.assertRaises(AssertionError):
+            pynibs.get_sphere(mesh=None,
+                              mesh_fn=None,
+                              target=self.target_empty,
+                              radius=self.radius)
+
+        # no target
+        with self.assertRaises(AssertionError):
+            pynibs.get_sphere(mesh=None, mesh_fn=self.mesh_hdf5_fn)
+
+        # wrong element type
+        with self.assertRaises(ValueError):
+            # no radius, return nearest element
+            pynibs.get_sphere(mesh=None,
+                              mesh_fn=self.mesh_hdf5_fn,
+                              target=self.target_empty,
+                              elmtype='square')
+
+    def test_02_get_sphere_nearest_tri(self):
+        # no radius, return nearest element
+        nearest_elm = pynibs.get_sphere(mesh=None,
+                                        mesh_fn=self.mesh_hdf5_fn,
+                                        target=self.target_empty)
+        assert nearest_elm == 681
+
+        nearest_elm = pynibs.get_sphere(mesh=None,
+                                        mesh_fn=self.mesh_hdf5_fn,
+                                        target=self.target_empty,
+                                        elmtype='Triangle')
+        assert nearest_elm == 681
+
+    def test_02_get_sphere_nearest_tet(self):
+        # no radius, return nearest element
+        nearest_elm = pynibs.get_sphere(mesh=None,
+                                        mesh_fn=self.mesh_hdf5_fn,
+                                        target=self.target_empty,
+                                        elmtype='tets')
+        assert nearest_elm == 20232
+
+        nearest_elm = pynibs.get_sphere(mesh=None,
+                                        mesh_fn=self.mesh_hdf5_fn,
+                                        target=self.target_empty,
+                                        elmtype='Tetrahedron')
+        assert nearest_elm == 20232
+
+        # return sphere, but should be empty
+        sphere_empty = pynibs.get_sphere(mesh=None,
+                                         mesh_fn=self.mesh_hdf5_fn,
+                                         target=self.target_empty,
+                                         radius=5)
+        assert sphere_empty.size == 0
+
+    def test_02_get_sphere_tris(self):
+        # return tri sphere, should not be empty
+        sphere_full_tris = pynibs.get_sphere(mesh=None,
+                                             mesh_fn=self.mesh_hdf5_fn,
+                                             target=self.target_full_tris,
+                                             radius=10)
+        assert sphere_full_tris.size == 13
+
+    def test_03_get_sphere_tets(self):
+        # return tet sphere, should not be empty
+        sphere_full_tets = pynibs.get_sphere(mesh=None,
+                                             mesh_fn=self.mesh_hdf5_fn,
+                                             target=self.target_full_tets,
+                                             radius=10,
+                                             elmtype='tets')
+        assert sphere_full_tets.size == 50
+
+
+if __name__ == '__main__':
+    unittest.main()

pynibs/tests/test_nnav_imports.py

@@ -0,0 +1,101 @@
+import unittest
+import numpy as np
+import pynibs
+
+class TestPyNIBSLocalite(unittest.TestCase):
+    def setUp(self):
+        # Set up any necessary paths to your .xml files here
+        self.valid_im_path = f"{pynibs.__testdatadir__}/InstrumentMarker20200225163611937.xml"
+        self.valid_tm_path = f"{pynibs.__testdatadir__}/TriggerMarkers_Coil1_20200225170337572.xml"
+        self.im_test = np.array([[[  0.9013614 ,   0.29839201,  -0.3138959 , -71.18429093],
+                                  [  0.38530408,  -0.8834528 ,   0.26659466, -79.95375675],
+                                  [ -0.19776044,  -0.36123975,  -0.91127244,  38.69342634],
+                                  [  0.        ,   0.        ,   0.        ,   1.        ]]])
+        self.self_tm_0 = np.array([[  0.89563849,   0.37653939,  -0.2367116 , -71.16214655],
+                                   [  0.42635749,  -0.87839562,   0.21592364, -75.74648256],
+                                   [ -0.12662378,  -0.29431584,  -0.94727356,  38.65814855],
+                                   [  0.        ,   0.        ,   0.        ,   1.        ]])
+
+    # def test_get_instrument_marker_valid(self):
+    #     # Test get_instrument_marker with valid input
+    #     final_arr, marker_description = pynibs.localite.get_instrument_marker(self.valid_im_path)
+    #     # Assert expected result here
+    #     assert np.isclose(final_arr, self.im_test).all()
+    #     assert np.array(marker_description) == np.array(['test'])
+    #
+    # def test_get_instrument_marker_list(self):
+    #     # Test get_instrument_marker with a list of valid paths
+    #     final_arr, marker_description = pynibs.localite.get_instrument_marker([self.valid_im_path, self.valid_im_path])
+    #     # Assert expected result here
+    #     assert len(final_arr) == len(marker_description) == 2
+    #     assert np.isclose(final_arr[0], self.im_test).all()
+    #     assert np.isclose(final_arr[1], self.im_test).all()
+    #     assert np.array(marker_description[0]) == np.array(['test'])
+    #     assert np.array(marker_description[1]) == np.array(['test'])
+
+    def test_get_marker_valid(self):
+        # Test get_marker with valid parameters
+        final_arr, marker_description, times = pynibs.localite.get_marker(self.valid_im_path, 'InstrumentMarker')
+        # Assert expected result here
+        assert np.isclose(final_arr, self.im_test).all()
+        assert np.array(marker_description) == np.array(['test'])
+        assert times == []
+
+    def test_read_triggermarker_localite_valid(self):
+        # Test read_triggermarker_localite with valid input
+        m_nnav, didt, mso, descr, rec_time = pynibs.localite.read_triggermarker_localite(self.valid_tm_path)
+
+        assert m_nnav.shape == (4,4,400)
+        assert np.isclose(self.self_tm_0, m_nnav[:,:,0]).all()
+
+        assert len(didt) == 400
+        assert (didt[:2] == np.array([1,4])).all()
+
+        assert len(mso) == 400
+        assert (mso[:2] == np.array([3, 6])).all()
+
+        assert len(descr) == 400
+
+        assert len(rec_time) == 400
+        assert rec_time[:3] == ['475056', '475251', '475450']
+
+
+class TestReadTargetsBrainsight(unittest.TestCase):
+    def setUp(self):
+        # Prepare a valid test file
+        self.valid_file = f"{pynibs.__testdatadir__}/brainsight_niiImage_nifticoord.txt"
+        self.target0 = np.array([[-9.9700e-01,  5.3000e-02,  5.9000e-02,  1.5020e+01],
+                                 [-5.6000e-02, -9.9700e-01, -4.4000e-02,  5.3062e+01],
+                                 [ 5.6000e-02, -4.8000e-02,  9.9700e-01,  8.7219e+01],
+                                 [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  1.0000e+00]])
+
+        self.sample0 = np.array([[ 7.1200e-01,  3.2100e-01, -6.2400e-01, -4.4198e+01],
+                                 [ 1.3000e-02,  8.8300e-01,  4.6900e-01,  7.5810e+01],
+                                 [ 7.0200e-01, -3.4200e-01,  6.2400e-01,  6.5742e+01],
+                                 [ 0.0000e+00,  0.0000e+00,  0.0000e+00,  1.0000e+00]])
+
+    def test_read_targets_brainsight(self):
+        # Test reading from a valid file
+        result = pynibs.brainsight.read_targets_brainsight(self.valid_file)
+        assert len(result) == 4
+        assert np.isclose(self.target0, result[:,:,0]).all()
+        self.assertEqual(result.shape, (4, 4, 7))  # Expecting one target with a 4x4 matrix
+
+
+    def test_get_marker_targets(self):
+        # Test reading from a valid file
+        matsimnibs, description, timings = pynibs.brainsight.get_marker(self.valid_file, markertype='Targets')
+        assert matsimnibs.shape == (7,4,4)
+        assert np.isclose(self.target0, matsimnibs[0,:,:]).all()
+
+
+    def test_get_marker_samples(self):
+        # Test reading from a valid file
+        matsimnibs, description, timings = pynibs.brainsight.get_marker(self.valid_file, markertype='Samples')
+        assert matsimnibs.shape == (101,4,4)
+        assert matsimnibs.shape[0] == len(description) == len(timings)
+        assert np.isclose(self.sample0, matsimnibs[0,:,:]).all()
+
+
+if __name__ == '__main__':
+    unittest.main()

pynibs/tests/test_quality_measures.py

@@ -0,0 +1,117 @@
+import gdist
+import pynibs
+import unittest
+import numpy as np
+
+
+class TestGeodesicDist(unittest.TestCase):
+    """
+    Test pynibs.quality_measures.geodesic_dist()
+    """
+    nodes1 = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]])
+    tris1 = np.array([[0, 1, 2]])
+    nodes2 = np.array([[0, 0, 0], [1, 1, 1], [5, 2, 0], [5, 3, 5]])
+    tris2 = np.array([[0, 1, 2], [1, 2, 3]])
+    source_node = np.array([0])
+    source_tri = 1
+    source_is_node_node = True
+    source_is_node_tri = False
+
+    def test_geodesic_dist_node(self):
+        # Test case 1: source is a node
+        nodes_dist, tris_dist = pynibs.geodesic_dist(self.nodes1, self.tris1, self.source_node,
+                                                     self.source_is_node_node)
+
+        assert isinstance(nodes_dist, np.ndarray)
+        assert isinstance(tris_dist, np.ndarray)
+        assert np.allclose(nodes_dist, [0, np.sqrt(3), 2 * np.sqrt(3)])
+        assert np.allclose(tris_dist, [np.sqrt(3)])
+
+    '''
+    # doesn't work yet:
+    def test_geodesic_dist_tri(self):  
+        # Test case 2: source is a triangle
+        nodes_dist, tris_dist = pynibs.geodesic_dist(self.nodes2, self.tris2, self.source_tri, self.source_is_node_tri)
+
+        assert isinstance(nodes_dist, np.ndarray)
+        assert isinstance(tris_dist, np.ndarray)
+        assert np.allclose(nodes_dist, ?)
+        assert np.allclose(tris_dist, ?)
+    '''
+
+
+class TestEuclideanDist(unittest.TestCase):
+    """
+    Test pynibs.quality_measures.euclidean_dist()
+    """
+    nodes = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]])
+    tris = np.array([[0, 1, 2], [1, 2, 3]])
+    source_node = np.array([0])
+    source_tri = np.array([0])
+    source_is_node_node = True
+    source_is_node_tri = False
+
+    def test_euclidean_dist_node(self):
+        # Test case 1: source is a node
+        nodes_dist, tris_dist = pynibs.euclidean_dist(self.nodes[:-1], self.tris[:-1], self.source_node,
+                                                      self.source_is_node_node)
+
+        assert isinstance(nodes_dist, np.ndarray)
+        assert isinstance(tris_dist, np.ndarray)
+        assert np.allclose(nodes_dist, [0, np.sqrt(3), 2 * np.sqrt(3)])
+        assert np.allclose(tris_dist, [np.sqrt(3)])
+
+    '''
+    doesnt work yet:
+    def test_euclidean_dist_tri(self):
+        # Test case 2: source is a triangle
+        nodes_dist, tris_dist = pynibs.euclidean_dist(self.nodes, self.tris, self.source_tri, self.source_is_node_tri)
+
+        assert isinstance(nodes_dist, np.ndarray)
+        assert isinstance(tris_dist, np.ndarray)
+        assert np.allclose(nodes_dist, [0, np.sqrt(3), 2 * np.sqrt(3), 3 * np.sqrt(3)])
+        assert np.allclose(tris_dist, [0, np.sqrt(3)])
+    '''
+
+
+class TestIntersectionVecPlan(unittest.TestCase):
+
+    def test_direct_intersection(self):
+        ray_dir = np.array([0, 0, -1])
+        ray_origin = np.array([0, 0, 10])
+        plane_n = np.array([0, 0, 1])
+        plane_p = np.array([0, 0, 0])
+        expected_intersection = np.array([0, 0, 0])
+        intersec = pynibs.intersection_vec_plan(ray_dir, ray_origin, plane_n, plane_p)
+        np.testing.assert_array_almost_equal(intersec, expected_intersection)
+
+    def test_parallel_no_intersection(self):
+        ray_dir = np.array([0, 1, 0])
+        ray_origin = np.array([0, 0, 10])
+        plane_n = np.array([0, 0, 1])
+        plane_p = np.array([0, 0, 0])
+        intersec = pynibs.intersection_vec_plan(ray_dir, ray_origin, plane_n, plane_p)
+        assert (intersec == [np.inf, np.inf, np.inf]).all()
+
+    def test_origin_within_plane(self):
+        ray_dir = np.array([0, 0, 1])
+        ray_origin = np.array([0, 0, 0])
+        plane_n = np.array([0, 0, 1])
+        plane_p = np.array([0, 0, 0])
+        expected_intersection = np.array([0, 0, 0])
+        intersec = pynibs.intersection_vec_plan(ray_dir, ray_origin, plane_n, plane_p)
+        np.testing.assert_array_almost_equal(intersec, expected_intersection)
+
+    def test_edge_case_near_parallel(self):
+        ray_dir = np.array([0.001, 0.001, -1])
+        ray_origin = np.array([0, 0, 10])
+        plane_n = np.array([0, 0, 1])
+        plane_p = np.array([0, 0, 0])
+        # Expected intersection is approximate due to near parallel direction
+        expected_intersection = np.array([0.01, 0.01, 0])
+        intersec = pynibs.intersection_vec_plan(ray_dir, ray_origin, plane_n, plane_p)
+        np.testing.assert_array_almost_equal(intersec, expected_intersection, decimal=2)
+
+
+if __name__ == '__main__':
+    unittest.main()