Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
linewidths=2.5)
if 'transform' not in self._reporting_data:
return [init_display]
else: # if resampling was performed
self._report_description = (self._report_description +
self._overlay_text)
# create display of resampled NiftiImage and mask
# assuming that resampl_img has same dim as img
resampl_img, resampl_mask = self._reporting_data['transform']
if resampl_img is not None:
if len(dim) == 4:
# compute middle image from 4D series for plotting
resampl_img = image.index_img(resampl_img, dim[-1] // 2)
else: # images were not provided to fit
resampl_img = resampl_mask
final_display = plotting.plot_img(resampl_img,
black_bg=False,
cmap='CMRmap_r')
final_display.add_contours(resampl_mask, levels=[.5],
colors='g', linewidths=2.5)
return [init_display, final_display]
# Restrict to face and house conditions
conditions = behavioral['labels']
condition_mask = np.logical_or(conditions == b"face",
conditions == b"house")
# Split data into train and test samples, using the chunks
condition_mask_train = np.logical_and(condition_mask, behavioral['chunks'] <= 6)
condition_mask_test = np.logical_and(condition_mask, behavioral['chunks'] > 6)
# Apply this sample mask to X (fMRI data) and y (behavioral labels)
# Because the data is in one single large 4D image, we need to use
# index_img to do the split easily
from nilearn.image import index_img
func_filenames = data_files.func[0]
X_train = index_img(func_filenames, condition_mask_train)
X_test = index_img(func_filenames, condition_mask_test)
y_train = conditions[condition_mask_train]
y_test = conditions[condition_mask_test]
# Compute the mean epi to be used for the background of the plotting
from nilearn.image import mean_img
background_img = mean_img(func_filenames)
##############################################################################
# Fit SpaceNet with a Graph-Net penalty
from nilearn.decoding import SpaceNetClassifier
# Fit model on train data and predict on test data
decoder = SpaceNetClassifier(memory="nilearn_cache", penalty='graph-net')
decoder.fit(X_train, y_train)
y_pred = decoder.predict(X_test)
accuracy = (y_pred == y_test).mean() * 100.
"""
import os
from pynets.core import utils
from nilearn.masking import intersect_masks
from nilearn.image import index_img, math_img, resample_img
mask_name = os.path.basename(self.clust_mask).split('.nii')[0]
self.atlas = "%s%s%s%s%s" % (mask_name, '_', self.clust_type, '_k', str(self.k))
print("%s%s%s%s%s%s%s" % ('\nCreating atlas using ', self.clust_type, ' at cluster level ', str(self.k),
' for ', str(self.atlas), '...\n'))
self._dir_path = utils.do_dir_path(self.atlas, self.func_file)
self.uatlas = "%s%s%s%s%s%s%s%s" % (self._dir_path, '/', mask_name, '_clust-', self.clust_type, '_k',
str(self.k), '.nii.gz')
# Load clustering mask
self._func_img.set_data_dtype(np.float32)
func_vol_img = index_img(self._func_img, 1)
func_vol_img.set_data_dtype(np.uint16)
clust_mask_res_img = resample_img(nib.load(self.clust_mask), target_affine=func_vol_img.affine,
target_shape=func_vol_img.shape, interpolation='nearest')
clust_mask_res_img.set_data_dtype(np.uint16)
func_data = np.asarray(func_vol_img.dataobj).astype('float32')
func_int_thr = np.round(np.mean(func_data[func_data > 0]) - np.std(func_data[func_data > 0]) * num_std_dev, 3)
if self.mask is not None:
self._mask_img = nib.load(self.mask)
self._mask_img.set_data_dtype(np.uint16)
mask_res_img = resample_img(self._mask_img, target_affine=func_vol_img.affine,
target_shape=func_vol_img.shape, interpolation='nearest')
mask_res_img.set_data_dtype(np.uint16)
self._clust_mask_corr_img = intersect_masks([math_img('img > ' + str(func_int_thr), img=func_vol_img),
math_img('img > 0.01', img=clust_mask_res_img),
math_img('img > 0.01', img=mask_res_img)],
threshold=1, connected=False)
if in_file is a list of files, return an arbitrary file from
the list, and an arbitrary volume from that file
"""
in_file = filemanip.filename_to_list(in_file)[0]
try:
in_file = nb.load(in_file)
except AttributeError:
in_file = in_file
if len(in_file.shape) == 3:
return in_file
return nlimage.index_img(in_file, 0)
# Showing region extraction results using 4D maps visualization tool
plotting.plot_prob_atlas(regions_img, display_mode='z', cut_coords=1,
view_type='contours', title="Regions extracted.")
# To reduce the complexity, we choose to display all the regions
# extracted from network 3
import numpy as np
DMN_network = index_img(atlas_networks, 3)
plotting.plot_roi(DMN_network, display_mode='z', cut_coords=1,
title='Network 3')
regions_indices_network3 = np.where(np.array(extraction.index_) == 3)
for index in regions_indices_network3[0]:
cur_img = index_img(extraction.regions_img_, index)
coords = find_xyz_cut_coords(cur_img)
plotting.plot_roi(cur_img, display_mode='z', cut_coords=coords[2:3],
title="Blob of network3")
plotting.show()
copy=True,
sample_mask=None):
# If we have a string (filename), we won't need to copy, as
# there will be no side effect
if isinstance(imgs, _basestring):
copy = False
if verbose > 0:
class_name = enclosing_scope_name(stack_level=2)
mask_img_ = _utils.check_niimg_3d(mask_img_)
imgs = _utils.check_niimg(imgs, atleast_4d=True)
if sample_mask is not None:
imgs = image.index_img(imgs, sample_mask)
# Resampling: allows the user to change the affine, the shape or both
if verbose > 1:
print("[%s] Resampling" % class_name)
# Check whether resampling is truly necessary. If so, crop mask
# as small as possible in order to speed up the process
if not _check_same_fov(imgs, mask_img_):
# now we can crop
mask_img_ = image.crop_img(mask_img_, copy=False)
imgs = cache(image.resample_img, memory, func_memory_level=2,
memory_level=memory_level, ignore=['copy'])(
imgs,
target_affine=mask_img_.get_affine(),
target_shape=mask_img_.shape,
maskdata = nib.load(mask_filename).get_data()
# get the size of the data
nx, ny, nz = maskdata.shape
# labels of seven ategories
categories = ["face", "cat", "house", "chair", "shoe", "bottle", "scissors"]
# numbe of conidtions: 7
ncon = len(categories)
# get fmri data under 7 conditions
# here we average the data under different conditions
fmri_data = np.full([ncon, nx, ny, nz], np.nan)
for i in range(ncon):
img = mean_img(index_img(func_filename, labels.isin([categories[i]])))
fmri_data[i] = datamask(img.get_data(), maskdata)
# get fmri data under 'face'-condition
face_img = nib.Nifti1Image(fmri_data[0], affine=img.affine)
# have a look
plotting.plot_epi(face_img)
plotting.show()
# reshaoe the data: [ncon, nx, ny, nz] -> [ncon, nsubs, nx, ny, nz]
# here just one subject's data
fmri_data = np.reshape(fmri_data, [ncon, 1, nx, ny, nz])
"""********** Section 3: Calculating the neural pattern similarity (for ROI) **********"""
# Now invert the masking operation, going back to a full 3D
# representation
component_img = masker.inverse_transform(components_masked)
#####################################################################
# Visualize the results
# Show some interesting components
from nilearn import image
from nilearn.plotting import plot_stat_map, show
# Use the mean as a background
mean_img = image.mean_img(func_filename)
plot_stat_map(image.index_img(component_img, 0), mean_img)
plot_stat_map(image.index_img(component_img, 1), mean_img)
show()
# Decomposition estimator embeds their own masker
masker = dict_fact.masker_
components_img = masker.inverse_transform(dict_fact.components_)
components_img.to_filename(join(trace_folder, 'components.nii.gz'))
time = time.time() - t0
print('[Example] Run in %.2f s' % time)
# Show components from both methods using 4D plotting tools
import matplotlib.pyplot as plt
from nilearn.plotting import plot_prob_atlas, plot_stat_map, show
from nilearn.image import index_img
print('[Example] Displaying')
fig, axes = plt.subplots(2, 1)
plot_prob_atlas(components_img, view_type="filled_contours",
axes=axes[0])
plot_stat_map(index_img(components_img, 0),
axes=axes[1],
colorbar=False,
threshold=0)
plt.savefig(join(trace_folder, 'components.pdf'))
show()