def test_load_surf_mesh_file_freesurfer(): mesh = generate_surf() for suff in ['.pial', '.inflated', '.white', '.orig', 'sphere']: filename_fs_mesh = tempfile.mktemp(suffix=suff) nb.freesurfer.write_geometry(filename_fs_mesh, mesh[0], mesh[1]) assert len(load_surf_mesh(filename_fs_mesh)) == 2 assert_array_almost_equal(load_surf_mesh(filename_fs_mesh)[0], mesh[0]) assert_array_almost_equal(load_surf_mesh(filename_fs_mesh)[1], mesh[1]) os.remove(filename_fs_mesh)
def test_load_surf_mesh_file_error(): # test if files with unexpected suffixes raise errors mesh = generate_surf() wrong_suff = ['.vtk', '.obj', '.mnc', '.txt'] for suff in wrong_suff: filename_wrong = tempfile.mktemp(suffix=suff) nb.freesurfer.write_geometry(filename_wrong, mesh[0], mesh[1]) with pytest.raises(ValueError, match='input type is not recognized'): load_surf_mesh(filename_wrong) os.remove(filename_wrong)
def test_load_surf_mesh_file_freesurfer(): # Older nibabel versions does not support 'write_geometry' if LooseVersion(nb.__version__) <= LooseVersion('1.2.0'): raise SkipTest mesh = _generate_surf() for suff in ['.pial', '.inflated', '.white', '.orig', 'sphere']: filename_fs_mesh = tempfile.mktemp(suffix=suff) nb.freesurfer.write_geometry(filename_fs_mesh, mesh[0], mesh[1]) assert_equal(len(load_surf_mesh(filename_fs_mesh)), 2) assert_array_almost_equal(load_surf_mesh(filename_fs_mesh)[0], mesh[0]) assert_array_almost_equal(load_surf_mesh(filename_fs_mesh)[1], mesh[1]) os.remove(filename_fs_mesh)
def test_load_surf_mesh_file_freesurfer(): # Older nibabel versions does not support 'write_geometry' if LooseVersion(nb.__version__) <= LooseVersion('1.2.0'): raise SkipTest mesh = generate_surf() for suff in ['.pial', '.inflated', '.white', '.orig', 'sphere']: filename_fs_mesh = tempfile.mktemp(suffix=suff) nb.freesurfer.write_geometry(filename_fs_mesh, mesh[0], mesh[1]) assert_equal(len(load_surf_mesh(filename_fs_mesh)), 2) assert_array_almost_equal(load_surf_mesh(filename_fs_mesh)[0], mesh[0]) assert_array_almost_equal(load_surf_mesh(filename_fs_mesh)[1], mesh[1]) os.remove(filename_fs_mesh)
def test_load_surf_mesh_file_gii_gz(): # Test the loader `load_surf_mesh` with gzipped fsaverage5 files fsaverage = datasets.fetch_surf_fsaverage().pial_left coords, faces = load_surf_mesh(fsaverage) assert_true(isinstance(coords, np.ndarray)) assert_true(isinstance(faces, np.ndarray))
def test_load_surf_mesh_file_gii_gz(): # Test the loader `load_surf_mesh` with gzipped fsaverage5 files fsaverage = datasets.fetch_surf_fsaverage().pial_left coords, faces = load_surf_mesh(fsaverage) assert isinstance(coords, np.ndarray) assert isinstance(faces, np.ndarray)
def test_view_surf(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_right']) surf_map = mesh[0][:, 0] html = html_surface.view_surf(fsaverage['pial_right'], surf_map, fsaverage['sulc_right'], '90%') check_html(html, title="Surface plot") html = html_surface.view_surf(fsaverage['pial_right'], surf_map, fsaverage['sulc_right'], .3, title="SOME_TITLE") check_html(html, title="SOME_TITLE") assert "SOME_TITLE" in html.html html = html_surface.view_surf(fsaverage['pial_right']) check_html(html) atlas = np.random.RandomState(0).randint(0, 10, size=len(mesh[0])) html = html_surface.view_surf(fsaverage['pial_left'], atlas, symmetric_cmap=False) check_html(html) html = html_surface.view_surf(fsaverage['pial_right'], fsaverage['sulc_right'], threshold=None, cmap='Greys') check_html(html) with pytest.raises(ValueError): html_surface.view_surf(mesh, mesh[0][::2, 0]) with pytest.raises(ValueError): html_surface.view_surf(mesh, mesh[0][:, 0], bg_map=mesh[0][::2, 0])
def test_view_surf(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_right']) surf_map = mesh[0][:, 0] html = html_surface.view_surf(fsaverage['pial_right'], surf_map, fsaverage['sulc_right'], '90%') check_html(html) html = html_surface.view_surf(fsaverage['pial_right'], surf_map, fsaverage['sulc_right'], .3, title="SOME_TITLE") check_html(html) assert "SOME_TITLE" in html.html html = html_surface.view_surf(fsaverage['pial_right']) check_html(html) destrieux = datasets.fetch_atlas_surf_destrieux()['map_left'] html = html_surface.view_surf(fsaverage['pial_left'], destrieux, symmetric_cmap=False) check_html(html) html = html_surface.view_surf(fsaverage['pial_right'], fsaverage['sulc_right'], threshold=None, cmap='Greys') check_html(html) assert_raises(ValueError, html_surface.view_surf, mesh, mesh[0][::2, 0]) assert_raises(ValueError, html_surface.view_surf, mesh, mesh[0][:, 0], bg_map=mesh[0][::2, 0])
def test_check_mesh(): mesh = html_surface._check_mesh('fsaverage5') assert mesh is html_surface._check_mesh(mesh) assert_raises(ValueError, html_surface._check_mesh, 'fsaverage3') mesh.pop('pial_left') assert_raises(ValueError, html_surface._check_mesh, mesh) assert_raises(TypeError, html_surface._check_mesh, surface.load_surf_mesh(mesh['pial_right']))
def test_check_mesh(): mesh = html_surface._check_mesh('fsaverage5') assert mesh is html_surface._check_mesh(mesh) assert_raises(ValueError, html_surface._check_mesh, 'fsaverage3') mesh.pop('pial_left') assert_raises(ValueError, html_surface._check_mesh, mesh) assert_raises(TypeError, html_surface._check_mesh, surface.load_surf_mesh(mesh['pial_right']))
def test_load_surf_mesh_list(): # test if correct list is returned mesh = generate_surf() assert_equal(len(load_surf_mesh(mesh)), 2) assert_array_equal(load_surf_mesh(mesh)[0], mesh[0]) assert_array_equal(load_surf_mesh(mesh)[1], mesh[1]) # test if incorrect list, array or dict raises error assert_raises_regex(ValueError, 'it must have two elements', load_surf_mesh, []) assert_raises_regex(ValueError, 'it must have two elements', load_surf_mesh, [mesh[0]]) assert_raises_regex(ValueError, 'it must have two elements', load_surf_mesh, [mesh[0], mesh[1], mesh[1]]) assert_raises_regex(ValueError, 'input type is not recognized', load_surf_mesh, mesh[0]) assert_raises_regex(ValueError, 'input type is not recognized', load_surf_mesh, dict()) del mesh
def test_mesh_to_plotly(hemi): """Tests for function mesh_to_plotly.""" fsaverage = fetch_surf_fsaverage() coord, triangles = load_surf_mesh(fsaverage[f'pial_{hemi}']) plotly = mesh_to_plotly(fsaverage[f'pial_{hemi}']) for i, key in enumerate(['_x', '_y', '_z']): assert np.allclose(decode(plotly[key], '<f4'), coord[:, i]) for i, key in enumerate(['_i', '_j', '_k']): assert np.allclose(decode(plotly[key], '<i4'), triangles[:, i])
def test_load_surf_mesh_list(): # test if correct list is returned mesh = _generate_surf() assert_equal(len(load_surf_mesh(mesh)), 2) assert_array_equal(load_surf_mesh(mesh)[0], mesh[0]) assert_array_equal(load_surf_mesh(mesh)[1], mesh[1]) # test if incorrect list, array or dict raises error assert_raises_regex(ValueError, 'it must have two elements', load_surf_mesh, []) assert_raises_regex(ValueError, 'it must have two elements', load_surf_mesh, [mesh[0]]) assert_raises_regex(ValueError, 'it must have two elements', load_surf_mesh, [mesh[0], mesh[1], mesh[1]]) assert_raises_regex(ValueError, 'input type is not recognized', load_surf_mesh, mesh[0]) assert_raises_regex(ValueError, 'input type is not recognized', load_surf_mesh, dict()) del mesh
def plot_labelmap(label_map): cols = [ "#FCF9F5", "#C06A45", # CER "#5B5BFF", # DMN "#D73E68", # FP "#8D18AB", # LIM "#0AFE47", # MOT "#FF9C42", # VAT_SAL_SUB "#FFFFAA" # VIS ] from nilearn import surface from nilearn import plotting, datasets import numpy.linalg as npl import nibabel as nb fsaverage = datasets.fetch_surf_fsaverage() from PAINTeR import utils s = utils.load_surface_obj('/Users/tspisak/tmp/wm_gm_simp2.obj') s2 = surface.load_surf_mesh(fsaverage['pial_left']) from nibabel.affines import apply_affine img = nb.load(label_map) data = img.get_data() import pandas as pd from PAINTeR import global_vars l = pd.read_csv(global_vars._ATLAS_LABELS_, sep="\t") modules = l['modules'].values lut = pd.factorize(modules)[0] + 1 lut = np.array([0] + lut.tolist()) data = lut[np.array(data, dtype=int)] parcellation = np.repeat(0, len(s[0])) for i in range(len(s[0])): coord = np.round(apply_affine(npl.inv(img.affine), s[0][i])).astype(int) if coord[0] - 1 >= data.shape[0] or coord[1] - 1 >= data.shape[ 1] or coord[2] - 1 >= data.shape[2]: parcellation[i] = 0 else: parcellation[i] = data[coord[0] - 1, coord[1] - 1, coord[2] - 1] import matplotlib.cm as cm view = plotting.view_surf( s, surf_map=parcellation, cmap=ListedColormap(sns.color_palette( cols)), # ListedColormap(cm.get_cmap('tab20').colors) threshold=0, symmetric_cmap=False) view.open_in_browser()
def test_mesh_to_plotly(): fsaverage = fetch_surf_fsaverage() coord, triangles = surface.load_surf_mesh(fsaverage['pial_left']) plotly = js_plotting_utils.mesh_to_plotly(fsaverage['pial_left']) for i, key in enumerate(['_x', '_y', '_z']): assert np.allclose( js_plotting_utils.decode(plotly[key], '<f4'), coord[:, i]) for i, key in enumerate(['_i', '_j', '_k']): assert np.allclose( js_plotting_utils.decode(plotly[key], '<i4'), triangles[:, i])
def test_check_mesh(): mesh = html_surface._check_mesh('fsaverage5') assert mesh is html_surface._check_mesh(mesh) with pytest.raises(ValueError): html_surface._check_mesh('fsaverage3') mesh.pop('pial_left') with pytest.raises(ValueError): html_surface._check_mesh(mesh) with pytest.raises(TypeError): html_surface._check_mesh(surface.load_surf_mesh(mesh['pial_right']))
def test_mesh_to_plotly(): fsaverage = fetch_surf_fsaverage() coord, triangles = surface.load_surf_mesh(fsaverage['pial_left']) plotly = js_plotting_utils.mesh_to_plotly(fsaverage['pial_left']) for i, key in enumerate(['_x', '_y', '_z']): assert np.allclose(js_plotting_utils.decode(plotly[key], '<f4'), coord[:, i]) for i, key in enumerate(['_i', '_j', '_k']): assert np.allclose(js_plotting_utils.decode(plotly[key], '<i4'), triangles[:, i])
def test_load_surf_mesh_file_gii(): # Test the loader `load_surf_mesh` # If nibabel is of older version we skip tests as nibabel does not # support intent argument and intent codes are not handled properly with # older versions if not LooseVersion(nb.__version__) >= LooseVersion('2.1.0'): raise SkipTest mesh = generate_surf() # test if correct gii is loaded into correct list filename_gii_mesh = tempfile.mktemp(suffix='.gii') coord_array = gifti.GiftiDataArray(data=mesh[0], intent=nb.nifti1.intent_codes[ 'NIFTI_INTENT_POINTSET']) face_array = gifti.GiftiDataArray(data=mesh[1], intent=nb.nifti1.intent_codes[ 'NIFTI_INTENT_TRIANGLE']) gii = gifti.GiftiImage(darrays=[coord_array, face_array]) gifti.write(gii, filename_gii_mesh) assert_array_equal(load_surf_mesh(filename_gii_mesh)[0], mesh[0]) assert_array_equal(load_surf_mesh(filename_gii_mesh)[1], mesh[1]) os.remove(filename_gii_mesh) # test if incorrect gii raises error filename_gii_mesh_no_point = tempfile.mktemp(suffix='.gii') gifti.write(gifti.GiftiImage(darrays=[face_array, face_array]), filename_gii_mesh_no_point) assert_raises_regex(ValueError, 'NIFTI_INTENT_POINTSET', load_surf_mesh, filename_gii_mesh_no_point) os.remove(filename_gii_mesh_no_point) filename_gii_mesh_no_face = tempfile.mktemp(suffix='.gii') gifti.write(gifti.GiftiImage(darrays=[coord_array, coord_array]), filename_gii_mesh_no_face) assert_raises_regex(ValueError, 'NIFTI_INTENT_TRIANGLE', load_surf_mesh, filename_gii_mesh_no_face) os.remove(filename_gii_mesh_no_face)
def test_load_surf_mesh_file_gii(): # Test the loader `load_surf_mesh` # If nibabel is of older version we skip tests as nibabel does not # support intent argument and intent codes are not handled properly with # older versions if not LooseVersion(nb.__version__) >= LooseVersion('2.1.0'): raise SkipTest mesh = generate_surf() # test if correct gii is loaded into correct list filename_gii_mesh = tempfile.mktemp(suffix='.gii') coord_array = gifti.GiftiDataArray(data=mesh[0], intent=nb.nifti1.intent_codes[ 'NIFTI_INTENT_POINTSET']) face_array = gifti.GiftiDataArray(data=mesh[1], intent=nb.nifti1.intent_codes[ 'NIFTI_INTENT_TRIANGLE']) gii = gifti.GiftiImage(darrays=[coord_array, face_array]) gifti.write(gii, filename_gii_mesh) assert_array_equal(load_surf_mesh(filename_gii_mesh)[0], mesh[0]) assert_array_equal(load_surf_mesh(filename_gii_mesh)[1], mesh[1]) os.remove(filename_gii_mesh) # test if incorrect gii raises error filename_gii_mesh_no_point = tempfile.mktemp(suffix='.gii') gifti.write(gifti.GiftiImage(darrays=[face_array, face_array]), filename_gii_mesh_no_point) assert_raises_regex(ValueError, 'NIFTI_INTENT_POINTSET', load_surf_mesh, filename_gii_mesh_no_point) os.remove(filename_gii_mesh_no_point) filename_gii_mesh_no_face = tempfile.mktemp(suffix='.gii') gifti.write(gifti.GiftiImage(darrays=[coord_array, coord_array]), filename_gii_mesh_no_face) assert_raises_regex(ValueError, 'NIFTI_INTENT_TRIANGLE', load_surf_mesh, filename_gii_mesh_no_face) os.remove(filename_gii_mesh_no_face)
def test_load_surf_mesh(): coords, faces = generate_surf() mesh = Mesh(coords, faces) assert_array_equal(mesh.coordinates, coords) assert_array_equal(mesh.faces, faces) # Call load_surf_mesh with a Mesh as argument loaded_mesh = load_surf_mesh(mesh) assert isinstance(loaded_mesh, Mesh) assert_array_equal(mesh.coordinates, loaded_mesh.coordinates) assert_array_equal(mesh.faces, loaded_mesh.faces) mesh_like = MeshLikeObject(coords, faces) assert_array_equal(mesh_like.coordinates, coords) assert_array_equal(mesh_like.faces, faces) # Call load_surf_mesh with an object having # coordinates and faces attributes loaded_mesh = load_surf_mesh(mesh_like) assert isinstance(loaded_mesh, Mesh) assert_array_equal(mesh_like.coordinates, loaded_mesh.coordinates) assert_array_equal(mesh_like.faces, loaded_mesh.faces)
def test_load_surf_mesh_file_glob(): mesh = generate_surf() fname1 = tempfile.mktemp(suffix='.pial') nb.freesurfer.write_geometry(fname1, mesh[0], mesh[1]) fname2 = tempfile.mktemp(suffix='.pial') nb.freesurfer.write_geometry(fname2, mesh[0], mesh[1]) assert_raises_regex(ValueError, 'More than one file matching path', load_surf_mesh, os.path.join(os.path.dirname(fname1), "*.pial")) assert_raises_regex(ValueError, 'No files matching path', load_surf_mesh, os.path.join(os.path.dirname(fname1), "*.unlikelysuffix")) assert_equal(len(load_surf_mesh(fname1)), 2) assert_array_almost_equal(load_surf_mesh(fname1)[0], mesh[0]) assert_array_almost_equal(load_surf_mesh(fname1)[1], mesh[1]) os.remove(fname1) os.remove(fname2)
def test_load_surf_mesh_file_glob(): mesh = generate_surf() fname1 = tempfile.mktemp(suffix='.pial') nb.freesurfer.write_geometry(fname1, mesh[0], mesh[1]) fname2 = tempfile.mktemp(suffix='.pial') nb.freesurfer.write_geometry(fname2, mesh[0], mesh[1]) assert_raises_regex(ValueError, 'More than one file matching path', load_surf_mesh, os.path.join(os.path.dirname(fname1), "*.pial")) assert_raises_regex(ValueError, 'No files matching path', load_surf_mesh, os.path.join(os.path.dirname(fname1), "*.unlikelysuffix")) assert_equal(len(load_surf_mesh(fname1)), 2) assert_array_almost_equal(load_surf_mesh(fname1)[0], mesh[0]) assert_array_almost_equal(load_surf_mesh(fname1)[1], mesh[1]) os.remove(fname1) os.remove(fname2)
def test_get_vertexcolor(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_left']) surf_map = np.arange(len(mesh[0])) colors = html_surface.colorscale('jet', surf_map, 10) vertexcolors = html_surface._get_vertexcolor( surf_map, colors['cmap'], colors['norm'], colors['abs_threshold'], fsaverage['sulc_left']) assert len(vertexcolors) == len(mesh[0]) vertexcolors = html_surface._get_vertexcolor( surf_map, colors['cmap'], colors['norm'], colors['abs_threshold']) assert len(vertexcolors) == len(mesh[0])
def test_get_vertexcolor(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_left']) surf_map = np.arange(len(mesh[0])) colors = html_surface.colorscale('jet', surf_map, 10) vertexcolors = html_surface._get_vertexcolor( surf_map, colors['cmap'], colors['norm'], colors['abs_threshold'], fsaverage['sulc_left']) assert len(vertexcolors) == len(mesh[0]) vertexcolors = html_surface._get_vertexcolor( surf_map, colors['cmap'], colors['norm'], colors['abs_threshold']) assert len(vertexcolors) == len(mesh[0])
def to_plotly(mesh): mesh = surface.load_surf_mesh(mesh) x, y, z = map(_encode, np.asarray(mesh[0].T, dtype='<f4')) i, j, k = map(_encode, np.asarray(mesh[1].T, dtype='<i4')) info = { "_x": x, "_y": y, "_z": z, "_i": i, "_j": j, "_k": k, } return info
def test_fill_html_template(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_right']) surf_map = mesh[0][:, 0] img = _get_img() info = html_surface.one_mesh_info( surf_map, fsaverage['pial_right'], '90%', black_bg=True, bg_map=fsaverage['sulc_right']) html = html_surface._fill_html_template(info, embed_js=False) check_html(html) assert "jquery.min.js" in html.html info = html_surface.full_brain_info(img) html = html_surface._fill_html_template(info) check_html(html) assert "* plotly.js (gl3d - minified) v1.38.3" in html.html
def test_fill_html_template(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_right']) surf_map = mesh[0][:, 0] img = _get_img() info = html_surface.one_mesh_info( surf_map, fsaverage['pial_right'], '90%', black_bg=True, bg_map=fsaverage['sulc_right']) html = html_surface._fill_html_template(info, embed_js=False) check_html(html) assert "jquery.min.js" in html.html info = html_surface.full_brain_info(img) html = html_surface._fill_html_template(info) check_html(html) assert "* plotly.js (gl3d - minified) v1.38.3" in html.html
def plot_on_surf(data, sides=['left', 'right'], selected=False, threshold=None, inflate=1.001, **kwargs): """ Plot a numpy array of data on the corresponding fsaverage surface. The kwargs are passed to mlab.triangular_mesh """ actors = dict() for side in sides: actors[side] = list() mesh = surface.load_surf_mesh(fsaverage['infl_%s' % side]) shift = -42 if side == 'left' else 42 surf = mlab.triangular_mesh(inflate * mesh[0][:, 0] + shift, inflate * mesh[0][:, 1], inflate * mesh[0][:, 2], mesh[1], scalars=data, **kwargs, ) surf.module_manager.source.filter.splitting = False # Avoid openGL bugs with backfaces surf.actor.property.backface_culling = True actors[side].append(surf) if threshold is not None: surf.enable_contours = True surf.contour.auto_contours = False surf.contour.contours = [threshold, data.max()] surf.contour.filled_contours = True # A trick exploiting a bug in Z-ordering to highlight the # contour surf.actor.property.opacity = .5 # Add a second surface to fill the contours if selected: dark_color = tuple(.3 * c for c in kwargs['color']) else: dark_color = tuple(.5 * c for c in kwargs['color']) surf2 = mlab.pipeline.contour_surface(surf, color=dark_color, line_width=8 if selected else 2, ) # opacity=.5) # surf2.enable_contours = True surf2.contour.auto_contours = False surf2.contour.contours = [threshold, data.max()] actors[side].append(surf2) return actors
def plot_surf(mesh, data, view="right", threshold="85%", output_file=None): coords, triangles = surface.load_surf_mesh(mesh) x, y, z = coords.T i, j, k = triangles.T colors = colorscale(cold_hot, data, threshold) vertexcolor = _get_vertexcolor( data, colors["cmap"], colors["norm"], colors["abs_threshold"], surface.load_surf_data(fsaverage["sulc_right"]), ) mesh_3d = go.Mesh3d(x=x, y=y, z=z, i=i, j=j, k=k, vertexcolor=vertexcolor) fig = go.Figure(data=[mesh_3d]) fig.update_layout(scene_camera=CAMERAS[view], **LAYOUT) if output_file is not None: fig.write_image(output_file) return fig
def test_view_surf(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_right']) surf_map = mesh[0][:, 0] html = html_surface.view_surf(fsaverage['pial_right'], surf_map, fsaverage['sulc_right'], '90%') check_html(html) html = html_surface.view_surf(fsaverage['pial_right'], surf_map, fsaverage['sulc_right'], .3) check_html(html) html = html_surface.view_surf(fsaverage['pial_right']) check_html(html) destrieux = datasets.fetch_atlas_surf_destrieux()['map_left'] html = html_surface.view_surf( fsaverage['pial_left'], destrieux, symmetric_cmap=False) check_html(html) assert_raises(ValueError, html_surface.view_surf, mesh, mesh[0][::2, 0]) assert_raises(ValueError, html_surface.view_surf, mesh, mesh[0][:, 0], bg_map=mesh[0][::2, 0])
def test_one_mesh_info(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_right']) surf_map = mesh[0][:, 0] info = html_surface.one_mesh_info( surf_map, fsaverage['pial_right'], '90%', black_bg=True, bg_map=fsaverage['sulc_right']) assert {'_x', '_y', '_z', '_i', '_j', '_k'}.issubset( info['inflated_left'].keys()) assert len(decode( info['inflated_left']['_x'], '<f4')) == len(surf_map) assert len(info['vertexcolor_left']) == len(surf_map) cmax = np.max(np.abs(surf_map)) assert (info['cmin'], info['cmax']) == (-cmax, cmax) assert type(info['cmax']) == float json.dumps(info) assert info['black_bg'] assert not info['full_brain_mesh'] check_colors(info['colorscale'])
def test_one_mesh_info(): fsaverage = fetch_surf_fsaverage() mesh = surface.load_surf_mesh(fsaverage['pial_right']) surf_map = mesh[0][:, 0] info = html_surface.one_mesh_info( surf_map, fsaverage['pial_right'], '90%', black_bg=True, bg_map=fsaverage['sulc_right']) assert {'_x', '_y', '_z', '_i', '_j', '_k'}.issubset( info['inflated_left'].keys()) assert len(decode( info['inflated_left']['_x'], '<f4')) == len(surf_map) assert len(info['vertexcolor_left']) == len(surf_map) cmax = np.max(np.abs(surf_map)) assert (info['cmin'], info['cmax']) == (-cmax, cmax) assert type(info['cmax']) == float json.dumps(info) assert info['black_bg'] assert not info['full_brain_mesh'] check_colors(info['colorscale'])
def test_plot_surf_avg_method(): mesh = generate_surf() rng = np.random.RandomState(42) # Plot with avg_method ## Test all built-in methods and check mapp = rng.standard_normal(size=mesh[0].shape[0]) mesh_ = load_surf_mesh(mesh) coords, faces = mesh_[0], mesh_[1] for method in ['mean', 'median', 'min', 'max']: display = plot_surf(mesh, surf_map=mapp, avg_method=method, engine='matplotlib') if method == 'mean': agg_faces = np.mean(mapp[faces], axis=1) elif method == 'median': agg_faces = np.median(mapp[faces], axis=1) elif method == 'min': agg_faces = np.min(mapp[faces], axis=1) elif method == 'max': agg_faces = np.max(mapp[faces], axis=1) vmin = np.min(agg_faces) vmax = np.max(agg_faces) agg_faces -= vmin agg_faces /= (vmax - vmin) cmap = plt.cm.get_cmap(plt.rcParamsDefault['image.cmap']) assert_array_equal( cmap(agg_faces), display._axstack.as_list()[0].collections[0]._facecolors) ## Try custom avg_method def custom_avg_function(vertices): return vertices[0] * vertices[1] * vertices[2] plot_surf( mesh, surf_map=rng.standard_normal(size=mesh[0].shape[0]), avg_method=custom_avg_function, engine='matplotlib', ) # Save execution time and memory plt.close()
def test_full_brain_info(): surfaces = datasets.fetch_surf_fsaverage() img = _get_img() info = html_surface.full_brain_info(img, surfaces) check_colors(info['colorscale']) assert {'pial_left', 'pial_right', 'inflated_left', 'inflated_right', 'vertexcolor_left', 'vertexcolor_right'}.issubset(info.keys()) assert info['cmin'] == - info['cmax'] assert info['full_brain_mesh'] assert not info['black_bg'] assert type(info['cmax']) == float json.dumps(info) for hemi in ['left', 'right']: mesh = surface.load_surf_mesh(surfaces['pial_{}'.format(hemi)]) assert len(info['vertexcolor_{}'.format(hemi)]) == len(mesh[0]) assert len(decode( info['inflated_{}'.format(hemi)]['_z'], '<f4')) == len(mesh[0]) assert len(decode( info['pial_{}'.format(hemi)]['_j'], '<i4')) == len(mesh[1])
def clean_surface_map(maps, hemi, cluster_size): """Clean surface maps by removing small connected components""" from nilearn.surface import load_surf_mesh if os.path.exists('/neurospin/ibc'): dir_ = '/neurospin/ibc/derivatives/sub-01/ses-00/anat/fsaverage/surf' else: dir_ = '/storage/store/data/ibc/derivatives/sub-01/ses-00/anat/' + \ 'fsaverage/surf' if hemi == 'right': mesh = os.path.join(dir_, 'rh.inflated') else: mesh = os.path.join(dir_, 'lh.inflated') _, faces = load_surf_mesh(mesh) connectivity = faces_2_connectivity(faces) for i in range(maps.shape[1]): maps[:, i] = connected_components_cleaning(connectivity, maps[:, i], cluster_size=cluster_size) return maps
def test_full_brain_info(): fsaverage = fetch_surf_fsaverage() img = _get_img() info = html_surface.full_brain_info(img) check_colors(info['colorscale']) assert {'pial_left', 'pial_right', 'inflated_left', 'inflated_right', 'vertexcolor_left', 'vertexcolor_right'}.issubset(info.keys()) assert info['cmin'] == - info['cmax'] assert info['full_brain_mesh'] assert not info['black_bg'] assert type(info['cmax']) == float json.dumps(info) for hemi in ['left', 'right']: mesh = surface.load_surf_mesh(fsaverage['pial_{}'.format(hemi)]) assert len(info['vertexcolor_{}'.format(hemi)]) == len(mesh[0]) assert len(decode( info['inflated_{}'.format(hemi)]['_z'], '<f4')) == len(mesh[0]) assert len(decode( info['pial_{}'.format(hemi)]['_j'], '<i4')) == len(mesh[1])
def test_load_surf_mesh_file_gii(tmp_path): # Test the loader `load_surf_mesh` # If nibabel is of older version we skip tests as nibabel does not # support intent argument and intent codes are not handled properly with # older versions if not LooseVersion(nb.__version__) >= LooseVersion('2.1.0'): raise pytest.skip('Nibabel version too old to handle intent codes') mesh = generate_surf() # test if correct gii is loaded into correct list fd_mesh, filename_gii_mesh = tempfile.mkstemp(suffix='.gii', dir=str(tmp_path)) os.close(fd_mesh) coord_array = gifti.GiftiDataArray(data=mesh[0], intent=nb.nifti1.intent_codes[ 'NIFTI_INTENT_POINTSET']) face_array = gifti.GiftiDataArray(data=mesh[1], intent=nb.nifti1.intent_codes[ 'NIFTI_INTENT_TRIANGLE']) gii = gifti.GiftiImage(darrays=[coord_array, face_array]) gifti.write(gii, filename_gii_mesh) assert_array_equal(load_surf_mesh(filename_gii_mesh)[0], mesh[0]) assert_array_equal(load_surf_mesh(filename_gii_mesh)[1], mesh[1]) os.remove(filename_gii_mesh) # test if incorrect gii raises error fd_no, filename_gii_mesh_no_point = tempfile.mkstemp(suffix='.gii', dir=str(tmp_path)) os.close(fd_no) gifti.write(gifti.GiftiImage(darrays=[face_array, face_array]), filename_gii_mesh_no_point) with pytest.raises(ValueError, match='NIFTI_INTENT_POINTSET'): load_surf_mesh(filename_gii_mesh_no_point) os.remove(filename_gii_mesh_no_point) fd_face, filename_gii_mesh_no_face = tempfile.mkstemp(suffix='.gii', dir=str(tmp_path)) os.close(fd_face) gifti.write(gifti.GiftiImage(darrays=[coord_array, coord_array]), filename_gii_mesh_no_face) with pytest.raises(ValueError, match='NIFTI_INTENT_TRIANGLE'): load_surf_mesh(filename_gii_mesh_no_face) os.remove(filename_gii_mesh_no_face)
def surface(): """ Returns 3D surface coordinates. Returns ------- fsaverage : Dictionary-like (from the Nilearn documentation) The interest attributes are : - 'pial_left': Gifti file, left hemisphere pial surface mesh - 'pial_right': Gifti file, right hemisphere pial surface mesh - 'infl_left': Gifti file, left hemisphere inflated pial surface mesh - 'infl_right': Gifti file, right hemisphere inflated pial surface mesh - 'sulc_left': Gifti file, left hemisphere sulcal depth data - 'sulc_right': Gifti file, right hemisphere sulcal depth data surf : Dictionary-like Object containing the x, y, z coordinates as well as the i, j, k triangulation coordinates """ """ Get surface for plotting. :return fsaverage: surface locations as in nilearn :return surf: surface for plotting """ fsaverage = fetch_surf_fsaverage('fsaverage') surf = {} for key in [ t + '_' + h for t in ['pial', 'infl'] for h in ['left', 'right'] ]: surf = load_surf_mesh(fsaverage[key]) x, y, z = np.asarray(surf[0].T, dtype='<f4') i, j, k = np.asarray(surf[1].T, dtype='<i4') surf[key] = dict(x=x, y=y, z=z, i=i, j=j, k=k) return fsaverage, surf
def to_three(mesh, stat_map, sample_mesh=None): if sample_mesh is None: sample_mesh = mesh mesh = surface.load_surf_mesh(mesh) coords = mesh[0][mesh[1].ravel()] surf_stat_map = surface.vol_to_surf(stat_map, sample_mesh) surf_stat_map -= surf_stat_map.min() surf_stat_map /= surf_stat_map.max() colors = cm.cold_hot(surf_stat_map[mesh[1].ravel()])[:, :3] center = list(map(float, mesh[0].mean(axis=0))) center = {'x': center[0], 'y': center[1], 'z': center[2]} vertices = np.asarray(coords.ravel(), dtype='<f4') # vertices = list(map(float, coords.ravel())) col = list(map(float, colors.ravel())) return { 'INSERT_VERTICES_HERE': base64.b64encode( vertices.tobytes()).decode('utf-8'), #json.dumps(vertices), 'INSERT_COLORS_HERE': json.dumps(col), 'INSERT_CENTER_POSITION_HERE': json.dumps(center) }
def test_load_surf_mesh_file_glob(tmp_path): mesh = generate_surf() fd1, fname1 = tempfile.mkstemp(suffix='.pial', dir=str(tmp_path)) os.close(fd1) nb.freesurfer.write_geometry(fname1, mesh[0], mesh[1]) fd2, fname2 = tempfile.mkstemp(suffix='.pial', dir=str(tmp_path)) os.close(fd2) nb.freesurfer.write_geometry(fname2, mesh[0], mesh[1]) with pytest.raises(ValueError, match='More than one file matching path'): load_surf_mesh(os.path.join(os.path.dirname(fname1), "*.pial")) with pytest.raises(ValueError, match='No files matching path'): load_surf_mesh(os.path.join(os.path.dirname(fname1), "*.unlikelysuffix") ) assert len(load_surf_mesh(fname1)) == 2 assert_array_almost_equal(load_surf_mesh(fname1)[0], mesh[0]) assert_array_almost_equal(load_surf_mesh(fname1)[1], mesh[1]) os.remove(fname1) os.remove(fname2)
def test_load_surf_mesh_file_gii(tmp_path): # Test the loader `load_surf_mesh` mesh = generate_surf() # test if correct gii is loaded into correct list fd_mesh, filename_gii_mesh = tempfile.mkstemp(suffix='.gii', dir=str(tmp_path)) os.close(fd_mesh) coord_array = gifti.GiftiDataArray(data=mesh[0], intent=nb.nifti1.intent_codes[ 'NIFTI_INTENT_POINTSET']) face_array = gifti.GiftiDataArray(data=mesh[1], intent=nb.nifti1.intent_codes[ 'NIFTI_INTENT_TRIANGLE']) gii = gifti.GiftiImage(darrays=[coord_array, face_array]) gifti.write(gii, filename_gii_mesh) assert_array_equal(load_surf_mesh(filename_gii_mesh)[0], mesh[0]) assert_array_equal(load_surf_mesh(filename_gii_mesh)[1], mesh[1]) os.remove(filename_gii_mesh) # test if incorrect gii raises error fd_no, filename_gii_mesh_no_point = tempfile.mkstemp(suffix='.gii', dir=str(tmp_path)) os.close(fd_no) gifti.write(gifti.GiftiImage(darrays=[face_array, face_array]), filename_gii_mesh_no_point) with pytest.raises(ValueError, match='NIFTI_INTENT_POINTSET'): load_surf_mesh(filename_gii_mesh_no_point) os.remove(filename_gii_mesh_no_point) fd_face, filename_gii_mesh_no_face = tempfile.mkstemp(suffix='.gii', dir=str(tmp_path)) os.close(fd_face) gifti.write(gifti.GiftiImage(darrays=[coord_array, coord_array]), filename_gii_mesh_no_face) with pytest.raises(ValueError, match='NIFTI_INTENT_TRIANGLE'): load_surf_mesh(filename_gii_mesh_no_face) os.remove(filename_gii_mesh_no_face)
# Display connectome from surface parcellation # # The following code extracts 3D coordinates of surface parcels (a.k.a. labels # in the Freesurfer naming convention). To do so we load the pial surface # of fsaverage subject, get the vertices contained in each parcel and compute # the mean location to obtain the coordinates. import numpy as np from nilearn import surface atlas = destrieux_atlas coordinates = [] labels = destrieux_atlas['labels'] for hemi in ['left', 'right']: vert = destrieux_atlas['map_%s' % hemi] rr, _ = surface.load_surf_mesh(fsaverage['pial_%s' % hemi]) for k, label in enumerate(labels): if "Unknown" not in str(label): # Omit the Unknown label. # Compute mean location of vertices in label of index k coordinates.append(np.mean(rr[vert == k], axis=0)) coordinates = np.array(coordinates) # 3D coordinates of parcels # We now make a synthetic connectivity matrix that connects labels # between left and right hemispheres. n_parcels = len(coordinates) corr = np.zeros((n_parcels, n_parcels)) n_parcels_hemi = n_parcels // 2 corr[np.arange(n_parcels_hemi), np.arange(n_parcels_hemi) + n_parcels_hemi] = 1 corr = corr + corr.T
def test_load_surf_mesh_list(): # test if correct list is returned mesh = generate_surf() assert len(load_surf_mesh(mesh)) == 2 assert_array_equal(load_surf_mesh(mesh)[0], mesh[0]) assert_array_equal(load_surf_mesh(mesh)[1], mesh[1]) # test if incorrect list, array or dict raises error with pytest.raises(ValueError, match='it must have two elements'): load_surf_mesh([]) with pytest.raises(ValueError, match='it must have two elements'): load_surf_mesh([mesh[0]]) with pytest.raises(ValueError, match='it must have two elements'): load_surf_mesh([mesh[0], mesh[1], mesh[1]]) with pytest.raises(ValueError, match='input type is not recognized'): load_surf_mesh(mesh[0]) with pytest.raises(ValueError, match='input type is not recognized'): load_surf_mesh(dict()) del mesh