def make_mask(mask, volume, mask_file):
from pyhrf.ndarray import xndarray
m = xndarray.load(mask)
v = xndarray.load(volume)
mask = m.copy()
#mask.data = np.zeros_like(m.data)
mask.data[np.where(v.data == 0.)] = 0
mask.save(mask_file)
return
def make_mask(mask, volume, mask_file):
from pyhrf.ndarray import xndarray
m = xndarray.load(mask)
v = xndarray.load(volume)
mask = m.copy()
#mask.data = np.zeros_like(m.data)
mask.data[np.where(v.data == 0.)] = 0
mask.save(mask_file)
return
def setUp(self):
cmask = xndarray.load(xcore.DEFAULT_MASK)
self.mask_vol = cmask.data
self.vol_meta_data = cmask.meta_data
self.bold_vol = xndarray.load(xcore.DEFAULT_BOLD).data
m = np.where(self.mask_vol)
self.bold_flat = self.bold_vol[m[0], m[1], m[2],:].T
self.onsets = xcore.DEFAULT_ONSETS
self.durations = xcore.DEFAULT_STIM_DURATIONS
def plot_maps(plot_params, anat_fn, anat_slice_def, fig_dir,
orientation=['axial','sagittal'], crop_extension=None,
plot_anat=True, plot_fontsize=25, fig_dpi=75):
ldata = []
for p in plot_params:
c = xndarray.load(p['fn']).sub_cuboid(**p['slice_def'])
c.set_orientation(orientation)
ldata.append(c.data)
c_anat = xndarray.load(anat_fn).sub_cuboid(**anat_slice_def)
c_anat.set_orientation(orientation)
resolution = c_anat.meta_data[1]['pixdim'][1:4]
slice_resolution = resolution[MRI4Daxes.index(orientation[0])], \
resolution[MRI4Daxes.index(orientation[1])]
all_data = np.array(ldata)
if 'prl' in plot_params[0]['fn']:
norm = normalize(all_data.min(), all_data.max()*1.05)
print 'norm:', (all_data.min(), all_data.max())
else:
norm = normalize(all_data.min(), all_data.max())
print 'norm:', (all_data.min(), all_data.max())
for data, plot_param in zip(all_data, plot_params):
fn = plot_param['fn']
plt.figure()
print 'fn:', fn
print '->', (data.min(), data.max())
if plot_anat:
anat_data = c_anat.data
else:
anat_data = None
plot_func_slice(data, anatomy=anat_data,
parcellation=plot_param.get('mask'),
func_cmap=cmap,
parcels_line_width=1., func_norm=norm,
resolution=slice_resolution,
crop_extension=crop_extension)
set_ticks_fontsize(plot_fontsize)
fig_fn = op.join(fig_dir, '%s.png' %op.splitext(op.basename(fn))[0])
output_fig_fn = plot_param.get('output_fig_fn', fig_fn)
print 'Save to: %s' %output_fig_fn
plt.savefig(output_fig_fn, dpi=fig_dpi)
autocrop(output_fig_fn)
return norm
def __init__(self,
contrasts={'dummy_contrast_example': '3*audio-video/3'},
contrast_test_baseline=0.0,
hrf_model='Canonical',
drift_model='Cosine',
hfcut=128.,
residuals_model='spherical',
fit_method='ols',
outputPrefix='glm_',
rescale_results=False,
rescale_factor_file=None,
fir_delays=[0],
output_fit=False):
xmlio.XmlInitable.__init__(self)
FMRIAnalyser.__init__(self, outputPrefix)
self.output_fit = output_fit
self.hrf_model = hrf_model
self.drift_model = drift_model
self.fir_delays = fir_delays
self.hfcut = hfcut
self.residuals_model = residuals_model
self.fit_method = fit_method
self.contrasts = contrasts
self.contrasts.pop('dummy_contrast_example', None)
self.con_bl = contrast_test_baseline
self.rescale_results = rescale_results
if rescale_factor_file is not None:
self.rescale_factor = xndarray.load(rescale_factor_file).data
else:
self.rescale_factor = None
def __init__(self, contrasts={'dummy_contrast_example':'3*audio-video/3'},
contrast_test_baseline=0.0,
hrf_model='Canonical', drift_model='Cosine', hfcut=128.,
residuals_model='spherical',fit_method='ols',
outputPrefix='glm_', rescale_results=False,
rescale_factor_file='', fir_delays=[0]):
FMRIAnalyser.__init__(self, outputPrefix)
xmlio.XMLable2.__init__(self)
self.hrf_model = hrf_model
self.drift_model = drift_model
self.fir_delays = fir_delays
self.hfcut = hfcut
self.residuals_model = residuals_model
self.fit_method = fit_method
self.contrasts = contrasts
self.contrasts.pop('dummy_contrast_example',None)
self.con_bl = contrast_test_baseline
self.rescale_results = rescale_results
if rescale_factor_file != '':
self.rescale_factor = xndarray.load(rescale_factor_file).data
else:
self.rescale_factor = None
def setUp(self):
tag = 'subj0_%s.nii.gz'
func_file = pyhrf.get_data_file_name(tag % 'bold_session0')
anatomy_file = pyhrf.get_data_file_name(tag % 'anatomy')
roi_mask_file = pyhrf.get_data_file_name(tag % 'parcellation')
islice = 24
cfunc = xndarray.load(func_file).sub_cuboid(time=0, axial=islice)
cfunc.set_orientation(['coronal', 'sagittal'])
self.func_data = cfunc.data
canat = xndarray.load(anatomy_file).sub_cuboid(axial=islice*3)
canat.set_orientation(['coronal', 'sagittal'])
self.anat_data = canat.data
croi_mask = xndarray.load(roi_mask_file).sub_cuboid(axial=islice)
croi_mask.set_orientation(['coronal', 'sagittal'])
self.roi_data = croi_mask.data
def load_func_data(self, mask):
# Load func data for all sessions and flatten them according to mask
mask = mask != self.bg_label
cfdata = [xndarray.load(f).flatten(mask, self.spatial_axes, 'voxel') \
for f in self.func_files]
# flatten along sessions:
cfdata = stack_cuboids(cfdata, 'session').reorient(['session','time']+\
self.spatial_axes)
return np.concatenate(cfdata.data)
def setUp(self):
tag = 'subj0_%s.nii.gz'
func_file = pyhrf.get_data_file_name(tag%'bold_session0')
anatomy_file = pyhrf.get_data_file_name(tag%'anatomy')
roi_mask_file = pyhrf.get_data_file_name(tag%'parcellation')
islice = 24
cfunc = xndarray.load(func_file).sub_cuboid(time=0,axial=islice)
cfunc.set_orientation(['coronal', 'sagittal'])
self.func_data = cfunc.data
canat = xndarray.load(anatomy_file).sub_cuboid(axial=islice*3)
canat.set_orientation(['coronal', 'sagittal'])
self.anat_data = canat.data
croi_mask = xndarray.load(roi_mask_file).sub_cuboid(axial=islice)
croi_mask.set_orientation(['coronal', 'sagittal'])
self.roi_data = croi_mask.data
def setUp(self):
tag = "subj0_%s.nii.gz"
func_file = pyhrf.get_data_file_name(tag % "bold_session0")
anatomy_file = pyhrf.get_data_file_name(tag % "anatomy")
roi_mask_file = pyhrf.get_data_file_name(tag % "parcellation")
islice = 24
cfunc = xndarray.load(func_file).sub_cuboid(time=0, axial=islice)
cfunc.set_orientation(["coronal", "sagittal"])
self.func_data = cfunc.data
canat = xndarray.load(anatomy_file).sub_cuboid(axial=islice * 3)
canat.set_orientation(["coronal", "sagittal"])
self.anat_data = canat.data
croi_mask = xndarray.load(roi_mask_file).sub_cuboid(axial=islice)
croi_mask.set_orientation(["coronal", "sagittal"])
self.roi_data = croi_mask.data
def make_mask_from_points(pois, mask_file, new_mask_file):
m = xndarray.load(mask_file)
new_m = xndarray.xndarray_like(m)
for poi in pois:
i,j,k = poi['sagittal'], poi['coronal'], poi['axial']
new_m.data[i,j,k] = 1
new_m.save(new_mask_file)
def plot_estimation_results(fig_dir, poi, jde_roi, cond, plot_label,
glm_fir_output_dir, rfir_output_dir,
jde_output_dir, ymin=-1.55, ymax=1.05,
plot_fontsize=25):
## HRF plots
fn = op.join(glm_fir_output_dir, 'glm_fir_hrf.nii.gz')
fir = xndarray.load(fn).sub_cuboid(condition=cond, **poi)
#fir /= (fir**2).sum()**.5
fir /= fir.max()
fn = op.join(rfir_output_dir, 'rfir_ehrf.nii.gz')
rfir = xndarray.load(fn).sub_cuboid(condition=cond, **poi)
#rfir /= (rfir**2).sum()**.5
rfir /= rfir.max()
fn = op.join(jde_output_dir, 'jde_mcmc_hrf_pm.nii.gz')
jde = xndarray.load(fn).sub_cuboid(ROI=jde_roi)
jde /= jde.max()
plt.figure()
pargs = {'linewidth' : 2.7}
plot_cub_as_curve(fir, show_axis_labels=False, plot_kwargs=pargs)
plot_cub_as_curve(rfir, show_axis_labels=False, plot_kwargs=pargs)
plot_cub_as_curve(jde, show_axis_labels=False, plot_kwargs=pargs)
from pyhrf.boldsynth.hrf import getCanoHRF
time_points, hcano = getCanoHRF()
hcano /= hcano.max()
plt.plot(time_points, hcano, 'k.-',linewidth=1.5)
set_ticks_fontsize(plot_fontsize)
plt.xlim(0,25)
plt.ylim(ymin, ymax)
plt.gca().xaxis.grid(True, 'major', linestyle='--', linewidth=1.2,
color='gray')
hrf_fig_fn = op.join(fig_dir, 'real_data_hrfs_%s.png' %plot_label)
print 'hrf_fig_fn:', hrf_fig_fn
plt.savefig(hrf_fig_fn)
autocrop(hrf_fig_fn)
def make_parcellation_from_files(betaFiles,
maskFile,
outFile,
nparcels,
method,
dry=False,
spatial_weight=10.):
if not op.exists(maskFile):
print 'Error, file %s not found' % maskFile
return
betaFiles = sorted(betaFiles)
for b in betaFiles:
if not op.exists(b):
raise Exception('Error, file %s not found' % b)
logger.info('Mask image: %s', op.basename(maskFile))
logger.info('Betas: %s ... %s', op.basename(betaFiles[0]),
op.basename(betaFiles[-1]))
logger.info("Method: %s, nb parcels: %d", method, nparcels)
logger.info('Spatial weight: %f', spatial_weight)
if not dry:
logger.info('Running parcellation ... ')
logger.info('Start date is: %s', strftime('%c', localtime()))
t0 = time()
v = logger.getEffectiveLevel() <= logging.INFO
lpa = fixed_parcellation(maskFile,
betaFiles,
nparcels,
nn=6,
method=method,
fullpath=outFile,
verbose=v,
mu=spatial_weight)
from pyhrf.ndarray import xndarray
c = xndarray.load(outFile)
if c.min() == -1:
c.data += 1
for i in np.unique(c.data):
# remove parcel with size < 2:
if i != 0 and len(c.data == 1) < 2:
c.data[np.where(c.data == i)] = 0
c.save(outFile)
logger.info('Parcellation complete, took %s',
format_duration(time() - t0))
return lpa
else:
logger.info('Dry run.')
def load_and_get_fdata_params(self):
pyhrf.verbose(1,'Load mask from: %s' %self.mask_file)
if self.data_type == 'surface':
pyhrf.verbose(2,'Read mesh from: %s' %self.mesh_file)
p = {'mask' : xndarray.load(self.mask_file).data}
pyhrf.verbose(1, 'Mask shape %s' %str(p['mask'].shape))
if self.data_type == 'surface':
p['graph'] = graph_from_mesh(read_mesh(self.mesh_file))
return p
def compute_T_Pvalue(betas, stds_beta, mask_file, null_hyp=True):
'''
Compute Tvalues statistic and Pvalue based upon estimates
and their standard deviation
beta and std_beta for all voxels
beta: shape (nb_vox, 1)
std: shape (1)
Assume null hypothesis if null_hyp is True
'''
from pyhrf.ndarray import xndarray
import sys
sys.path.append("/home/i2bm/BrainVisa/source/pyhrf/pyhrf-free/trunk/script/WIP/Scripts_IRMf_Adultes_Solv/Scripts_divers_utiles/Scripts_utiles/")
from Functions_fit import Permutation_test, stat_mean, stat_Tvalue, stat_Wilcoxon
mask = xndarray.load(mask_file).data #to save P and Tval on a map
BvalC = xndarray(betas, axes_names=['sagittal', 'coronal', 'axial'])
Betasval = BvalC.flatten(mask, axes=['sagittal', 'coronal', 'axial'], new_axis='position').data
Stdsval = stds_beta
Tval = xndarray(Betasval/Stdsval, axes_names=['position']).data
nb_vox = Betasval.shape[0]
nb_reg = betas.shape[1]
dof = nb_vox - nb_reg #degrees of freedom for STudent distribution
assert dof>0
Probas=np.zeros(Betasval.shape)
for i in xrange(nb_vox):
if null_hyp:
#STudent distribution
from scipy.stats import t
fmix = lambda x: t.pdf(x, dof)
else:
fmix = lambda t: 1/np.sqrt(2*np.pi*Stdsval[i]**2)*np.exp(- (t - Betasval[i])**2 / (2*Stdsval[i]**2) )
Probas[i] = quad(fmix, Tval[i], float('inf'))[0]
Tvalues_ = xndarray(Tval, axes_names=['position'])
Pvalues_ = xndarray(Probas, axes_names=['position'])
Tvalues = Tvalues_.expand(mask, 'position', ['sagittal','coronal','axial'])
Pvalues = Pvalues_.expand(mask, 'position', ['sagittal','coronal','axial'])
#Computation of Pvalue using permutations
#not possible to do this actually...it was used for group level stats
#Pvalue_t = np.zeros(Betasval.shape)
#for i in xrange(nb_vox):
#Pvalue_t[i] = Permutation_test(Betasval[i], n_permutations=10000, \
#stat = stat_Tvalue, two_tailed=False, plot_histo=False)
return Tvalues.data, Pvalues.data
def load_and_get_fdata_params(self, sessions_data, mask):
params = stack_trees([sd.to_dict() for sd in sessions_data])
fns = params.pop('func_data_file')
pyhrf.verbose(1, 'Load functional data from: %s' %',\n'.join(fns))
fdata = stack_cuboids([xndarray.load(fn) for fn in fns], 'session')
fdata = np.concatenate(fdata.data) #scan sessions along time axis
pio.discard_bad_data(fdata, mask)
pyhrf.verbose(1, 'Functional data shape %s' %str(fdata.shape))
params['func_data'] = fdata
return params
def test_voronoi_with_seeds(self):
import os.path as op
from pyhrf.ndarray import xndarray
import pyhrf
fn = 'subj0_parcellation.nii.gz'
mask_file = pyhrf.get_data_file_name(fn)
orientation = ['axial', 'coronal', 'sagittal']
seeds = xndarray.xndarray_like(
xndarray.load(mask_file)).reorient(orientation)
seed_coords = np.array([[24, 35, 8], # axial, coronal, sagittal
[27, 35, 5],
[27, 29, 46],
[31, 28, 46]])
seeds.data[:] = 0
seeds.data[tuple(seed_coords.T)] = 1
seed_file = op.join(self.tmp_dir, 'voronoi_seeds.nii')
seeds.save(seed_file, set_MRI_orientation=True)
output_file = op.join(self.tmp_dir, 'voronoi_parcellation.nii')
cmd = 'pyhrf_parcellate_spatial %s -m voronoi -c %s -o %s -v %d' \
% (mask_file, seed_file, output_file, logger.getEffectiveLevel())
if os.system(cmd) != 0:
raise Exception('"' + cmd + '" did not execute correctly')
logger.info('cmd: %s', cmd)
assert op.exists(output_file)
parcellation = xndarray.load(output_file)
n_parcels = len(np.unique(parcellation.data)) - 1
self.assertEqual(n_parcels, len(seed_coords))
def make_parcellation_from_files(betaFiles, maskFile, outFile, nparcels,
method, dry=False, spatial_weight=10.):
if not op.exists(maskFile):
print 'Error, file %s not found' %maskFile
return
betaFiles = sorted(betaFiles)
for b in betaFiles:
if not op.exists(b):
print 'Error, file %s not found' %b
return
pyhrf.verbose(1, 'Mask image: ' + op.basename(maskFile))
pyhrf.verbose(1, 'Betas: ' + op.basename(betaFiles[0]) + ' ... ' + \
op.basename(betaFiles[-1]))
pyhrf.verbose(1, "Method: %s, nb parcels: %d" %(method, nparcels))
pyhrf.verbose(1, 'Spatial weight: %f' %spatial_weight)
if not dry:
pyhrf.verbose(1, 'Running parcellation ... ')
pyhrf.verbose(1, 'Start date is: %s' %strftime('%c',localtime()))
t0 = time()
#lpa = one_subj_parcellation(maskFile, betaFiles, nparcels, 6,
# method, 10, 1, fullpath=outFile)
v = pyhrf.verbose.verbosity
lpa = fixed_parcellation(maskFile, betaFiles, nparcels, nn=6,
method=method, fullpath=outFile, verbose=v,
mu=spatial_weight)
from pyhrf.ndarray import xndarray
c = xndarray.load(outFile)
if c.min() == -1:
c.data += 1
for i in np.unique(c.data):
# remove parcel with size < 2:
if i!=0 and len(c.data==1) < 2:
c.data[np.where(c.data==i)] = 0
c.save(outFile)
pyhrf.verbose(1, 'Parcellation complete, took %s' \
%format_duration(time() - t0))
return lpa
else:
pyhrf.verbose(1, 'Dry run.')
def load_and_get_fdata_params(self, mask):
if op.splitext(self.paradigm_file)[-1] == '.csv':
onsets, durations = pio.load_paradigm_from_csv(self.paradigm_file)
else:
raise Exception('Only CSV file format support for paradigm')
fns = self.func_data_files
pyhrf.verbose(1, 'Load functional data from: %s' %',\n'.join(fns))
fdata = stack_cuboids([xndarray.load(fn) for fn in fns], 'session')
fdata = np.concatenate(fdata.data) #scan sessions along time axis
pio.discard_bad_data(fdata, mask)
pyhrf.verbose(1, 'Functional data shape %s' %str(fdata.shape))
return {'stim_onsets': onsets, 'stim_durations':durations,
'func_data': fdata}
def item_list_popup(self, pos):
sel_indexes = self.ui.item_list.selectionModel().selection().indexes()
if len(sel_indexes) > 0:
menu = QtGui.QMenu(self.ui.item_list)
reloadAction = menu.addAction("Reload")
action = menu.exec_(self.ui.item_list.mapToGlobal(pos))
if action == reloadAction:
fn_to_cuboid = {}
for i in sel_indexes:
r, c = i.row(), i.column()
item = str(self.ui.item_list.itemAt(r, c).text())
# only load cuboids once
fn = self.item_to_filenames[item]
if not fn_to_cuboid.has_key(fn):
fn_to_cuboid[fn] = xndarray.load(fn)
self.main_browser.set_new_cuboid(fn_to_cuboid[fn], item)
fn_to_cuboid = None #garbage collect
def make_parcellation_from_files(betaFiles, maskFile, outFile, nparcels,
method, dry=False, spatial_weight=10.):
if not op.exists(maskFile):
print 'Error, file %s not found' % maskFile
return
betaFiles = sorted(betaFiles)
for b in betaFiles:
if not op.exists(b):
raise Exception('Error, file %s not found' % b)
logger.info('Mask image: %s', op.basename(maskFile))
logger.info('Betas: %s ... %s', op.basename(betaFiles[0]),
op.basename(betaFiles[-1]))
logger.info("Method: %s, nb parcels: %d", method, nparcels)
logger.info('Spatial weight: %f', spatial_weight)
if not dry:
logger.info('Running parcellation ... ')
logger.info('Start date is: %s', strftime('%c', localtime()))
t0 = time()
v = logger.getEffectiveLevel() <= logging.INFO
lpa = fixed_parcellation(maskFile, betaFiles, nparcels, nn=6,
method=method, fullpath=outFile, verbose=v,
mu=spatial_weight)
from pyhrf.ndarray import xndarray
c = xndarray.load(outFile)
if c.min() == -1:
c.data += 1
for i in np.unique(c.data):
# remove parcel with size < 2:
if i != 0 and len(c.data == 1) < 2:
c.data[np.where(c.data == i)] = 0
c.save(outFile)
logger.info(
'Parcellation complete, took %s', format_duration(time() - t0))
return lpa
else:
logger.info('Dry run.')
def test_ward_spatial_cmd(self):
from pyhrf.parcellation import parcellation_dist
output_file = op.join(self.tmp_dir, 'parcellation_output_test.nii')
nparcels = 4
cmd = 'pyhrf_parcellate_glm -m %s %s %s -o %s -v %d ' \
'-n %d -t ward_spatial ' \
% (self.mask_fn, self.p1_fn, self.p2_fn, output_file,
logger.getEffectiveLevel(), nparcels)
if os.system(cmd) != 0:
raise Exception('"' + cmd + '" did not execute correctly')
logger.info('cmd: %s', cmd)
labels = xndarray.load(output_file).data
logger.info('labels.dtype:%s', str(labels.dtype))
dist = parcellation_dist(self.p1, labels)[0]
logger.info('dist:%d', dist)
self.assertEqual(dist, 0)
def test_ward_spatial_cmd(self):
from pyhrf.parcellation import parcellation_dist
#pyhrf.verbose.verbosity = 2
output_file = op.join(self.tmp_dir,'parcellation_output_test.nii')
nparcels = 4
cmd = 'pyhrf_parcellate_glm -m %s %s %s -o %s -v %d ' \
'-n %d -t ward_spatial ' \
%(self.mask_fn, self.p1_fn, self.p2_fn, output_file,
pyhrf.verbose.verbosity, nparcels)
if os.system(cmd) != 0 :
raise Exception('"' + cmd + '" did not execute correctly')
pyhrf.verbose(1, 'cmd: %s' %cmd)
labels = xndarray.load(output_file).data
pyhrf.verbose(2, 'labels.dtype:%s' %str(labels.dtype))
dist = parcellation_dist(self.p1, labels)[0]
pyhrf.verbose(2, 'dist:%d' %dist)
self.assertEqual(dist, 0)
def add_file(self, filename, open_plot=True):
"""
Load a file, place into item list and create a browser/viewer.
Args:
- filename (str): path to the data file to load
- open_plot (bool): open plot window on load (TODO)
Modifies attributes:
- item_to_filenames: associate filename to new item id
- filenames_to_items: associate item id to filename
"""
if not op.exists(filename):
QtGui.QMessageBox.critical(self, 'File not found: %s' %filename)
item_id = self.get_unique_item_id(op.basename(filename))
#print 'item_id:', item_id
self.item_to_filenames[item_id] = filename
self.filenames_to_items[filename] = item_id
self.ui.item_list.addItem(item_id)
self.main_browser.add_cuboid(xndarray.load(filename), item_id)
def compute_jde_glm_rescaling(jde_path, glm_path, output_file):
#TODO: check consistency of condition order btwn GLM & JDE !!!
# load matX from JDE results (same for all parcels)
# matX is a matrix of shape (time x nb_hrf_coeff)
# matX = sum_m(X^m * m) where X is the matrix defined in the fwd JDE model
# jde_dm_fn = op.join(jde_path,'jde_mcmc_matX.nii.gz')
# jde_dm = xndarray.load(jde_dm_fn).sub_cuboid(ROI=12).reorient(('time','P'))
# print 'jde_dm:'
# print jde_dm.descrip()
# ny,lgCI = jde_dm.data.shape
# nbConditions = len(np.unique(jde_dm.data)) - 1
# # reconstruct all X^m from matX
# varX = np.zeros((nbConditions,ny,lgCI))
# for j in xrange(nbConditions):
# varX[j,:,:] = (jde_dm.data == j).astype(int)
jde_varX_fn = op.join(jde_path,'jde_mcmc_varX.nii.gz')
jde_varX = xndarray.load(jde_varX_fn).sub_cuboid(ROI=1)
jde_varX = jde_varX.reorient(('condition', 'time','P'))
print 'jde_dm varX:'
print jde_varX.descrip()
nbConditions,ny,lgCI = jde_varX.data.shape
varX = jde_varX.data
# More convenient matrix structure to perfom product with HRF afterwards
stackX = np.zeros((ny*nbConditions,lgCI), dtype=int)
for j in xrange(nbConditions):
stackX[ny*j:ny*(j+1), :] = varX[j,:,:]
print 'stackX:', stackX.shape
# Load HRFs from JDE results
jde_hrf_fn = op.join(jde_path, 'jde_mcmc_hrf_pm.nii.gz')
jde_hrf = xndarray.load(jde_hrf_fn).reorient(('ROI','time'))
print 'jde_hrf:'
print jde_hrf.descrip()
roi_ids = jde_hrf.axes_domains['ROI']
jde_xh = np.zeros((len(roi_ids),ny,nbConditions))
for iroi,roi in enumerate(roi_ids):
h = jde_hrf.sub_cuboid(ROI=roi).data[1:-1]
# make sure that the HRF is normalized:
h /= (h**2).sum()**.5
stackXh = np.dot(stackX, h)
jde_xh[iroi,:,:] = np.reshape(stackXh, (nbConditions,ny)).transpose()
jde_roi_mask_fn = op.join(jde_path, 'jde_mcmc_roi_mapping.nii.gz')
print 'jde_roi_mask_fn:', jde_roi_mask_fn
jde_roi_mask = xndarray.load(jde_roi_mask_fn)
glm_dm_fn = op.join(glm_path, 'glm_hcano_design_matrix.nii.gz')
glm_dm = xndarray.load(glm_dm_fn).sub_cuboid(ROI=1).reorient(('time',
'regressor'))
print 'glm_dm:'
print glm_dm.descrip()
# align condition axis of GLM design matrix onto condition axis of JDE
# design matrix:
jde_xh_tmp = jde_xh.copy()
cond_domain = []
for cidx,cn in enumerate(glm_dm.axes_domains['regressor']):
if cn in jde_varX.axes_domains['condition']:
jde_cidx = np.where(jde_varX.axes_domains['condition']==cn)[0][0]
print 'cidx:', cidx
print 'jde_cidx:', jde_cidx
jde_xh_tmp[:,:,cidx] = jde_xh[:,:,jde_cidx]
cond_domain.append(cn)
#glm_norm_weights = (glm_dm.data**2).sum(0)**.5
glm_norm_weights = glm_dm.data.ptp(0)
jde_norm_weights = np.zeros(jde_roi_mask.data.shape + (nbConditions,))
scale_factor = np.zeros_like(jde_norm_weights)
for iroi,roi in enumerate(roi_ids):
m = np.where(jde_roi_mask.data == roi)
#jde_w = (jde_xh[iroi]**2).sum(0)**.5
jde_w = jde_xh[iroi].ptp(0)
jde_norm_weights[m[0],m[1],m[2],:] = jde_w
scale_factor[m[0],m[1],m[2],:] = glm_norm_weights[:len(jde_w)] / jde_w
from pyhrf.ndarray import MRI3Daxes
csf = xndarray(scale_factor, axes_names=MRI3Daxes+['condition'],
axes_domains={'condition':np.array(cond_domain)},
meta_data=jde_hrf.meta_data)
print 'rescale factor:'
print csf.descrip()
print 'scale_factor file:', output_file
csf.reorient(['condition']+MRI3Daxes).save(output_file)
def plot_detection_results(fig_dir, poi, condition, coi, parcellation_file,
plot_label, jde_output_dir, glm_hcano_rs_output_dir,
fig_dpi=100):
"""
coi (str): contrast of interest
poi (dict): defines the point of interest for plots of HRFs and maps
"""
if condition == 'audio':
condition = 'phraseaudio'
orientation = ['coronal', 'sagittal']
axial_slice = poi['axial']
anat_file = get_data_file_name('real_data_vol_4_regions_anatomy.nii.gz')
parcellation = xndarray.load(parcellation_file)
parcellation = parcellation.sub_cuboid(axial=axial_slice)
parcellation = parcellation.reorient(orientation)
## Detection maps
detection_plots_params = []
#JDE NRLs
fn = op.join(jde_output_dir, 'jde_mcmc_nrl_pm.nii.gz')
slice_def = {'axial':axial_slice, 'condition':condition}
fig_fn = op.join(fig_dir, 'real_data_jde_mcmc_nrls_%s.png' %condition)
detection_plots_params.append({'fn':fn, 'slice_def':slice_def,
'mask': parcellation.data,
'output_fig_fn':fig_fn})
#GLM hcano
fn = op.join(glm_hcano_rs_output_dir, 'glm_hcano_rs_beta_%s.nii.gz' %condition)
slice_def = {'axial':axial_slice}
fig_fn = op.join(fig_dir, 'real_data_glm_hcano_rs_%s.png'%condition)
detection_plots_params.append({'fn':fn, 'slice_def':slice_def,
'mask': (parcellation.data != 0),
'output_fig_fn':fig_fn})
perf_norm = plot_maps(detection_plots_params, anat_file,
{'axial':axial_slice*3},
fig_dir, orientation=orientation,
crop_extension=None, plot_anat=True)
palette_fig_fn = op.join(fig_dir, 'real_data_detection_%s_palette.png' \
%condition)
plot_palette(cmap, perf_norm, 45)
plt.savefig(palette_fig_fn, dpi=fig_dpi)
autocrop(palette_fig_fn)
#JDE Contrast
fn = op.join(jde_output_dir, 'jde_mcmc_nrl_contrasts.nii.gz')
slice_def = {'axial':axial_slice, 'contrast':coi}
fig_fn = op.join(fig_dir, 'real_data_jde_mcmc_con_%s.png' %coi)
detection_plots_params.append({'fn':fn, 'slice_def':slice_def,
'mask': parcellation.data,
'output_fig_fn':fig_fn})
#GLM hcano
fn = op.join(glm_hcano_rs_output_dir, 'glm_hcano_rs_con_effect_%s.nii.gz'%coi)
slice_def = {'axial':axial_slice}
fig_fn = op.join(fig_dir, 'real_data_glm_hcano_rs_con_%s.png' %coi)
detection_plots_params.append({'fn':fn, 'slice_def':slice_def,
'mask': (parcellation.data != 0),
'output_fig_fn':fig_fn})
perf_norm = plot_maps(detection_plots_params, anat_file,
{'axial':axial_slice*3},
fig_dir, orientation=orientation,
crop_extension=None, plot_anat=True)
palette_fig_fn = op.join(fig_dir, 'real_data_detection_con_%s_palette.png'
%coi)
plot_palette(cmap, perf_norm, 45)
plt.savefig(palette_fig_fn, dpi=fig_dpi)
autocrop(palette_fig_fn)
#
"""
Compute the mean of BOLD signal within parcels.
This is an example of several operations for xndarray:
- explosion of data according to a parcellation mask
- mean over voxel
- merge of several xndarray objects
"""
import os.path as op
from pyhrf import get_data_file_name, get_tmp_path
from pyhrf.ndarray import xndarray, merge
func_data = xndarray.load(get_data_file_name("subj0_bold_session0.nii.gz"))
parcellation = xndarray.load(get_data_file_name("subj0_parcellation.nii.gz"))
parcel_fdata = func_data.explode(parcellation)
parcel_means = dict((parcel_id, d.copy().fill(d.mean("position"))) for parcel_id, d in parcel_fdata.items())
parcel_means = merge(parcel_means, parcellation, axis="position")
output_fn = op.join(get_tmp_path(), "./subj0_bold_parcel_means.nii")
print "File saved to:", output_fn
parcel_means.save(output_fn)
# TODO test full script
# -*- coding: utf-8 -*-
#
"""
Compute the mean of BOLD signal within parcels.
This is an example of several operations for xndarray:
- explosion of data according to a parcellation mask
- mean over voxel
- merge of several xndarray objects
"""
import os.path as op
from pyhrf import get_data_file_name, get_tmp_path
from pyhrf.ndarray import xndarray, merge
func_data = xndarray.load(get_data_file_name('subj0_bold_session0.nii.gz'))
parcellation = xndarray.load(get_data_file_name('subj0_parcellation.nii.gz'))
parcel_fdata = func_data.explode(parcellation)
parcel_means = dict((parcel_id, d.copy().fill(d.mean('position')))
for parcel_id, d in parcel_fdata.items())
parcel_means = merge(parcel_means, parcellation, axis='position')
output_fn = op.join(get_tmp_path(), './subj0_bold_parcel_means.nii')
print 'File saved to:', output_fn
parcel_means.save(output_fn)
#TODO test full script
def cread_volume(fileName):
from pyhrf.ndarray import xndarray
return xndarray.load(fileName)
def cread_volume(fileName):
from pyhrf.ndarray import xndarray
return xndarray.load(fileName)
def make_parcellation(subject, dest_dir="parcellation", roi_mask_file=None):
"""
Perform a functional parcellation from input fmri data
Return: parcellation file name (str)
"""
# Loading names for folders and files
# - T maps (input)
# func_files = glob(op.join(op.join(op.join('./', subject), \
# 't_maps'), 'BOLD*nii'))
# func_files = glob(op.join('./', subject, 'ASLf', 'spm_analysis', \
# 'Tmaps*img'))
func_files = glob(op.join("./", subject, "ASLf", "spm_analysis", "spmT*img"))
print "Tmap files: ", func_files
# - Mask (input)
# spm_mask_file = op.join(spm_maps_dir, 'mask.img')
mask_dir = op.join("./", subject, "preprocessed_data")
if not op.exists(mask_dir):
os.makedirs(mask_dir)
mask_file = op.join(mask_dir, "mask.nii")
mask = op.join(mask_dir, "rcut_tissue_mask.nii")
volume = op.join("./", subject, "ASLf", "funct", "coregister", "mean" + subject + "_ASLf_correctionT1_0001.nii")
make_mask(mask, volume, mask_file)
# - parcellation (output)
parcellation_dir = op.join("./", subject, dest_dir)
if not op.exists(parcellation_dir):
os.makedirs(parcellation_dir)
pfile = op.join(parcellation_dir, "parcellation_func.nii")
# Parcellation
from pyhrf.parcellation import make_parcellation_from_files
# make_parcellation_from_files(func_files, mask_file, pfile,
# nparcels=200, method='ward_and_gkm')
# Masking with a ROI so we just consider parcels inside
# a certain area of the brain
# if roi_mask_file is not None:
if 0: # for ip in np.array([11, 51, 131, 194]):
# ip = 200
# print 'Masking parcellation with roi_mask_file: ', roi_mask_file
print "Masking ROI: ", ip
pfile_masked = op.join(parcellation_dir, "parcellation_func_masked_roi" + str(ip) + ".nii")
from pyhrf.ndarray import xndarray
parcellation = xndarray.load(pfile)
# m = xndarray.load(roi_mask_file)
# parcels_to_keep = np.unique(parcellation.data * m.data)
masked_parcellation = xndarray.xndarray_like(parcellation)
# for ip in parcels_to_keep:
# masked_parcellation.data[np.where(parcellation.data==ip)] = ip
masked_parcellation.data[np.where(parcellation.data == ip)] = ip
masked_parcellation.save(pfile_masked)
from pyhrf.ndarray import xndarray
for tmap in func_files:
func_file_i = xndarray.load(tmap)
func_data = func_file_i.data
# func_file_i.data[np.where(func_data<0.1*func_data.max())] = 0
parcellation = xndarray.load(pfile)
print func_data.max()
print func_data.argmax()
# ip = parcellation.data[func_data.argmax()]
ip = parcellation.data[np.unravel_index(func_data.argmax(), parcellation.data.shape)]
print ip.shape
masked_parcellation = xndarray.xndarray_like(parcellation)
print masked_parcellation.data.shape
print parcellation.data.shape
masked_parcellation.data[np.where(parcellation.data == ip)] = ip
masked_parcellation.save(tmap[:-4] + "_parcelmax.nii")
return pfile
plt.rc('xtick', labelsize=15)
plt.rc('ytick', labelsize=15)
fig = plt.figure(figsize=(20, 9))
gs = gridspec.GridSpec(2, 2)
# Parcellation image
parcels_img = load_img(PARCELLATION_MASK)
parcels_img_data = np.array(parcels_img.get_data())
# Anatomical image
ANAT_IMAGE = glob.glob(os.path.join(INPUT_FOLDER, 'bold.nii')).pop()
anat_img = load_img(ANAT_IMAGE)
# Estimated HRF (3)
hrf_s = xndarray.load(os.path.join(PYHRF_OUTPUT, 'jde_vem_hrf.nii'))
time_axis, canonical_hrf = getCanoHRF(duration=HRF_DURATION, dt=DT)
# Plot Canonical HRF (3)
ax_hrf = plt.subplot(gs[1, 0])
ax_hrf.plot(time_axis, canonical_hrf, ":", label="Canonical")
ax_hrf.set_xlim([0, np.max(time_axis)])
ax_hrf.set_ylabel("amplitude", size=15)
ax_hrf.set_xlabel("time (s)", size=15)
# Plot PPM (2)
ax_ppm = plt.subplot(gs[0, 1])
ppm_img = load_img(os.path.join(PYHRF_OUTPUT, ppm_nii))
try:
plot_stat_map(stat_map_img=ppm_img,
threshold=PPM_THRESHOLD,
def cread_volume(fileName):
return xndarray.load(fileName)
def make_parcellation(subject, dest_dir='parcellation', roi_mask_file=None):
"""
Perform a functional parcellation from input fmri data
Return: parcellation file name (str)
"""
# Loading names for folders and files
# - T maps (input)
#func_files = glob(op.join(op.join(op.join('./', subject), \
# 't_maps'), 'BOLD*nii'))
#func_files = glob(op.join('./', subject, 'ASLf', 'spm_analysis', \
# 'Tmaps*img'))
func_files = glob(op.join('./', subject, 'ASLf', 'spm_analysis', \
'spmT*img'))
print 'Tmap files: ', func_files
# - Mask (input)
#spm_mask_file = op.join(spm_maps_dir, 'mask.img')
mask_dir = op.join('./', subject, 'preprocessed_data')
if not op.exists(mask_dir): os.makedirs(mask_dir)
mask_file = op.join(mask_dir, 'mask.nii')
mask = op.join(mask_dir, 'rcut_tissue_mask.nii')
volume = op.join('./', subject, 'ASLf', 'funct', 'coregister', \
'mean' + subject + '_ASLf_correctionT1_0001.nii')
make_mask(mask, volume, mask_file)
# - parcellation (output)
parcellation_dir = op.join('./', subject, dest_dir)
if not op.exists(parcellation_dir): os.makedirs(parcellation_dir)
pfile = op.join(parcellation_dir, 'parcellation_func.nii')
# Parcellation
from pyhrf.parcellation import make_parcellation_from_files
#make_parcellation_from_files(func_files, mask_file, pfile,
# nparcels=200, method='ward_and_gkm')
# Masking with a ROI so we just consider parcels inside
# a certain area of the brain
#if roi_mask_file is not None:
if 0: #for ip in np.array([11, 51, 131, 194]):
#ip = 200
#print 'Masking parcellation with roi_mask_file: ', roi_mask_file
print 'Masking ROI: ', ip
pfile_masked = op.join(parcellation_dir, 'parcellation_func_masked_roi' + str(ip) + '.nii')
from pyhrf.ndarray import xndarray
parcellation = xndarray.load(pfile)
#m = xndarray.load(roi_mask_file)
#parcels_to_keep = np.unique(parcellation.data * m.data)
masked_parcellation = xndarray.xndarray_like(parcellation)
#for ip in parcels_to_keep:
# masked_parcellation.data[np.where(parcellation.data==ip)] = ip
masked_parcellation.data[np.where(parcellation.data==ip)] = ip
masked_parcellation.save(pfile_masked)
from pyhrf.ndarray import xndarray
for tmap in func_files:
func_file_i = xndarray.load(tmap)
func_data = func_file_i.data
#func_file_i.data[np.where(func_data<0.1*func_data.max())] = 0
parcellation = xndarray.load(pfile)
print func_data.max()
print func_data.argmax()
#ip = parcellation.data[func_data.argmax()]
ip = parcellation.data[np.unravel_index(func_data.argmax(), parcellation.data.shape)]
print ip.shape
masked_parcellation = xndarray.xndarray_like(parcellation)
print masked_parcellation.data.shape
print parcellation.data.shape
masked_parcellation.data[np.where(parcellation.data==ip)] = ip
masked_parcellation.save(tmap[:-4] + '_parcelmax.nii')
return pfile
