def test_img_to_signals_labels_non_float_type(target_dtype):
fake_fmri_data = np.random.RandomState(0).rand(10, 10, 10, 10) > 0.5
fake_affine = np.eye(4, 4).astype(np.float64)
fake_fmri_img_orig = nibabel.Nifti1Image(
fake_fmri_data.astype(np.float64),
fake_affine,
)
fake_fmri_img_target_dtype = new_img_like(
fake_fmri_img_orig, fake_fmri_data.astype(target_dtype))
fake_mask_data = np.ones((10, 10, 10), dtype=np.uint8)
fake_mask = nibabel.Nifti1Image(fake_mask_data, fake_affine)
masker = NiftiLabelsMasker(fake_mask)
masker.fit()
timeseries_int = masker.transform(fake_fmri_img_target_dtype)
timeseries_float = masker.transform(fake_fmri_img_orig)
assert np.sum(timeseries_int) != 0
assert np.allclose(timeseries_int, timeseries_float)
#save for future usage
label_atlas_nii.to_filename(roiLabel)
#load saved labels
# label_atlas_nii= nib.load(roiLabel)
masker = NiftiLabelsMasker(labels_img=label_atlas_nii, standardize=True,
memory='nilearn_cache', verbose=0)
masker.fit()
corr_mat_vect_list = []
ind_list = []
for i_rs_img, rs_img in enumerate(rs_niis):
print('%i/%i: %s' % (i_rs_img + 1, len(rs_niis), rs_img))
rs_reg_ts = masker.transform(rs_img)
corr_mat = np.corrcoef(rs_reg_ts.T)
triu_inds = np.triu_indices(corr_mat.shape[0], 1)
corr_mat_vect = corr_mat[triu_inds]
# save for later
corr_mat_vect_list.append(corr_mat_vect)
corr_mat_vect_array = np.array(corr_mat_vect_list)
print(corr_mat_vect_array.shape)
#demean
corr_mat_vect_array[np.isnan(corr_mat_vect_array)] = 1
if (nMasks**2-nMasks)/2 == corr_mat_vect_array.shape[1]:
print corr_mat_vect_array.shape
np.save(crosscorr, corr_mat_vect_array)
else:
##########################################################################
# Fitting the mask and generating a report
masker.fit(func_filename)
# We can again generate a report, but this time, the provided functional
# image is displayed with the ROI of the atlas.
# The report also contains a summary table giving the region sizes in mm3
report = masker.generate_report()
report
###########################################################################
# Process the data with the NiftiLablesMasker
#
# In order to extract the signals, we need to call transform on the
# functional data
signals = masker.transform(func_filename)
# signals is a 2D matrix, (n_time_points x n_regions)
signals.shape
###########################################################################
# Plot the signals
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(15, 5))
ax = fig.add_subplot(111)
for label_idx in range(3):
ax.plot(signals[:, label_idx],
linewidth=2,
label=atlas.labels[label_idx + 1]) # 0 is background
ax.legend(loc=2)
ax.set_title("Signals for first 3 regions")
def roi_average(roi_paths,
rois_parent_folder,
tasks,
df,
selected_contrasts=None,
subject_specific_rois=False,
roi_masks=None):
"""
Function to compute the average and std of z-scores for a set of voxels
inside of subject-specific, functional Regions-of-Interest (ROIs)
in a set of contrast z-maps.
"""
# For every ROI, ...
roi_names = []
all_rois_contrast_avgs = []
all_contrast_names = []
for r, roi_path in enumerate(roi_paths, start=1):
# ROI name
roi_name = re.match('.*' + rois_parent_folder + '/(.*).nii.gz',
roi_path).groups()[0]
roi_names.append(roi_name)
# For every task, ...
roi_contrast_avgs = []
contrast_names = []
for t, task in enumerate(tasks):
# Select the entries in the data frame only concerned to
# the ffx z-maps
task_df = df[df.task == task][df.acquisition == 'ffx']
contrasts = task_df.contrast.unique()
if selected_contrasts is not None:
contrasts = np.intersect1d(selected_contrasts, contrasts)
# For every contrast, ...
for contrast in contrasts:
flatten_list = []
for s, subject in enumerate(SUBJECTS):
img_paths = []
# Create the subject-specific ROI mask
if subject_specific_rois:
if roi_masks is None:
raise ValueError('roi_masks not defined!')
else:
roi = math_img('img == %d' % r, img=roi_masks[s])
print('Extracting subject-specific ' + \
'"%s" as ROI for %s from the contrast "%s".'
%(roi_name, subject, contrast))
else:
roi = roi_path
print('Extracting general ' + \
'"%s" as ROI for %s from the contrast "%s".'
%(roi_name, subject, contrast))
masker = NiftiLabelsMasker(labels_img=roi)
masker.fit()
# Paths of the contrast z-maps of every participants
img_path = task_df[task_df.contrast == contrast]\
[task_df.subject == subject]\
.path.values[-1]
img_paths.append(img_path)
print(img_paths)
# For each participant, extract data from z-map
# according to the subject-specific ROI mask and
# average straight off the values of
# the corresponding voxels
mask_data = masker.transform(img_paths)
flatten_list.extend(mask_data.tolist()[0])
roi_contrast_avgs.append(flatten_list)
# Labels of the contrasts
contrast_names.append(LABELS[contrast][1].values[0] + ' vs. ' +
LABELS[contrast][0].values[0])
# Append for all ROIs
all_rois_contrast_avgs.append(roi_contrast_avgs)
all_contrast_names.append(contrast_names)
return all_rois_contrast_avgs, all_contrast_names, roi_names
from load_confounds import Params24
from nilearn.input_data import NiftiLabelsMasker
import glob
import numpy as np
####################################################################
configfiles = glob.glob('/home/sana4471/projects/rrg-pbellec/sana4471/movie_decoding_sa/data/friends/derivatives/fmriprep-20.1.0/fmriprep/sub-01/**/*preproc_bold.nii.gz', recursive=True)
configfiles=sorted(configfiles)
print('#################### The number of movie segments:')
print(len(configfiles)) #24*2+ 17*2
#####################################################################
fMRI_T=[]
for path in configfiles:
print(path)
masker= NiftiLabelsMasker(labels_img='MIST_444.nii.gz', standardize=True, detrend=False, smoothing_fwhm=8).fit()
Data_fmri=masker.transform(path, confounds=Params24().load(path))
print(Data_fmri.shape)
fMRI_T.append(Data_fmri)
np.save('Sanajoon_fMRI2.npy', fMRI_T)
print('##################### Done!')
###############################################################################
##### Optionally, calculate CT and GMD of each DKT region and output csv. #####
###############################################################################
# If either CT or GMD image was provided, fit DKT labels.
if ct_path or gmd_path:
# Fit DKT labels
masker = NiftiLabelsMasker(dkt_img)
masker.fit()
# If CT image was provided, also output csv of CT values by DKT region.
if ct_path:
# Load cortical thickness image.
ct_img = nib.load(ct_path)
# Get cortical thickness values by DKT region.
ct_values = masker.transform(ct_img)
# Make values list for output df (subjectId, sessionId, + CT values list).
ct_values = sub_ses + ct_values.tolist()[0]
# Combine columns and values into CT dataframe.
ct_df = pd.DataFrame(data=[ct_values], columns=columns)
# Output CT dataframe to csv file.
ct_df.to_csv(f"{outDir}/{sub}_{ses}_CorticalThickness.csv", index=False)
# If CT image was provided, also output csv of GMD values by DKT region.
if gmd_path:
# Load GMD image.
gmd_img = nib.load(gmd_path)
# Get GMD values by DKT region.
gmd_values = masker.transform(gmd_img)
# Make values list for output df (subjectId, sessionId, + gmd values list).
gmd_values = sub_ses + gmd_values.tolist()[0]
# data according to given parameters
masker.fit()
# Preparing for data extraction: setting number of conditions, size, etc from
# haxby dataset
condition_names = haxby_labels.unique()
n_cond_img = fmri_data[..., haxby_labels == 'house'].shape[-1]
n_conds = len(condition_names)
X1, X2 = np.zeros((n_cond_img, n_conds)), np.zeros((n_cond_img, n_conds))
# Gathering data for each condition and then use transformer from masker
# object transform() on each data. The transformer extracts data in condition
# maps where the target regions are specified by labels images
for i, cond in enumerate(condition_names):
cond_maps = new_img_like(
fmri_img, fmri_data[..., haxby_labels == cond][..., :n_cond_img])
mask_data = masker.transform(cond_maps)
X1[:, i], X2[:, i] = mask_data[:, 0], mask_data[:, 1]
condition_names[np.where(condition_names == 'scrambledpix')] = 'scrambled'
##############################################################################
# save the ROI 'atlas' to a Nifti file
new_img_like(fmri_img, labels).to_filename('mask_atlas.nii.gz')
##############################################################################
# Plot the average in the different condition names
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 7))
for i in np.arange(2):
plt.subplot(1, 2, i + 1)
plt.boxplot(X1 if i == 0 else X2)
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=RuntimeWarning)
temp_sum = np.sum(data != 0, axis=a)
# temp_sum [temp_sum==0] = 1
output = np.sum(data, axis=a) / temp_sum
output[np.isnan(output)] = 0
return output
ave_loadings_flat = mean_nonzero(rest_loading, 1)
ave_loadings_mat = np.zeros((14, 14))
ave_loadings_mat[idx] = ave_loadings_flat
ave_loadings_mat = ave_loadings_mat + ave_loadings_mat.T
ave_loadings = mean_nonzero(ave_loadings_mat, 1)
ts_len = masker.transform(rs_niis[0]).shape[0]
for i_rs_img, rs_img in enumerate(rs_niis):
par = '_'.join(rs_img.split(os.sep)[-1].split('_')[0:2])
outputDIR = resultdir + '_new' + os.sep + par
if not os.path.exists(outputDIR):
os.makedirs(outputDIR)
print('%i/%i: %s' % (i_rs_img + 1, len(rs_niis), par))
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=DeprecationWarning)
rs_reg_ts = masker.transform(rs_img)
#weighted TS of the average
cur_all_weightedTS = mean_nonzero(rs_reg_ts * ave_loadings, 1)
cur_all_txtfn = outputDIR + os.sep + '%s_weightedTS_%s_allcomps.txt' % (
par, analysis_name)
np.savetxt(
cur_all_txtfn,
# here it is assumed that your input lesion image is available at # '/tmp/lesion.nii.gz' # change it to any path you like atlas = fetch_atlas_yeo_2011() thick17 = atlas['thick_17'] # optionally display the atlas # plot_roi(thick17) # separate yeo17 atlas into connected components: # 122 connected components overall separate_thick17 = connected_label_regions(thick17) # display the lesion on top of the atlas display = plot_img(lesion) display.add_overlay(thick17, cmap=plt.cm.hsv) # compute the mean of lesion proportion per network masker = NiftiLabelsMasker(labels_img=thick17).fit() network_lesion = masker.transform(lesion) # redo that on a per'region basis display = plot_img(lesion) display.add_overlay(separate_thick17, cmap=plt.cm.hsv) # compute the mean of lesion proportion per network separate_masker = NiftiLabelsMasker(labels_img=separate_thick17).fit() region_lesion = separate_masker.transform(lesion) plt.show()
label_atlas_nii.to_filename(roiLabel)
#load saved labels
# label_atlas_nii= nib.load(roiLabel)
masker = NiftiLabelsMasker(labels_img=label_atlas_nii,
standardize=True,
memory='nilearn_cache',
verbose=0)
masker.fit()
corr_mat_vect_list = []
ind_list = []
for i_rs_img, rs_img in enumerate(rs_niis):
print('%i/%i: %s' % (i_rs_img + 1, len(rs_niis), rs_img))
rs_reg_ts = masker.transform(rs_img)
corr_mat = np.corrcoef(rs_reg_ts.T)
triu_inds = np.triu_indices(corr_mat.shape[0], 1)
corr_mat_vect = corr_mat[triu_inds]
# save for later
corr_mat_vect_list.append(corr_mat_vect)
corr_mat_vect_array = np.array(corr_mat_vect_list)
print(corr_mat_vect_array.shape)
#demean
corr_mat_vect_array[np.isnan(corr_mat_vect_array)] = 1
if (nMasks**2 - nMasks) / 2 == corr_mat_vect_array.shape[1]:
print corr_mat_vect_array.shape
np.save(crosscorr, corr_mat_vect_array)
else:
def mean_nonzero(data, a):
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=RuntimeWarning)
temp_sum = np.sum(data!=0, axis=a)
# temp_sum [temp_sum==0] = 1
output = np.sum(data, axis=a)/temp_sum
output[np.isnan(output)] = 0
return output
ave_loadings_flat = mean_nonzero(rest_loading,1)
ave_loadings_mat = np.zeros((14,14))
ave_loadings_mat[idx] = ave_loadings_flat
ave_loadings_mat = ave_loadings_mat + ave_loadings_mat.T
ave_loadings = mean_nonzero(ave_loadings_mat, 1)
ts_len = masker.transform(rs_niis[0]).shape[0]
for i_rs_img, rs_img in enumerate(rs_niis):
par = '_'.join(rs_img.split(os.sep)[-1].split('_')[0:2])
outputDIR = resultdir + '_new' + os.sep + par
if not os.path.exists(outputDIR):
os.makedirs(outputDIR)
print('%i/%i: %s' %(i_rs_img + 1, len(rs_niis),par))
with warnings.catch_warnings():
warnings.simplefilter("ignore", category=DeprecationWarning)
rs_reg_ts = masker.transform(rs_img)
#weighted TS of the average
cur_all_weightedTS = mean_nonzero(rs_reg_ts*ave_loadings, 1)
cur_all_txtfn = outputDIR + os.sep + '%s_weightedTS_%s_allcomps.txt' %(par, analysis_name)
np.savetxt(cur_all_txtfn, cur_all_weightedTS, fmt='%f',)
for i_comp in range(rest_loading.shape[1]):
cur_loadings = rest_loading[np.where(rest_loading[:,i_comp]!=0),i_comp].flatten()
###################################
### Preprocessing per subject #####
###################################
# extract TS per ROI, preprocess and compute correlation matrix
# loop through 86 subjects
print("Starting the ROI time series extraction")
FS = []
for i_nii, nii_path in enumerate(df.fMRI_path.values):
# each participant has a 4D nii of shape (91, 109, 91, 121)
print("Currently doing sub", i_nii + 1, "/86")
# EXTRACT TIME SERIES PER roi
cur_FS = masker.transform(nii_path)
# standardize the time series
cur_FS = StandardScaler().fit_transform(cur_FS)
# shape (121, 100)
# deconfounding
# upload df with motion parameter values
# confounds = pd.read_excel('C:\\sexualorientproject\\MC_Parameter\\second\\prefiltered_func_data_mcf_{}.xlsx'.format(i_nii+1))
confounds = pd.read_excel('prefiltered_func_data_mcf_{}.xlsx'.format(i_nii+1))
confounds = confounds[confounds.columns[1:]].values
assert confounds.shape == (121, 24)
# deconfounding
cur_FS = clean(signals=cur_FS, confounds=confounds, detrend=False)
# shape (121, 100)
FS.append(cur_FS)
# np.save("C:\\sexualorientproject\\fmri_FS_ss", FS)
n_rois = len(np.unique(rroi_img.get_data())) - 1
# !fslview dbg_roi_labelimg.nii.gz
roi_masker = NiftiLabelsMasker(labels_img=rroi_img,
background_label=0,
standardize=True,
smoothing_fwhm=0,
detrend=True,
low_pass=None,
high_pass=None,
memory='nilearn_cache',
verbose=0)
roi_masker.fit()
# parse the RS images according to the ROIs
sub_FS = roi_masker.transform(rs_4D)
# assert sub_FS.shape == (len(cur_rs_imgs), len(roi_names))
# dump_path = op.join(rs_base, 'roi_dump_' + ROI_DIR)
# np.save(dump_path, arr=sub_FS)
# vectorize
cross_corr = np.corrcoef(sub_FS.T)
tril_inds = np.tril_indices_from(cross_corr, k=-1)
cc_ravel = cross_corr[tril_inds]
# cross_corrs.append(cc_ravel)
cur_FS[i_rs] = cc_ravel
# plt.matshow(cross_corr, cmap=plt.cm.RdBu)
# plt.title(rs_base)
masker.fit()
allsj_ls = []
for sj in os.listdir(func_dir):
sj_dir = os.path.join(func_dir, sj)
sj_ls = []
for f in sorted(os.listdir(sj_dir)):
# read pmod
sj_num = int(f.split('_')[0].split('-')[1])
run_num = int(f.split('_')[2].split('-')[1])
df_pmod = resample_pmod(df, sj_num, run_num)
# read roi
func_file = os.path.join(sj_dir, f)
# print(func_file)
mask_data = masker.transform(func_file)
mask_mean = np.mean(mask_data, 1)
# make df
df_len = min([len(mask_mean), len(df_pmod)])
df_tmp = pd.DataFrame({
'roi_mean': mask_mean[:df_len],
'pmod_mean': df_pmod[:df_len],
'subject': [sj_num] * df_len,
'session': [run_num] * df_len
})
sj_ls.append(df_tmp)
df_sj = pd.concat(sj_ls)
allsj_ls.append(df_sj)
allsj_df = pd.concat(allsj_ls)
fname = mask_img.split('.')[0].split('/')[1] + '.csv'
memory_level=1,
verbose=0,
detrend=True,
standardize=True,
low_pass=0.1,
high_pass=0.01,
t_r=2.5,
resampling_target='labels')
masker.fit()
for suj in range(6):
result_scores[suj] = {}
y, session = data_behaviour(suj)
fmri_filename = haxby.func[suj]
haxby_mni = resample_img(fmri_filename, template.affine, template.shape)
fmri = masker.transform(haxby_mni)
rest_mask = y == b'rest'
condition_mask = np.logical_or(y == b'cat', y == b'face')
rest = fmri[rest_mask]
cond = fmri[condition_mask]
session_label = session[condition_mask]
cv = LeaveOneLabelOut(session_label / 2)
y = y[condition_mask]
y = (y == b'cat')
w_name = 'D:/haxby2001/rest/' + str(suj) + '_w_kalofolias.mat'
for graph_name, param in sorted(graphsname.items()):
if 'method' not in param:
param['method'] = False
if 'spars' not in param:
r_atlas_nii = resample_img(
img=atlas_nii,
target_affine=mask_file.get_affine(),
target_shape=mask_file.shape,
interpolation='nearest'
)
r_atlas_nii.to_filename('debug_ratlas.nii.gz')
from nilearn.input_data import NiftiLabelsMasker
nlm = NiftiLabelsMasker(
labels_img=r_atlas_nii, mask_img=mask_file,
standardize=True, detrend=True)
nlm.fit()
FS_regpool = nlm.transform(all_sub_rs_maps)
np.save('%i_regs_timeseries' % sub_id, FS_regpool)
# compute network sparse inverse covariance
from sklearn.covariance import GraphLassoCV
from nilearn.image import index_img
from nilearn import plotting
try:
gsc_nets = GraphLassoCV(verbose=2, alphas=20)
gsc_nets.fit(FS_regpool)
np.save('%i_regs_cov' % sub_id, gsc_nets.covariance_)
np.save('%i_regs_prec' % sub_id, gsc_nets.precision_)
except:
pass
def reduce(dataset, output_dir=None, direct=False, source='hcp_rs_concat'):
"""Create a reduced version of a given dataset.
Unmask must be called beforehand"""
memory = Memory(cachedir=get_cache_dirs()[0], verbose=2)
print('Fetch data')
this_dataset_dir = join(get_output_dir(output_dir), 'unmasked', dataset)
masker, X = get_raw_contrast_data(this_dataset_dir)
print('Retrieve components')
if source == 'craddock':
components = fetch_craddock_parcellation().parcellate400
niimgs = masker.inverse_transform(X.values)
label_masker = NiftiLabelsMasker(labels_img=components,
smoothing_fwhm=0,
mask_img=masker.mask_img_).fit()
# components = label_masker.inverse_transform(np.eye(400))
print('Transform and fit data')
Xt = label_masker.transform(niimgs)
else:
if source == 'msdl':
components = [fetch_atlas_msdl()['maps']]
else:
data = fetch_atlas_modl()
if source == 'hcp_rs':
components_imgs = [data.nips2017_components256]
elif source == 'hcp_rs_concat':
components_imgs = [
data.nips2017_components16, data.nips2017_components64,
data.nips2017_components256
]
elif source == 'hcp_336':
components_imgs = [data.nips2017_components336]
elif source == 'hcp_new':
components_imgs = [
data.positive_new_components16,
data.positive_new_components64,
data.positive_new_components128
]
elif source == 'hcp_new_big':
components_imgs = [
data.positive_new_components16,
data.positive_new_components64,
data.positive_new_components512
]
elif source == 'hcp_rs_positive_concat':
components_imgs = [
data.positive_components16, data.positive_components64,
data.positive_components512
]
elif source == 'hcp_new_208':
components_imgs = [data.positive_new_components208]
components = masker.transform(components_imgs)
print('Transform and fit data')
proj, proj_inv, _ = memory.cache(make_projection_matrix)(
components, scale_bases=True)
if direct:
proj = proj_inv.T
Xt = X.dot(proj)
Xt = pd.DataFrame(data=Xt, index=X.index)
this_source = source
if direct:
this_source += '_direct'
this_output_dir = join(get_output_dir(output_dir), 'reduced', this_source,
dataset)
if not os.path.exists(this_output_dir):
os.makedirs(this_output_dir)
print(join(this_output_dir, 'Xt.pkl'))
Xt.to_pickle(join(this_output_dir, 'Xt.pkl'))
dump(masker, join(this_output_dir, 'masker.pkl'))
np.save(join(output_dir, 'components'), components)
# Prepare masker & Correct affine
template = load_mni152_template()
basc = datasets.fetch_atlas_basc_multiscale_2015(version='sym')['scale444']
orig_filename='F:/sim/template/restbaseline.nii.gz'
orig_img= image.load_img(orig_filename)
brainmask = load_mni152_brain_mask()
mem = Memory('nilearn_cache')
masker = NiftiLabelsMasker(labels_img = basc, mask_img = brainmask,
memory=mem, memory_level=1, verbose=0,
detrend=False, standardize=False,
high_pass=0.01,t_r=2,
resampling_target='labels')
masker.fit()
# Prep Classification
for s in np.arange(84,89):#range(suj):#
for n in range(meas):
sim_filename='F:/sim/sim_'+str(s+1)+'_'+ str(n+1)+ '.nii.gz'
if os.path.exists(sim_filename):
sim_img = image.load_img(sim_filename)
sim=sim_img.get_data()
data_sim=Nifti1Image(sim,orig_img.affine)
roi = masker.transform(data_sim)
save_name= 'F:/sim/mni/roi_mni_'+str(s+1)+'_'+str(n+1)+'.npz'
np.savez_compressed(save_name,roi=roi)
rest=roi[rest_mask]
sio.savemat('F:/sim/rest/sim_'+str(s+1)+'_'+ str(n+1)+'_rest.mat', {'rest':rest})
ratlas_nii = resample_img(
atlas.maps, target_affine=tmp_nii.affine, interpolation='nearest')
# ratlas_nii.to_filename('debug_ratlas.nii.gz')
# extracting data MRI
FS = []
for i_nii, nii_path in enumerate(df_RLS.data_path.values):
print(nii_path)
nii = nib.load(nii_path)
cur_ratlas_nii = resample_img(
atlas.maps, target_affine=nii.affine, interpolation='nearest')
nii_fake4D = nib.Nifti1Image(
nii.get_data()[:, :, :, None], affine=nii.affine)
masker = NiftiLabelsMasker(labels_img=ratlas_nii)
masker.fit()
cur_FS = masker.transform(nii_fake4D)
FS.append(cur_FS)
FS = np.array(FS).squeeze()
assert len(df_RLS.data_path.values) == len(FS)
ssFS = StandardScaler().fit_transform(FS)
np.random.seed(42)
# data brain
pca_brain = PCA(n_components=10).fit(ssFS)
Y_ss_brain_pca = pca_brain.transform(ssFS)
#############################
####### CCA Analysis ########
#############################
# data according to given parameters
masker.fit()
# Preparing for data extraction: setting number of conditions, size, etc from
# haxby dataset
condition_names = haxby_labels.unique()
n_cond_img = fmri_data[..., haxby_labels == 'house'].shape[-1]
n_conds = len(condition_names)
X1, X2 = np.zeros((n_cond_img, n_conds)), np.zeros((n_cond_img, n_conds))
# Gathering data for each condition and then use transformer from masker
# object transform() on each data. The transformer extracts data in condition
# maps where the target regions are specified by labels images
for i, cond in enumerate(condition_names):
cond_maps = new_img_like(
fmri_img, fmri_data[..., haxby_labels == cond][..., :n_cond_img])
mask_data = masker.transform(cond_maps)
X1[:, i], X2[:, i] = mask_data[:, 0], mask_data[:, 1]
condition_names[np.where(condition_names == 'scrambledpix')] = 'scrambled'
##############################################################################
# save the ROI 'atlas' to a Nifti file
new_img_like(fmri_img, labels).to_filename('mask_atlas.nii.gz')
##############################################################################
# Plot the average in the different condition names
import matplotlib.pyplot as plt
plt.figure(figsize=(15, 7))
for i in np.arange(2):
plt.subplot(1, 2, i + 1)
plt.boxplot(X1 if i == 0 else X2)
pipeline='cpac',
band_pass_filtering=True,
global_signal_regression=True,
derivatives=['func_preproc'],
quality_checked=True,
DX_GROUP=1,
SITE_ID=S)
print(len(abidedata_func_normal['func_preproc']))
print(len(abidedata_func_autism['func_preproc']))
## Extaction of time series for normal
abide_ts = []
abide_ts_normal = []
for i in range(len(abidedata_func_normal['func_preproc'])):
ts_nor = glassermasker.transform(
imgs=abidedata_func_normal['func_preproc'][i])
ts_normal = ts_nor[:, ind_reord]
abide_ts_normal.append(ts_normal)
abide_ts.append(ts_normal)
## Extaction of time series for autism
abide_ts_autism = []
for i in range(len(abidedata_func_autism['func_preproc'])):
ts_aut = glassermasker.transform(
imgs=abidedata_func_autism['func_preproc'][i])
ts_autism = ts_aut[:, ind_reord]
abide_ts_autism.append(ts_autism)
abide_ts.append(ts_autism)
print(len(abide_ts))
