def check_mask(epi_data):
"""
Create the data mask and check that the volume is reasonable
Parameters
----------
data: string: path of some input data
returns
-------
mask_array: array of shape nibabel.load(data).get_shape(),
the binary mask
"""
mask_array = compute_mask_files(epi_data[0])
affine = nibabel.load(epi_data[0]).get_affine()
vol = np.abs(np.linalg.det(affine)) * mask_array.sum() / 1000
print 'The estimated brain volume is: %f cm^3, should be 1000< <2000' % vol
return mask_array
def load_vol_bold_and_mask(bold_files, mask_file):
from pyhrf.tools._io import read_volume, discard_bad_data
# Handle mask
if not op.exists(mask_file):
logger.warning('Mask file %s does not exist. Mask is '
'computed from BOLD ...', mask_file)
bold_file = 'subj0_bold_session0.nii.gz'
# HACK
if bold_files[0] == pyhrf.get_data_file_name(bold_file):
max_frac = .99999 # be sure to keep non zero voxels
connect_component = False # default BOLD vol has 2 ROIs
else:
max_frac = .9
connect_component = True
compute_mask_files(bold_files[0], mask_file, False, .4,
max_frac, cc=connect_component)
mask_loaded_from_file = False
else:
mask_loaded_from_file = True
logger.info('Assuming orientation for mask file: ' +
string.join(MRI3Daxes, ','))
logger.info('Read mask from: %s', mask_file)
mask, mask_meta_obj = read_volume(mask_file)
if not np.allclose(np.round(mask), mask):
raise Exception("Mask is not n-ary (%s)" % mask_file)
mask = np.round(mask).astype(np.int32)
logger.info('Mask has shape %s\nMask min value: %d\n'
'Mask max value: %d\nMask has %d parcels',
str(mask.shape), mask.min(), mask.max(), len(np.unique(mask)))
if mask.min() == -1:
mask += 1
# Load BOLD:
last_scan = 0
session_scans = []
bolds = []
logger.info('Assuming orientation for BOLD files: ' +
string.join(MRI4Daxes, ','))
if type(bold_files[0]) is list:
bold_files = bold_files[0]
for bold_file in bold_files:
if not op.exists(bold_file):
raise Exception('File not found: ' + bold_file)
bold, _ = read_volume(bold_file)
bolds.append(bold)
session_scans.append(np.arange(last_scan,
last_scan + bold.shape[TIME_AXIS],
dtype=int))
last_scan += bold.shape[TIME_AXIS]
bold = np.concatenate(tuple(bolds), axis=TIME_AXIS)
logger.info('BOLD has shape %s', str(bold.shape))
discard_bad_data(bold, mask)
return mask, mask_meta_obj, mask_loaded_from_file, bold, session_scans
drift_model=drift_model, hfcut=hfcut)
ax = design_matrix.show()
ax.set_position([.05, .25, .9, .65])
ax.set_title('Design matrix')
pylab.savefig(op.join(swd, 'design_matrix.png'))
# design_matrix.write_csv(...)
########################################
# Mask the data
########################################
print 'Computing a brain mask...'
mask_path = op.join(swd, 'mask.nii')
mask_array = compute_mask_files( data_path, mask_path, False, 0.4, 0.9)
#########################################
# Specify the contrasts
#########################################
# simplest ones
contrasts = {}
contrast_id = conditions
for i in range(len(conditions)):
contrasts['%s' % conditions[i]]= np.eye(len(design_matrix.names))[2 * i]
# and more complex/ interesting ones
contrasts["audio"] = contrasts["clicDaudio"] + contrasts["clicGaudio"] +\
contrasts["calculaudio"] + contrasts["phraseaudio"]
contrasts["video"] = contrasts["clicDvideo"] + contrasts["clicGvideo"] + \
# get the images
fmri_series = [os.path.join(fmri_dir, '%s_series_%s.nii' %
(subject, session)) for session in sessions]
if side == 'left':
fmri_series = [
os.path.join(fmri_dir, '%s_series_%s_lh_smooth5.gii' %
(subject, session)) for session in sessions]
elif side == 'right':
fmri_series = [
os.path.join(fmri_dir, '%s_series_%s_rh_smooth5.gii' %
(subject, session)) for session in sessions]
# compute the mask
if side == False:
mean_img = glob.glob(os.path.join(fmri_dir, 'mean*.nii'))[0]
mask_array = compute_mask_files(mean_img, epi_mask, True,
inf_threshold, sup_threshold)[0]
# get the contrasts
n_reg = make_dmtx(frametimes, add_regs=reg_matrix,
drift_model=drift_model, hfcut=hfcut).matrix.shape[1]
contrasts, all_reg = make_contrasts(sessions, n_reg)
contrast_obj = {}
for (sess, (session, fmri_data)) in enumerate(zip(
sessions, fmri_series)):
# create design matrices
reg = all_reg[2 * sess: 2 * sess + 2] # fixme
design_matrix = make_dmtx(
frametimes, add_regs=reg_matrix, add_reg_names=reg,
drift_model=drift_model, hfcut=hfcut)
def load_vol_bold_and_mask(bold_files, mask_file):
from pyhrf.tools._io import read_volume, discard_bad_data
# Handle mask
if not op.exists(mask_file):
logger.warning(
'Mask file %s does not exist. Mask is '
'computed from BOLD ...', mask_file)
bold_file = 'subj0_bold_session0.nii.gz'
# HACK
if bold_files[0] == pyhrf.get_data_file_name(bold_file):
max_frac = .99999 # be sure to keep non zero voxels
connect_component = False # default BOLD vol has 2 ROIs
else:
max_frac = .9
connect_component = True
compute_mask_files(bold_files[0],
mask_file,
False,
.4,
max_frac,
cc=connect_component)
mask_loaded_from_file = False
else:
mask_loaded_from_file = True
logger.info('Assuming orientation for mask file: ' +
string.join(MRI3Daxes, ','))
logger.info('Read mask from: %s', mask_file)
mask, mask_meta_obj = read_volume(mask_file)
if not np.allclose(np.round(mask), mask):
raise Exception("Mask is not n-ary (%s)" % mask_file)
mask = np.round(mask).astype(np.int32)
logger.info(
'Mask has shape %s\nMask min value: %d\n'
'Mask max value: %d\nMask has %d parcels', str(mask.shape), mask.min(),
mask.max(), len(np.unique(mask)))
if mask.min() == -1:
mask += 1
# Load BOLD:
last_scan = 0
session_scans = []
bolds = []
logger.info('Assuming orientation for BOLD files: ' +
string.join(MRI4Daxes, ','))
if type(bold_files[0]) is list:
bold_files = bold_files[0]
for bold_file in bold_files:
if not op.exists(bold_file):
raise Exception('File not found: ' + bold_file)
bold, _ = read_volume(bold_file)
bolds.append(bold)
session_scans.append(
np.arange(last_scan, last_scan + bold.shape[TIME_AXIS], dtype=int))
last_scan += bold.shape[TIME_AXIS]
bold = np.concatenate(tuple(bolds), axis=TIME_AXIS)
logger.info('BOLD has shape %s', str(bold.shape))
discard_bad_data(bold, mask)
return mask, mask_meta_obj, mask_loaded_from_file, bold, session_scans
def plot_cv_tc(epi_data, session_ids, subject_id,
do_plot=True,
write_image=True, mask=True, bg_image=False,
plot_diff=True,
_output_dir=None,
cv_tc_plot_outfile=None):
""" Compute coefficient of variation of the data and plot it
Parameters
----------
epi_data: list of strings, input fMRI 4D images
session_ids: list of strings of the same length as epi_data,
session indexes (for figures)
subject_id: string, id of the subject (for figures)
do_plot: bool, optional,
should we plot the resulting time course
write_image: bool, optional,
should we write the cv image
mask: bool or string, optional,
(string) path of a mask or (bool) should we mask the data
bg_image: bool or string, optional,
(string) pasth of a background image for display or (bool)
should we compute such an image as the mean across inputs.
if no, an MNI template is used (works for normalized data)
"""
if _output_dir is None:
if not cv_tc_plot_outfile is None:
_output_dir = os.path.dirname(cv_tc_plot_outfile)
else:
_output_dir = tempfile.mkdtemp()
cv_tc_ = []
if isinstance(mask, basestring):
mask_array = nibabel.load(mask).get_data() > 0
elif mask == True:
mask_array = compute_mask_files(epi_data[0])
else:
mask_array = None
for (session_id, fmri_file) in zip(session_ids, epi_data):
nim = do_3Dto4D_merge(fmri_file, output_dir=_output_dir)
affine = nim.get_affine()
if len(nim.shape) == 4:
# get the data
data = nim.get_data()
else:
raise TypeError("Expecting 4D image!")
pass
# compute the CV for the session
cache_dir = os.path.join(_output_dir, "CV")
if not os.path.exists(cache_dir):
os.makedirs(cache_dir)
mem = joblib.Memory(cachedir=cache_dir, verbose=5)
cv = mem.cache(compute_cv)(data, mask_array=mask_array)
if write_image:
# write an image
nibabel.save(nibabel.Nifti1Image(cv, affine),
os.path.join(_output_dir, 'cv_%s.nii' % session_id))
if bg_image == False:
try:
viz.plot_map(
cv, affine, threshold=.01, cmap=viz.cm.cold_hot)
except IndexError:
print traceback.format_exc()
else:
if isinstance(bg_image, basestring):
_tmp = nibabel.load(bg_image)
anat, anat_affine = (
_tmp.get_data(),
_tmp.get_affine())
else:
anat, anat_affine = data.mean(-1), affine
try:
viz.plot_map(
cv, affine, threshold=.01, cmap=viz.cm.cold_hot,
anat=anat, anat_affine=anat_affine)
except IndexError:
print traceback.format_exc()
# compute the time course of cv
cv_tc_sess = np.median(
np.sqrt((data[mask_array > 0].T /
data[mask_array > 0].mean(-1) - 1) ** 2), 1)
cv_tc_.append(cv_tc_sess)
cv_tc = np.concatenate(cv_tc_)
if do_plot:
# plot the time course of cv for different subjects
pl.figure()
pl.plot(cv_tc, label=subject_id)
pl.legend()
pl.xlabel('time(scans)')
pl.ylabel('Median coefficient of variation')
pl.axis('tight')
if not cv_tc_plot_outfile is None:
pl.savefig(cv_tc_plot_outfile,
bbox_inches="tight", dpi=200)
return cv_tc
elif side == 'right':
wild_card = '*rh_smooth5.gii' # '*rh.gii' #
print "Subject : %s, side : %s" % (subject, side)
# get the images
fmri_series = [glob.glob(
os.path.join(fmri_dir, session, wild_card))
for session in sessions]
# warning: glob returns the files in random order
for f in fmri_series:
f.sort()
if side == False:
# in the volume, compute a mask o fthe brain
mask_array = compute_mask_files(fmri_series[0], epi_mask, True,
inf_threshold, sup_threshold)[0]
# Specify the contrasts
contrasts = make_contrasts(sessions, odd=subject in
['sujet10', 'sujet12'])
contrast_obj = {}
for (sess, (session, fmri_data)) in enumerate(zip(
sessions, fmri_series)):
# create design matrices
reg = all_reg[4 * sess: 4 * sess + 4] # fixme
design_matrix = make_dmtx(
frametimes, add_regs=reg_matrix, add_reg_names=reg,
drift_model=drift_model, hfcut=hf_cut)
# plot the design matrix
def load_vol_bold_and_mask(bold_files, mask_file):
# Handle mask
if not op.exists(mask_file):
pyhrf.verbose(1,'Mask file %s does not exist. Mask is '\
' computed from BOLD ...' %mask_file)
bf = 'subj0_bold_session0.nii.gz'
# HACK
if bold_files[0] == pyhrf.get_data_file_name(bf):
max_frac = .99999 #be sure to keep non zero voxels
cc = 0 # default BOLD vol has 2 ROIs
else:
max_frac = .9
cc = 1
compute_mask_files(bold_files[0], mask_file, False, .4,
max_frac, cc=cc)
mask_loaded_from_file = False
else:
mask_loaded_from_file = True
pyhrf.verbose(1,'Assuming orientation for mask file: ' + \
string.join(MRI3Daxes, ','))
pyhrf.verbose(2,'Read mask from: %s' %mask_file)
mask, mask_meta_obj = read_volume(mask_file)
if not np.allclose(np.round(mask),mask):
raise Exception("Mask is not n-ary (%s)" %mask_file)
mask = mask.astype(np.int32)
pyhrf.verbose(1,'Mask has shape %s' %str(mask.shape))
pyhrf.verbose(1,'Mask min value: %d' %mask.min())
pyhrf.verbose(1,'Mask max value: %d' %mask.max())
mshape = mask.shape
if mask.min() == -1:
mask += 1
#Load BOLD:
lastScan = 0
sessionScans = []
bolds = []
pyhrf.verbose(1,'Assuming orientation for BOLD files: ' + \
string.join(MRI4Daxes, ','))
#print 'type of bold_files[0]:', type(bold_files[0])
#print 'bold_files:', bold_files
if type(bold_files[0]) is list:
bold_files = bold_files[0]
for bold_file in bold_files:
if not op.exists(bold_file):
raise Exception('File not found: ' + bold_file)
b, bold_meta = read_volume(bold_file)
bolds.append(b)
sessionScans.append(np.arange(lastScan,
lastScan+b.shape[TIME_AXIS],
dtype=int))
lastScan += b.shape[TIME_AXIS]
bold = np.concatenate(tuple(bolds), axis=TIME_AXIS)
pyhrf.verbose(1,'BOLD has shape %s' %str(bold.shape))
discard_bad_data(bold, mask)
# #HACK
# if mask_file != DEFAULT_MASK_VOL_FILE:
# write_volume(mask,'./treated_mask.nii')
# sys.exit(0)
return mask, mask_meta_obj, mask_loaded_from_file, bold, sessionScans
fmri_dir,
'%s_series_%s_lh_smooth5.gii' % (subject, session))
for session in sessions
]
elif side == 'right':
fmri_series = [
os.path.join(
fmri_dir,
'%s_series_%s_rh_smooth5.gii' % (subject, session))
for session in sessions
]
# compute the mask
if side == False:
mean_img = glob.glob(os.path.join(fmri_dir, 'mean*.nii'))[0]
mask_array = compute_mask_files(mean_img, epi_mask, True,
inf_threshold, sup_threshold)[0]
# get the contrasts
n_reg = make_dmtx(frametimes,
add_regs=reg_matrix,
drift_model=drift_model,
hfcut=hfcut).matrix.shape[1]
contrasts, all_reg = make_contrasts(sessions, n_reg)
contrast_obj = {}
for (sess, (session,
fmri_data)) in enumerate(zip(sessions, fmri_series)):
# create design matrices
reg = all_reg[2 * sess:2 * sess + 2] # fixme
design_matrix = make_dmtx(frametimes,
hfcut=hfcut)
ax = design_matrix.show()
ax.set_position([.05, .25, .9, .65])
ax.set_title('Design matrix')
plt.savefig(path.join(write_dir, 'design_matrix.png'))
# design_matrix.write_csv(...)
########################################
# Mask the data
########################################
print 'Computing a brain mask...'
mask_path = path.join(write_dir, 'mask.nii')
mask_array = compute_mask_files(data_path, mask_path, False, 0.4, 0.9)
#########################################
# Specify the contrasts
#########################################
# simplest ones
contrasts = {}
n_columns = len(design_matrix.names)
for i in range(paradigm.n_conditions):
contrasts['%s' % design_matrix.names[2 * i]] = np.eye(n_columns)[2 * i]
# and more complex/ interesting ones
contrasts["audio"] = contrasts["clicDaudio"] + contrasts["clicGaudio"] +\
contrasts["calculaudio"] + contrasts["phraseaudio"]
contrasts["video"] = contrasts["clicDvideo"] + contrasts["clicGvideo"] + \
