def plot_activation_by_ID(identifier): localizer_dataset = datasets.fetch_localizer_contrasts( [identifier], n_subjects=2, get_tmaps=True) localizer_tmap_filename = localizer_dataset.tmaps[1] plotting.plot_glass_brain(localizer_tmap_filename,threshold=3)
2. A permuted Ordinary Least Squares algorithm is run at each voxel. Data
smoothed at 5 voxels FWHM are used.
"""
# Author: Virgile Fritsch, <*****@*****.**>, May. 2014
import numpy as np
from scipy import linalg
import matplotlib.pyplot as plt
from nilearn import datasets
from nilearn.input_data import NiftiMasker
from nilearn.mass_univariate import permuted_ols
### Load Localizer contrast ###################################################
n_samples = 94
localizer_dataset = datasets.fetch_localizer_contrasts(
['left button press (auditory cue)'], n_subjects=n_samples)
tested_var = localizer_dataset.ext_vars['pseudo']
# Quality check / Remove subjects with bad tested variate
mask_quality_check = np.where(tested_var != 'None')[0]
n_samples = mask_quality_check.size
contrast_map_filenames = [localizer_dataset.cmaps[i]
for i in mask_quality_check]
tested_var = tested_var[mask_quality_check].astype(float).reshape((-1, 1))
print("Actual number of subjects after quality check: %d" % n_samples)
### Mask data #################################################################
nifti_masker = NiftiMasker(
smoothing_fwhm=5,
memory='nilearn_cache', memory_level=1) # cache options
fmri_masked = nifti_masker.fit_transform(contrast_map_filenames)
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_localizer_contrasts
from nilearn.datasets import load_mni152_template
template = load_mni152_template()
localizer_dataset = fetch_localizer_contrasts(["left vs right button press"],
n_subjects=1,
get_anats=True,
get_tmaps=True)
localizer_tmap_filename = localizer_dataset.tmaps[0]
localizer_anat_filename = localizer_dataset.anats[0]
###############################################################################
# Now, the localizer t-map image can be resampled to the MNI template image.
from nilearn.image import resample_to_img
resampled_localizer_tmap = resample_to_img(localizer_tmap_filename, template)
###############################################################################
# Let's check the shape and affine have been correctly updated.
from nilearn.image import index_img
expected to elicit activity in the motor cortex (positive in the right
hemisphere, negative in the left hemisphere).
"""
#########################################################################
# Fetch dataset
# --------------
# We download a list of left vs right button press :term:`contrasts<contrast>`
# from a localizer dataset. Note that we fetch individual t-maps that represent
# the :term:`Bold<BOLD>` activity estimate divided by the uncertainty about this
# estimate.
from nilearn.datasets import fetch_localizer_contrasts
n_subjects = 16
data = fetch_localizer_contrasts(["left vs right button press"],
n_subjects,
get_tmaps=True)
###########################################################################
# Display subject t_maps
# ----------------------
# We plot a grid with all the subjects t-maps thresholded at t = 2 for simple
# visualization purposes. The button press effect is visible among all
# subjects.
from nilearn import plotting
import matplotlib.pyplot as plt
subjects = [subject_data[0] for subject_data in data['ext_vars']]
fig, axes = plt.subplots(nrows=4, ncols=4)
for cidx, tmap in enumerate(data['tmaps']):
plotting.plot_glass_brain(tmap,
colorbar=False,
'auditory processing vs visual processing',
'auditory&visual calculation vs sentences',
'sentence reading vs checkerboard']
nifti_masker = NiftiMasker('mask_GM_forFunc.nii')
grp_mask = load(nifti_masker.mask).get_data()
affine = load(nifti_masker.mask).get_affine()
# Create the data matrix
n_contrasts, n_subjects = len(contrasts), 40
subjects = ['S%02d' % i for i in range(n_subjects)]
n_voxels = grp_mask.sum()
X = np.zeros((n_voxels, n_contrasts, n_subjects))
for nc, contrast in enumerate(contrasts):
imgs = datasets.fetch_localizer_contrasts(
[contrast], n_subjects=n_subjects)['cmaps']
X[:, nc, :] = nifti_masker.fit_transform(imgs).T
# improve the mask
second_mask = (X == 0).sum(1).sum(1) < 100
grp_mask[grp_mask > 0] = second_mask
X = X[second_mask]
# write directory
write_dir = os.path.join(os.getcwd(), 'results')
if not os.path.exists(write_dir):
os.mkdir(write_dir)
###############################################################################
# what shall we do in the present experiment ?
1. A sequence of subject fMRI button press contrasts is downloaded.
2. a mask of the useful brain volume is computed
3. A one-sample t-test is applied to the brain maps
We focus on a given contrast of the localizer dataset: the motor response to left versus right button press. Both at the ndividual and group level, this is expected to elicit activity in the motor cortex (positive in the right hemisphere, negative in the left hemisphere).
"""
#########################################################################
# Fetch dataset
# --------------
# We download a list of left vs right button press contrasts from a
# localizer dataset. Note that we fetc individual t-maps that represent the Bold activity estimate divided by the uncertainty about this estimate.
from nilearn.datasets import fetch_localizer_contrasts
n_subjects = 16
data = fetch_localizer_contrasts(["left vs right button press"], n_subjects,
get_tmaps=True)
###########################################################################
# Display subject t_maps
# ----------------------
# We plot a grid with all the subjects t-maps thresholded at t = 2 for
# simple visualization purposes. The button press effect is visible among
# all subjects
from nilearn import plotting
import matplotlib.pyplot as plt
subjects = [subject_data[0] for subject_data in data['ext_vars']]
fig, axes = plt.subplots(nrows=4, ncols=4)
for cidx, tmap in enumerate(data['tmaps']):
plotting.plot_glass_brain(tmap, colorbar=False, threshold=2.0,
title=subjects[cidx],
axes=axes[int(cidx / 4), int(cidx % 4)],
smoothed at 5 voxels FWHM are used.
"""
# Author: Virgile Fritsch, <*****@*****.**>, May. 2014
import numpy as np
import matplotlib.pyplot as plt
from nilearn import datasets
from nilearn.input_data import NiftiMasker
from nilearn.mass_univariate import permuted_ols
from nilearn.image import get_data
##############################################################################
# Load Localizer contrast
n_samples = 94
localizer_dataset = datasets.fetch_localizer_contrasts(
['left button press (auditory cue)'], n_subjects=n_samples)
# print basic information on the dataset
print('First contrast nifti image (3D) is located at: %s' %
localizer_dataset.cmaps[0])
tested_var = localizer_dataset.ext_vars['pseudo']
# Quality check / Remove subjects with bad tested variate
mask_quality_check = np.where(tested_var != b'n/a')[0]
n_samples = mask_quality_check.size
contrast_map_filenames = [
localizer_dataset.cmaps[i] for i in mask_quality_check
]
tested_var = tested_var[mask_quality_check].astype(float).reshape((-1, 1))
print("Actual number of subjects after quality check: %d" % n_samples)
"""
# Author: Virgile Fritsch, <*****@*****.**>, Mar. 2014
import numpy as np
from nilearn import datasets
from scipy import linalg
from nilearn.input_data import NiftiMasker
from nilearn.mass_univariate import permuted_ols
from nilearn_sandbox.mass_univariate.rpbi import randomized_parcellation_based_inference
### Load Localizer motor contrast #############################################
n_samples = 20
# localizer_dataset = datasets.fetch_localizer_calculation_task(
# n_subjects=n_samples)
localizer_dataset = datasets.fetch_localizer_contrasts(
["calculation vs sentences"],
n_subjects=n_samples)
### Mask data #################################################################
nifti_masker = NiftiMasker(
memory='nilearn_cache', memory_level=1) # cache options
fmri_masked = nifti_masker.fit_transform(localizer_dataset.cmaps)
### Perform massively univariate analysis with permuted OLS ###################
tested_var = np.ones((n_samples, 1), dtype=float) # intercept
neg_log_pvals, all_scores, h0 = permuted_ols(
tested_var, fmri_masked, model_intercept=False,
n_perm=5000, # 5,000 for the sake of time. 10,000 is recommended
two_sided_test=False, # RPBI does not perform a two-sided test
n_jobs=1) # can be changed to use more CPUs
neg_log_pvals_unmasked = nifti_masker.inverse_transform(
visual areas. At the group level, such a mapping is not possible. Yet,
we may observe some significant effects in these areas.
"""
import pandas as pd
from nilearn import plotting
from nilearn.datasets import fetch_localizer_contrasts
#########################################################################
# Fetch dataset
# --------------
# We download a list of left vs right button press contrasts from a
# localizer dataset.
n_subjects = 16
sample_vertical = fetch_localizer_contrasts(
["vertical checkerboard"], n_subjects, get_tmaps=True)
sample_horizontal = fetch_localizer_contrasts(
["horizontal checkerboard"], n_subjects, get_tmaps=True)
# What remains implicit here is that there is a one-to-one
# correspondence between the two samples: the first image of both
# samples comes from subject S1, the second from subject S2 etc.
############################################################################
# Estimate second level model
# ---------------------------
# We define the input maps and the design matrix for the second level model
# and fit it.
second_level_input = sample_vertical['cmaps'] + sample_horizontal['cmaps']
############################################################################
def test_fetch_localizer_contrasts():
local_url = "file://" + datadir
ids = np.asarray([('S%2d' % i).encode() for i in range(94)])
ids = ids.view(dtype=[('subject_id', 'S3')])
file_mock.add_csv('cubicwebexport.csv', ids)
file_mock.add_csv('cubicwebexport2.csv', ids)
# Disabled: cannot be tested without actually fetching covariates CSV file
# All subjects
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.tmaps is None)
assert_true(dataset.masks is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.cmaps), 94)
# 20 subjects
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
n_subjects=20,
data_dir=tmpdir,
url=local_url,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.tmaps is None)
assert_true(dataset.masks is None)
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_equal(len(dataset.cmaps), 20)
assert_equal(dataset.ext_vars.size, 20)
# Multiple contrasts
dataset = datasets.fetch_localizer_contrasts(
["checkerboard", "horizontal checkerboard"],
n_subjects=20,
data_dir=tmpdir,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.tmaps is None)
assert_true(dataset.masks is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_equal(len(dataset.cmaps), 20 * 2) # two contrasts are fetched
assert_equal(dataset.ext_vars.size, 20)
# get_anats=True
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
get_anats=True,
verbose=0)
assert_true(dataset.masks is None)
assert_true(dataset.tmaps is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.anats[0], _basestring))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.anats), 94)
assert_equal(len(dataset.cmaps), 94)
# get_masks=True
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
get_masks=True,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.tmaps is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_true(isinstance(dataset.masks[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.cmaps), 94)
assert_equal(len(dataset.masks), 94)
# get_tmaps=True
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
get_tmaps=True,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.masks is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_true(isinstance(dataset.tmaps[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.cmaps), 94)
assert_equal(len(dataset.tmaps), 94)
# all get_*=True
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
get_anats=True,
get_masks=True,
get_tmaps=True,
verbose=0)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.anats[0], _basestring))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_true(isinstance(dataset.masks[0], _basestring))
assert_true(isinstance(dataset.tmaps[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.anats), 94)
assert_equal(len(dataset.cmaps), 94)
assert_equal(len(dataset.masks), 94)
assert_equal(len(dataset.tmaps), 94)
'auditory&visual calculation vs sentences',
'sentence reading vs checkerboard'
]
nifti_masker = NiftiMasker('mask_GM_forFunc.nii')
grp_mask = load(nifti_masker.mask).get_data()
affine = load(nifti_masker.mask).get_affine()
# Create the data matrix
n_contrasts, n_subjects = len(contrasts), 40
subjects = ['S%02d' % i for i in range(n_subjects)]
n_voxels = grp_mask.sum()
X = np.zeros((n_voxels, n_contrasts, n_subjects))
for nc, contrast in enumerate(contrasts):
imgs = datasets.fetch_localizer_contrasts([contrast],
n_subjects=n_subjects)['cmaps']
X[:, nc, :] = nifti_masker.fit_transform(imgs).T
# improve the mask
second_mask = (X == 0).sum(1).sum(1) < 100
grp_mask[grp_mask > 0] = second_mask
X = X[second_mask]
# write directory
write_dir = os.path.join(os.getcwd(), 'results')
if not os.path.exists(write_dir):
os.mkdir(write_dir)
###############################################################################
# what shall we do in the present experiment ?
"horizontal checkerboard", "vertical checkerboard", 'sentence listening',
"sentence reading", "calculation (auditory cue)",
"calculation (visual cue)", "left button press (auditory cue)",
"left button press (visual cue)", "right button press (auditory cue)",
"right button press (visual cue)"
]
test_set = ['left button press (auditory cue)']
ref = [contrast for contrast in contrasts if contrast not in test_set]
n_ref = len(ref)
nifti_masker = NiftiMasker('mask_GM_forFunc.nii')
affine = load(nifti_masker.mask).get_affine()
# fetch the data
ref_imgs = datasets.fetch_localizer_contrasts(ref).cmaps
n_subjects = len(ref_imgs) / n_ref
# Create a population mask
one_contrast = [img for img in ref_imgs if 'horizontal' in img]
mask_ = compute_multi_background_mask(one_contrast)
mask_image = intersect_masks(['mask_GM_forFunc.nii', mask_])
mask = mask_image.get_data()
n_voxels = mask.sum()
save(mask_image, '/tmp/mask.nii')
nifti_masker = NiftiMasker(mask_image)
# write directory
write_dir = op.join(getcwd(), 'results')
if not op.exists(write_dir):
mkdir(write_dir)
that it conveys more sensitivity.
"""
# Author: Virgile Fritsch, <*****@*****.**>, Mar. 2014
import numpy as np
from nilearn import datasets
from scipy import linalg
from nilearn.input_data import NiftiMasker
from nilearn.mass_univariate import permuted_ols
from nilearn_sandbox.mass_univariate.rpbi import randomized_parcellation_based_inference
### Load Localizer motor contrast #############################################
n_samples = 20
# localizer_dataset = datasets.fetch_localizer_calculation_task(
# n_subjects=n_samples)
localizer_dataset = datasets.fetch_localizer_contrasts(
["calculation vs sentences"], n_subjects=n_samples)
### Mask data #################################################################
nifti_masker = NiftiMasker(memory='nilearn_cache',
memory_level=1) # cache options
fmri_masked = nifti_masker.fit_transform(localizer_dataset.cmaps)
### Perform massively univariate analysis with permuted OLS ###################
tested_var = np.ones((n_samples, 1), dtype=float) # intercept
neg_log_pvals, all_scores, h0 = permuted_ols(
tested_var,
fmri_masked,
model_intercept=False,
n_perm=5000, # 5,000 for the sake of time. 10,000 is recommended
two_sided_test=False, # RPBI does not perform a two-sided test
n_jobs=1) # can be changed to use more CPUs
We use localizer t-statistic maps from :func:`nilearn.datasets.fetch_localizer_contrasts`
as an input image.
The idea is to threshold an image to get foreground objects using a
function :func:`nilearn.image.threshold_img` and extract objects using a function
:func:`nilearn.regions.connected_regions`.
"""
################################################################################
# Fetching t-statistic image of localizer constrasts by loading from datasets
# utilities
from nilearn import datasets
n_subjects = 3
localizer_path = datasets.fetch_localizer_contrasts(
['calculation (auditory cue)'], n_subjects=n_subjects, get_tmaps=True)
tmap_filename = localizer_path.tmaps[0]
################################################################################
# Threshold the t-statistic image by importing threshold function
from nilearn.image import threshold_img
# Two types of strategies can be used from this threshold function
# Type 1: strategy used will be based on scoreatpercentile
threshold_percentile_img = threshold_img(tmap_filename, threshold='97%')
# Type 2: threshold strategy used will be based on image intensity
# Here, threshold value should be within the limits i.e. less than max value.
threshold_value_img = threshold_img(tmap_filename, threshold=4.)
def test_fetch_localizer_contrasts():
local_url = "file://" + datadir
ids = np.asarray([('S%2d' % i).encode() for i in range(94)])
ids = ids.view(dtype=[('subject_id', 'S3')])
file_mock.add_csv('cubicwebexport.csv', ids)
file_mock.add_csv('cubicwebexport2.csv', ids)
# Disabled: cannot be tested without actually fetching covariates CSV file
# All subjects
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.tmaps is None)
assert_true(dataset.masks is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.cmaps), 94)
# 20 subjects
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
n_subjects=20,
data_dir=tmpdir,
url=local_url,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.tmaps is None)
assert_true(dataset.masks is None)
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_equal(len(dataset.cmaps), 20)
assert_equal(dataset.ext_vars.size, 20)
# Multiple contrasts
dataset = datasets.fetch_localizer_contrasts(
["checkerboard", "horizontal checkerboard"],
n_subjects=20, data_dir=tmpdir,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.tmaps is None)
assert_true(dataset.masks is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_equal(len(dataset.cmaps), 20 * 2) # two contrasts are fetched
assert_equal(dataset.ext_vars.size, 20)
# get_anats=True
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
get_anats=True,
verbose=0)
assert_true(dataset.masks is None)
assert_true(dataset.tmaps is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.anats[0], _basestring))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.anats), 94)
assert_equal(len(dataset.cmaps), 94)
# get_masks=True
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
get_masks=True,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.tmaps is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_true(isinstance(dataset.masks[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.cmaps), 94)
assert_equal(len(dataset.masks), 94)
# get_tmaps=True
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
get_tmaps=True,
verbose=0)
assert_true(dataset.anats is None)
assert_true(dataset.masks is None)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_true(isinstance(dataset.tmaps[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.cmaps), 94)
assert_equal(len(dataset.tmaps), 94)
# all get_*=True
dataset = datasets.fetch_localizer_contrasts(["checkerboard"],
data_dir=tmpdir,
url=local_url,
get_anats=True,
get_masks=True,
get_tmaps=True,
verbose=0)
assert_true(isinstance(dataset.ext_vars, np.recarray))
assert_true(isinstance(dataset.anats[0], _basestring))
assert_true(isinstance(dataset.cmaps[0], _basestring))
assert_true(isinstance(dataset.masks[0], _basestring))
assert_true(isinstance(dataset.tmaps[0], _basestring))
assert_equal(dataset.ext_vars.size, 94)
assert_equal(len(dataset.anats), 94)
assert_equal(len(dataset.cmaps), 94)
assert_equal(len(dataset.masks), 94)
assert_equal(len(dataset.tmaps), 94)
print("Done")
np.save(str(maps_file), term_maps)
######################################################################
# Obtain some example brain maps
# ------------------------------
# We load example subject-level tmaps from a localizer dataset, and also
# generate a brain maps from a set of MNI coordinates.
queries = {}
contrasts = ["left vs right button press", "sentence listening"]
for contrast in contrasts:
query_map = fetch_localizer_contrasts([contrast],
n_subjects=1,
get_tmaps=True)["tmaps"][0]
queries[contrast] = query_map
dmn_coords = [(0, -52, 18), (-46, -68, 32), (46, -68, 32), (1, 50, -5)]
dmn_img = gaussian_coord_smoothing(dmn_coords, encoder.get_masker())
masked_dmn = encoder.get_masker().transform(dmn_img).ravel()
queries["DMN coordinates"] = dmn_img
######################################################################
# Discover which terms have activations similar to the query map
# --------------------------------------------------------------
# Here we simply use the dot product with the absolute values of the input map
for name, query_map in queries.items():
masked_query = encoder.get_masker().transform(query_map).ravel()
we may observe some significant effects in these areas.
"""
import pandas as pd
from nilearn import plotting
from nilearn.datasets import fetch_localizer_contrasts
#########################################################################
# Fetch dataset
# --------------
# We download a list of left vs right button press contrasts from a
# localizer dataset.
n_subjects = 16
sample_vertical = fetch_localizer_contrasts(["vertical checkerboard"],
n_subjects,
get_tmaps=True)
sample_horizontal = fetch_localizer_contrasts(["horizontal checkerboard"],
n_subjects,
get_tmaps=True)
# What remains implicit here is that there is a one-to-one
# correspondence between the two samples: the first image of both
# samples comes from subject S1, the second from subject S2 etc.
############################################################################
# Estimate second level model
# ---------------------------
# We define the input maps and the design matrix for the second level model
# and fit it.
second_level_input = sample_vertical['cmaps'] + sample_horizontal['cmaps']
# Source: python notebook: [Massively univariate analysis of a motor task from the Localizer dataset](https://nilearn.github.io/auto_examples/05_advanced/plot_localizer_mass_univariate_methods.html#sphx-glr-auto-examples-05-advanced-plot-localizer-mass-univariate-methods-py)
# ---------------
# setup
# ---------------
import numpy as np
from nilearn import datasets
from nilearn.input_data import NiftiMasker
from nilearn.image import get_data
# ---------------
# load data
# ---------------
n_samples = 16
localizer_dataset_left = datasets.fetch_localizer_contrasts(
["left visual click"], n_subjects=n_samples)
localizer_dataset_right = datasets.fetch_localizer_contrasts(
["right visual click"], n_subjects=n_samples)
# ---------------
# quality control
# ---------------
tested_var_left = localizer_dataset_left.ext_vars['pseudo']
# Quality check / Remove subjects with bad tested variate
mask_quality_check_left = np.where(tested_var_left != b'n/a')[0]
n_samples_left = mask_quality_check_left.size
contrast_map_filenames_left = [
localizer_dataset_left.cmaps[i] for i in mask_quality_check_left
]
'auditory&visual calculation vs sentences',
'sentence reading vs checkerboard']
nifti_masker = NiftiMasker('mask_GM_forFunc.nii')
grp_mask = load(nifti_masker.mask_img).get_data()
affine = load(nifti_masker.mask_img).get_affine()
# Create the data matrix
n_contrasts, n_subjects = len(contrasts), 40
subjects = ['S%02d' % i for i in range(n_subjects)]
n_voxels = grp_mask.sum()
X = np.zeros((n_voxels, n_contrasts, n_subjects))
for nc, contrast in enumerate(contrasts):
imgs = datasets.fetch_localizer_contrasts(
[contrast], n_subjects=n_subjects,
data_dir='/tmp/')['cmaps']
X[:, nc, :] = nifti_masker.fit_transform(imgs).T
# improve the mask
second_mask = (X == 0).sum(1).sum(1) < 100
grp_mask[grp_mask > 0] = second_mask
X = X[second_mask]
# write directory
write_dir = os.path.join(os.getcwd(), 'results')
if not os.path.exists(write_dir):
os.mkdir(write_dir)
###############################################################################
from nilearn import datasets
from nilearn import plotting, image
###############################################################################
# Retrieve the data: haxby dataset to have EPI images and masks, and
# localizer dataset to have contrast maps
haxby_dataset = datasets.fetch_haxby(n_subjects=1)
haxby_anat_filename = haxby_dataset.anat[0]
haxby_mask_filename = haxby_dataset.mask_vt[0]
haxby_func_filename = haxby_dataset.func[0]
localizer_dataset = datasets.fetch_localizer_contrasts(
["left vs right button press"],
n_subjects=2,
get_anats=True,
get_tmaps=True)
localizer_anat_filename = localizer_dataset.anats[1]
localizer_cmap_filename = localizer_dataset.cmaps[1]
localizer_tmap_filename = localizer_dataset.tmaps[1]
###############################################################################
# demo the different plotting functions
# Plotting statistical maps
plotting.plot_stat_map(localizer_cmap_filename, bg_img=localizer_anat_filename,
threshold=3, title="plot_stat_map",
cut_coords=(36, -27, 66))
# Plotting glass brain
We use localizer t-statistic maps from :func:`nilearn.datasets.fetch_localizer_contrasts`
as an input image.
The idea is to threshold an image to get foreground objects using a
function :func:`nilearn.image.threshold_img` and extract objects using a function
:func:`nilearn.regions.connected_regions`.
"""
################################################################################
# Fetching t-statistic image of localizer constrasts by loading from datasets
# utilities
from nilearn import datasets
n_subjects = 3
localizer_path = datasets.fetch_localizer_contrasts(
['calculation (auditory cue)'], n_subjects=n_subjects, get_tmaps=True)
tmap_filename = localizer_path.tmaps[0]
################################################################################
# Threshold the t-statistic image by importing threshold function
from nilearn.image import threshold_img
# Two types of strategies can be used from this threshold function
# Type 1: strategy used will be based on scoreatpercentile
threshold_percentile_img = threshold_img(tmap_filename, threshold='97%')
# Type 2: threshold strategy used will be based on image intensity
# Here, threshold value should be within the limits i.e. less than max value.
threshold_value_img = threshold_img(tmap_filename, threshold=4.)
################################################################################
See :ref:`plotting` for more details.
"""
from nilearn import datasets
from nilearn import plotting, image
###############################################################################
# Retrieve the data: haxby dataset to have EPI images and masks, and
# localizer dataset to have contrast maps
haxby_dataset = datasets.fetch_haxby(n_subjects=1)
haxby_anat_filename = haxby_dataset.anat[0]
haxby_mask_filename = haxby_dataset.mask_vt[0]
haxby_func_filename = haxby_dataset.func[0]
localizer_dataset = datasets.fetch_localizer_contrasts(
["left vs right button press"], n_subjects=2, get_anats=True)
localizer_anat_filename = localizer_dataset.anats[1]
localizer_cmap_filename = localizer_dataset.cmaps[1]
###############################################################################
# demo the different 'display_mode' options
plotting.plot_stat_map(localizer_cmap_filename,
display_mode='ortho',
cut_coords=(36, -27, 60),
title="display_mode='ortho', cut_coords=(36, -27, 60)")
plotting.plot_stat_map(localizer_cmap_filename,
display_mode='z',
cut_coords=5,
title="display_mode='z', cut_coords=5")
expected to elicit activity in the motor cortex (positive in the right
hemisphere, negative in the left hemisphere).
"""
#########################################################################
# Fetch dataset
# --------------
# We download a list of left vs right button press :term:`contrasts<contrast>`
# from a localizer dataset. Note that we fetch individual t-maps that represent
# the :term:`Bold<BOLD>` activity estimate divided by the uncertainty about this
# estimate.
from nilearn.datasets import fetch_localizer_contrasts
n_subjects = 16
data = fetch_localizer_contrasts(
["left vs right button press"], n_subjects,
get_tmaps=True, legacy_format=False
)
###########################################################################
# Display subject t_maps
# ----------------------
# We plot a grid with all the subjects t-maps thresholded at t = 2 for simple
# visualization purposes. The button press effect is visible among all
# subjects.
from nilearn import plotting
import matplotlib.pyplot as plt
subjects = [subject_data[0] for subject_data in data['ext_vars']]
fig, axes = plt.subplots(nrows=4, ncols=4)
for cidx, tmap in enumerate(data['tmaps']):
plotting.plot_glass_brain(tmap, colorbar=False, threshold=2.0,
title=subjects[cidx],
"calculation (auditory cue)",
"calculation (visual cue)",
"left button press (auditory cue)",
"left button press (visual cue)",
"right button press (auditory cue)",
"right button press (visual cue)"]
test_set = ['left button press (auditory cue)']
ref = [contrast for contrast in contrasts if contrast not in test_set]
n_ref = len(ref)
nifti_masker = NiftiMasker('mask_GM_forFunc.nii')
affine = load(nifti_masker.mask).get_affine()
# fetch the data
ref_imgs = datasets.fetch_localizer_contrasts(ref).cmaps
n_subjects = len(ref_imgs) / n_ref
# Create a population mask
one_contrast = [img for img in ref_imgs if 'horizontal' in img]
mask_ = compute_multi_background_mask(one_contrast)
mask_image = intersect_masks(['mask_GM_forFunc.nii', mask_])
mask = mask_image.get_data()
n_voxels = mask.sum()
save(mask_image, '/tmp/mask.nii')
nifti_masker = NiftiMasker(mask_image)
# write directory
write_dir = op.join(getcwd(), 'results')
if not op.exists(write_dir):
mkdir(write_dir)
