def image_search(args=None): parser = _get_parser() args = parser.parse_args(args=args) img = args.query_img if img is None: img = datasets.fetch_neurovault_motor_task()["images"][0] try: image_name = Path(img).name except Exception: image_name = "Image" search = NeuroQueryImageSearch() results = search(img, n_studies=args.n_studies, n_terms=args.n_terms, transform=args.transform, rescale_similarities=(not args.no_rescaling)) if args.output is None: results_to_html(results, image_name).open_in_browser() print("Displaying results in web browser") print("Use '--output' to write results in a file") return output_file = Path(args.output) print(f"Saving results in {output_file}") if output_file.suffix in [".html", ".htm"]: results_to_html(results, image_name).save_as_html(output_file) return results.pop("image") output_file.write_text(json.dumps(results, cls=_JSONEncoder))
def test_create_output(tmpdir): # create mock data motor_images = fetch_neurovault_motor_task() stat_img = motor_images.images[0] stat_img_name = os.path.basename(stat_img)[:-7] # temporary output output_dir = tmpdir.mkdir('mni_test') atlas_reader.create_output(stat_img, atlas=['Harvard_Oxford'], outDir=output_dir) # test if output exists and if the key .csv and .png files were created assert os.path.exists(output_dir) assert len(os.listdir(output_dir)) > 0 assert os.path.isfile( os.path.join(output_dir, '{}.csv'.format(stat_img_name))) assert os.path.isfile( os.path.join(output_dir, '{}.png'.format(stat_img_name)))
""" ############################################################################### # First, we retrieve data from nilearn provided (general-purpose) datasets # ------------------------------------------------------------------------- from nilearn import datasets # haxby dataset to have anatomical image, EPI images and masks haxby_dataset = datasets.fetch_haxby() haxby_anat_filename = haxby_dataset.anat[0] haxby_mask_filename = haxby_dataset.mask_vt[0] haxby_func_filename = haxby_dataset.func[0] # localizer dataset to have contrast maps motor_images = datasets.fetch_neurovault_motor_task() stat_img = motor_images.images[0] ############################################################################### # Now, we show from here how to visualize the retrieved datasets using plotting # tools from nilearn. from nilearn import plotting ############################################################################### # Visualizing in - 'sagittal', 'coronal' and 'axial' with given coordinates # ------------------------------------------------------------------------- # # The first argument ``stat_img`` is a path to the filename of a contrast map. # The optional argument ``display_mode`` is given as a string 'ortho' to # visualize the map in three specific directions xyz. Because of this, the
# Statistical maps # ================ ###################################################################### # Download and plot an individual-level statistical map and plot it on the # subject's T1 image: from nilearn import datasets, plotting localizer = datasets.fetch_localizer_button_task() plotting.view_img(localizer['tmap'], bg_img=localizer['anat'], threshold='97%') ###################################################################### # Download and plot a group-level statistical map: img = datasets.fetch_neurovault_motor_task()['images'][0] plotting.view_img(img, threshold='95%') ###################################################################### # More about dataset downloaders: https://nilearn.github.io/modules/reference.html#module-nilearn.datasets # # More about plotting: https://nilearn.github.io/plotting/index.html ###################################################################### # Static plots that can be saved in a variety of formats: plotting.plot_stat_map(img, threshold=3) ######################################################################
=============================== The goal of this example is to illustrate the use of the function :func:`nilearn.image.resample_to_img` to resample an image to a template. We use the MNI152 template as the reference for resampling a t-map image. Function :func:`nilearn.image.resample_img` could also be used to achieve this. """ ############################################################################### # First we load the required datasets using the nilearn datasets module. from nilearn.datasets import fetch_neurovault_motor_task from nilearn.datasets import load_mni152_template template = load_mni152_template() motor_images = fetch_neurovault_motor_task() stat_img = motor_images.images[0] ############################################################################### # Now, the localizer t-map image can be resampled to the MNI template image. from nilearn.image import resample_to_img resampled_stat_img = resample_to_img(stat_img, template) ############################################################################### # Let's check the shape and affine have been correctly updated. # First load the original t-map in memory: from nilearn.image import load_img tmap_img = load_img(stat_img)
import os import numpy as np from atlasreader import atlasreader import nibabel as nb from nilearn.datasets import fetch_neurovault_motor_task import pytest import pandas as pd STAT_IMG = fetch_neurovault_motor_task().images[0] EXAMPLE_COORDS = dict(affine=np.array([[1, 0, 0, -90], [0, 1, 0, -150], [0, 0, 1, -80], [0, 0, 0, 1]]), coords=[ dict(ijk=[0, 0, 0], xyz=np.array([[-90, -150, -80]])), dict(ijk=[[10, 10, 10], [100, 50, 100]], xyz=np.array([[-80, -140, -70], [10, -100, 20]])), dict(ijk=[[54, 32, 20], [82, 205, 38], [32, 51, 82]], xyz=np.array([[-36, -118, -60], [-8, 55, -42], [-58, -99, 2]])) ], bad_coords=[ dict(ijk_in=np.array([80, 80, 80]), ijk_out=np.array([80, 80, 80])), dict(ijk_in=np.array([-1, 0, 0]), ijk_out=np.array([0, 0, 0])), dict(ijk_in=np.array([80, 80, 100]), ijk_out=np.array([0, 0, 0])) ], bounding_shape=np.array([90, 90, 90])) EXPECTED_TABLES = dict(cluster=np.array([[42, -25, 58, 6.66003, 36936],
############################################################################### # Retrieve the data # ------------------ # # Nilearn comes with set of functions that download public data from Internet # # Let us first see where the data will be downloded and stored on our disk: # from nilearn import datasets print('Datasets shipped with nilearn are stored in: %r' % datasets.get_data_dirs()) ############################################################################### # Let us now retrieve a motor task contrast map # corresponding to a group one-sample t-test motor_images = datasets.fetch_neurovault_motor_task() stat_img = motor_images.images[0] # stat_img is just the name of the file that we downloded print(stat_img) ############################################################################### # Demo glass brain plotting # -------------------------- from nilearn import plotting # Whole brain sagittal cuts and map is thresholded at 3 plotting.plot_glass_brain(stat_img, threshold=3) ############################################################################### # With a colorbar
def __init__(self, indice=0): from nilearn import datasets motor_images = datasets.fetch_neurovault_motor_task() self.dataset = motor_images.images[indice]
} 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 if __name__ == "__main__": img = datasets.fetch_neurovault_motor_task()["images"][0] fsaverage = datasets.fetch_surf_fsaverage() mesh = fsaverage["pial_right"] data = surface.vol_to_surf(img, fsaverage["pial_right"]) fig = plot_surf(mesh, data, output_file="/tmp/surface_plot.png") fig.show()