def get_dti(self, subj, instance=1):
"""Returns DTI image and b-values plus b-vectors
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the DTI dataset.
Returns
-------
NiBabel Nifti1Image, array, array
The first returned array the the vector of b-values for each volume
in the image file. The second array are the 3D b-vectors for each
volume in the image file.
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), "dti")
return (
nb.load(_opj(path, "dti%.3i.nii.gz" % instance)),
np.loadtxt(_opj(path, "dti%.3i.bvals" % instance)),
np.loadtxt(_opj(path, "dti%.3i.bvecs" % instance)).T,
)
def run_searchlight(op, subjectdir, conf, output_dir,TR=2):
mask_name = conf.mask_name
conditions = conf.conditions_to_compare
flavor = conf.flavor
study_path = op.study_dir()
subcode = subjectdir.subcode()
for condition in conditions:
did_run = True
output = _opj(output_dir, '*{}*'.format(conf.get_cond_prefix(condition)))
if conf.num_of_permutations > 0:
output = "{}_perm{}".format(output,conf.num_of_permutations)
if len(glob(output)) == 0:
did_run = False
if did_run:
print "already ran all sl for {}".format(output_dir)
return
fds = conf.get_ds(study_path, subcode, conf, mask_name, flavor, TR)
print fds.summary()
warp = glob(_opj(study_path,'sub{:0>3d}'.format(subcode), '**', conf.mvpa_tasks[0], 'reg', 'example_func2standard_warp.nii.gz'))[0]
if not os.path.exists(output_dir):
os.makedirs(output_dir)
for pair in conditions:
permute = AttributePermutator('condition', limit='chunks')
print conf.num_of_permutations+1
for j in xrange(conf.num_of_permutations+1):
prefix = conf.get_cond_prefix(pair)
cond_ds = fds[np.array([c in pair for c in fds.sa['condition']])]
if j > 0:
cond_ds = permute(cond_ds)
prefix = "{}_perm{}".format(prefix,j)
print prefix
output_basename = os.path.join(output_dir, prefix)
if(len(glob(output_basename+"*")) > 0):
print "sl already ran {}".format(j)
continue
kwa = {'voxel_indices': conf.get_neighbourhood_strategy(cond_ds)}
qe = IndexQueryEngine(**kwa)
# init the searchlight with the queryengine
sl = Searchlight(conf.get_sl_measure(), queryengine=qe, roi_ids=None,
enable_ca=['roi_sizes', 'roi_feature_ids'])
print "starting sl {}".format(datetime.now())
sl_map = sl(cond_ds)
print "finished sl {}".format(datetime.now())
pickle.dump(sl_map, open("{}_sl_map.p".format(output_basename), "wb"))
acc_results = map2nifti(sl_map,
imghdr=fds.a.imghdr)
acc_nii_filename = '{}-acc.nii.gz'.format(output_basename)
acc_results.to_filename(acc_nii_filename)
#do_searchlight(cond_ds,k,os.path.join(output_dir, prefix))
out_filename = acc_nii_filename.replace('.nii.gz', '_mni.nii.gz')
apply_warp(acc_nii_filename, warp, out_filename)
def perm_hist(subj):
conf = AnalysisConfiguration()
data_dir = os.environ.get('DATA_DIR') or '/home/user/data'
sub_dir = _opj(data_dir,conf.study_name,'sub{:0>3d}'.format(subj))
directory = _opj(data_dir,'LP/sub{:0>3d}/results/'.format(subj))
print conf.dir_name()
for pair in conf.conditions_to_compare:
#print _opj(directory,conf.dir_name(),'{}*{}{}*.p'.format(conf.mask_name,pair[0],pair[1]))
files = sorted(glob(_opj(directory,conf.dir_name(),'{}*{}{}*.p'.format(conf.mask_name,pair[0],pair[1]))))
plt.figure()
plt.subplot(211)
plt.title('sub{:0>3d}-{}{}'.format(subj,pair[0],pair[1]))
print pair, " ", len(files)
all_maps = []
for f in files[:-1]:
f_h = file(f,'r')
m = pickle.load(f_h)
all_maps.append(m)
if 'perm' in f:
color = 'black'
line_width = 1
else:
color = 'crimson'
line_width = 2
plt.hist(np.transpose(m),bins=20,histtype='step',color=[color], lw = line_width)
perms = vstack(all_maps)
real_f = files[-1]
f_h = file(real_f,'r')
real_map = pickle.load(f_h)
color = 'crimson'
line_width = 2
plt.hist(np.transpose(real_map),bins=20,histtype='step',color=[color], lw = line_width)
percentiles = np.zeros((1,len(real_map.samples[0])))
for i,vox in enumerate(real_map.samples[0]):
percentiles[0,i]=percentileofscore(perms[:,i].samples.flat,vox)
plt.subplot(212)
print len(percentiles[0])
plt.hist(percentiles[0],bins=20,histtype='step')
real_map.samples=percentiles
nii = real_f.replace("_sl_map.p", "-acc.nii.gz")
nii_file = nib.load(nii)
perc_results = map2nifti(real_map, imghdr=nii_file.header)
perc_nii_filename =real_f.replace("_sl_map.p", "-percentiles_sub{:0>3d}.nii.gz".format(subj))
perc_results.to_filename(perc_nii_filename)
thr_prc_filename = perc_nii_filename.replace(".nii.gz","_p0.01.nii.gz")
thr = fsl.maths.Threshold(in_file=perc_nii_filename, thresh=100,
out_file=thr_prc_filename)
thr.run()
mni_thr_filename = thr_prc_filename.replace(".nii.gz","_mni.nii.gz")
apply_warp(sub_dir,thr_prc_filename, mni_thr_filename)
plt.show()
#plt.savefig('/tmp/sub{:0>3d}_{}{}'.format(subj,pair[0],pair[1]))
raw_input()
def process_files(prefix, output_dir, thr,all_file, avg_file):
from scipy import ndimage
data = avg_file.get_data()
cluster_map, n_clusters = ndimage.label(data > thr)
output_file = _opj(output_dir, "{}_thr_{}.nii.gz".format(prefix, thr))
nib.save(nib.Nifti1Image(cluster_map, None, avg_file.header), output_file)
data = all_file.get_data()
thr_data = data > thr
res = np.sum(thr_data, 3)
output_file = _opj(output_dir, "{}_sum_thr_{}.nii.gz".format(prefix, thr))
nib.save(nib.Nifti1Image(res, None, avg_file.header), output_file)
return output_file
def main():
conf = AnalysisConfiguration()
data_dir = os.environ.get('DATA_DIR') or '/home/user/data'
op = OpenFMRIData(data_dir, conf.study_name)
analyzer = OpenFMRIAnalyzer(op, conf)
all_subject_dirs = op.all_subjects_dirs_with_raw()
for subject in all_subject_dirs:
analyzer.extract_brain(subject)
for subject in all_subject_dirs:
analyzer.anatomical_registration(subject)
for subject in all_subject_dirs:
#for task in conf.mvpa_tasks:
#subject.remove_volumes_from_model(1, "", task, conf.num_of_volumes_to_delete)
analyzer.motion_correction(subject)
analyzer.functional_registration(subject)
if conf.func_seg:
analyzer.functional_segmentation(subject)
else:
analyzer.segmentation(subject)
analyzer.generate_functional_gm_masks(subject)
#analyzer.warp_standard_mask(subject)
for subject in all_subject_dirs:
# DO SL
out_dir = _opj(subject.path(),'results',conf.dir_name())
if not os.path.exists(out_dir):
os.makedirs(out_dir)
run_searchlight(op, subject, conf, out_dir)
# run_searchlight(op.study_dir(), subject.subcode(), mask_name, k, [['G1','G4']], out_dir,flavor)
#Group Level
output_dir = _opj(op.study_dir(), 'results', "{}".format(conf.dir_name()))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
files = glob(_opj(op.study_dir(), "**", 'results', conf.dir_name(), '*acc_mni.nii.gz'))
print files
generate_group_level_map( files, output_dir)
def calc_summary_niis(in_files, output_dir, prefix):
all_file = _opj(output_dir, '{}_all.nii.gz'.format(prefix))
avg_file = _opj(output_dir, '{}_avg.nii.gz'.format(prefix))
merge = fsl.Merge(in_files=in_files,
dimension='t',
merged_file=all_file)
merge.run()
mean = fsl.maths.MeanImage(in_file=all_file, dimension='T', out_file=avg_file)
mean.run()
all_nii = nib.load(all_file)
avg_nii = nib.load(avg_file)
all_data = all_nii.get_data()
med_data = np.median(all_data,3)
output_file = _opj(output_dir, "{}_median.nii.gz".format(prefix))
nib.save(nib.Nifti1Image(med_data, None, avg_nii.header), output_file)
return all_nii, avg_nii
def get_run_fmri(self, subj, task, run, flavor='dico'):
"""Returns a NiBabel image instance for fMRI of a particular run
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
task : int
Task ID (see task_key.txt)
run : int
Run ID.
flavor : ('', 'dico', 'dico7Tad2grpbold7Tad', 'dico7Tad2grpbold7Tad_nl')
fMRI data flavor to access (see dataset description)
Returns
-------
NiBabel Nifti1Image
"""
import nibabel as nb
if flavor == '':
fname = 'bold.nii.gz'
elif flavor == 'dico':
fname = 'bold_dico.nii.gz'
else:
fname = 'bold_%s.nii.gz' % flavor
fname = _opj(self._basedir, _sub2id(subj), 'BOLD', _taskrun(task, run),
fname)
return nb.load(fname)
def get_run_physio_data(self, subj, task, run, sensors=None):
"""Returns the physiological recording for a particular run
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
task : int
Task ID (see task_key.txt)
run : int
Run ID.
sensors : None or tuple({'trigger', 'respiratory', 'cardiac', 'oxygen'})
Selection and order of values to return.
Returns
-------
array
Array of floats -- one row per sample (100Hz), if ``sensors`` is None,
4 columns are returned (trigger track, respiratory trace, cardiac trace,
oxygen saturation). If ``sensors`` is specified the order of columns
matches the order of the ``sensors`` sequence.
"""
fname = _opj(self._basedir, _sub2id(subj), 'physio',
_taskrun(task, run), 'physio.txt.gz')
sensor_map = {
'trigger': 0,
'respiratory': 1,
'cardiac': 2,
'oxygen': 3
}
if not sensors is None:
sensors = [sensor_map[s] for s in sensors]
data = np.loadtxt(fname, usecols=sensors)
return data
def get_model_conditions(self, model):
"""Returns a description of all conditions for a given model
Parameters
----------
model : int
Model identifier.
Returns
-------
list(dict)
A list of a model conditions is returned, where each item is a
dictionary with keys ``id`` (numerical condition ID), ``task``
(numerical task ID for the task containing this condition), and
``name`` (the literal condition name). This information is
returned in a list (instead of a dictionary), because the openfmri
specification of model conditions contains no unique condition
identifier. Conditions are only uniquely described by the combination
of task and condition ID.
"""
def_fname = _opj(self._basedir, 'models', _model2id(model),
'condition_key.txt')
def_data = np.recfromtxt(def_fname)
conds = []
# load model meta data
for dd in def_data:
cond = {}
cond['task'] = _id2int(dd[0])
cond['id'] = _id2int(dd[1])
cond['name'] = dd[2]
conds.append(cond)
return conds
def get_bold_run_image(self, subj, task, run, flavor=None):
"""Returns a NiBabel image instance for the BOLD data of a
particular subject/task/run combination.
Parameters
----------
subj : int
Subject identifier.
task : int
Task ID (see task_key.txt)
run : int
Run ID.
flavor : None or str
BOLD data flavor to access (see dataset description)
Returns
-------
NiBabel Nifti1Image
"""
import nibabel as nb
if flavor is None:
flavor = ''
else:
flavor = '_' + flavor
fname = 'bold%s.nii.gz' % flavor
fname = _opj(self._basedir, _sub2id(subj),
'BOLD', _taskrun(task, run),
fname)
return nb.load(fname)
def get_run_fmri(self, subj, task, run, flavor="dico"):
"""Returns a NiBabel image instance for fMRI of a particular run
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
task : int
Task ID (see task_key.txt)
run : int
Run ID.
flavor : ('', 'dico', 'dico7Tad2grpbold7Tad', 'dico7Tad2grpbold7Tad_nl')
fMRI data flavor to access (see dataset description)
Returns
-------
NiBabel Nifti1Image
"""
import nibabel as nb
if flavor == "":
fname = "bold.nii.gz"
elif flavor == "dico":
fname = "bold_dico.nii.gz"
else:
fname = "bold_%s.nii.gz" % flavor
fname = _opj(self._basedir, _sub2id(subj), "BOLD", _taskrun(task, run), fname)
return nb.load(fname)
def get_run_physio_data(self, subj, task, run, sensors=None):
"""Returns the physiological recording for a particular run
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
task : int
Task ID (see task_key.txt)
run : int
Run ID.
sensors : None or tuple({'trigger', 'respiratory', 'cardiac', 'oxygen'})
Selection and order of values to return.
Returns
-------
array
Array of floats -- one row per sample (100Hz), if ``sensors`` is None,
4 columns are returned (trigger track, respiratory trace, cardiac trace,
oxygen saturation). If ``sensors`` is specified the order of columns
matches the order of the ``sensors`` sequence.
"""
fname = _opj(self._basedir, _sub2id(subj), "physio", _taskrun(task, run), "physio.txt.gz")
sensor_map = {"trigger": 0, "respiratory": 1, "cardiac": 2, "oxygen": 3}
if not sensors is None:
sensors = [sensor_map[s] for s in sensors]
data = np.loadtxt(fname, usecols=sensors)
return data
def get_t2(self, subj, instance=1):
"""Returns T2-weighted scan.
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the T2 dataset.
Returns
-------
NiBabel Nifti1Image
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), 'anatomy', 'other')
return nb.load(_opj(path, 't2w%.3i.nii.gz' % instance))
def get_angio(self, subj, instance=1):
"""Returns angiography scan.
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the angio dataset.
Returns
-------
NiBabel Nifti1Image
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), 'angio')
return nb.load(_opj(path, 'angio%.3i.nii.gz' % instance))
def _subdirs2ids(path, prefix, **kwargs):
ids = []
if not os.path.exists(path):
return ids
for item in os.listdir(path):
if item.startswith(prefix) and os.path.isdir(_opj(path, item)):
ids.append(_id2int(item, **kwargs))
return sorted(ids)
def get_task_descriptions(self):
"""Returns a dictionary with the tasks defined in the dataset
Dictionary keys are integer task IDs, values are task description
strings.
"""
fname = _opj(self._basedir, 'task_key.txt')
return _get_description_dict(fname, xfm_key=_id2int)
def _subdirs2ids(path, prefix, **kwargs):
ids = []
if not os.path.exists(path):
return ids
for item in os.listdir(path):
if item.startswith(prefix) and os.path.isdir(_opj(path, item)):
ids.append(_id2int(item, **kwargs))
return sorted(ids)
def get_task_descriptions(self):
"""Return a dictionary with the tasks defined in the dataset
Dictionary keys are integer task IDs, values are task description
strings.
"""
fname = _opj(self.basedir, 'task_key.txt')
return _get_description_dict(fname, xfm_key=_id2int)
def get_angio(self, subj, instance=1):
"""Returns angiography scan.
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the angio dataset.
Returns
-------
NiBabel Nifti1Image
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), "angio")
return nb.load(_opj(path, "angio%.3i.nii.gz" % instance))
def get_t2(self, subj, instance=1):
"""Returns T2-weighted scan.
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the T2 dataset.
Returns
-------
NiBabel Nifti1Image
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), "anatomy", "other")
return nb.load(_opj(path, "t2w%.3i.nii.gz" % instance))
def get_fieldmap(self, subj, instance=1):
"""Returns fieldmap scan.
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the fieldmap dataset.
Returns
-------
NiBabel Nifti1Image, Nifti1Image
Magnitude and phase image.
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), 'fieldmap')
return nb.load(_opj(path, 'fieldmap%.3i_mag.nii.gz' % instance)), \
nb.load(_opj(path, 'fieldmap%.3i_pha.nii.gz' % instance))
def get_swi(self, subj, instance=1):
"""Returns susceptibility-weighted scan.
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the SWI dataset.
Returns
-------
NiBabel Nifti1Image, Nifti1Image
Magnitude and phase image.
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), 'anatomy', 'other')
return nb.load(_opj(path, 'swi%.3i_mag.nii.gz' % instance)), \
nb.load(_opj(path, 'swi%.3i_pha.nii.gz' % instance))
def _subdirs2ids(path, prefix, **kwargs):
# num_ids to separate sorting of numeric and literal ids
ids, num_ids = [], []
if not os.path.exists(path):
return ids
for item in os.listdir(path):
if item.startswith(prefix) and os.path.isdir(_opj(path, item)):
id_ = _id2int(item, **kwargs)
(num_ids if isinstance(id_, (np.integer, int)) else ids).append(id_)
return sorted(num_ids) + sorted(ids)
def get_model_descriptions(self):
"""Returns a dictionary with the models described in the dataset
Dictionary keys are integer model IDs, values are description strings.
Note that the return dictionary is not necessarily comprehensive. It
only reflects the models described in ``model_key.txt``. If a dataset
is inconsistently described, ``get_model_ids()`` actually may discover
more or less models in comparison to the avauilable model descriptions.
"""
fname = _opj(self._basedir, 'model_key.txt')
return _get_description_dict(fname, xfm_key=_id2int)
def apply_warp(sub_dir, in_file, out_file):
# warp_file = _opj(sub_dir,'anatomy','reg','highres2standard_warp.nii.gz')
# pre_mat_file = _opj(sub_dir,'BOLD','task001','reg','example_func2highres.mat')
warp_file = _opj(sub_dir,'BOLD','task001','reg','example_func2standard_warp.nii.gz')
standard_image = fsl.Info.standard_image('MNI152_T1_2mm_brain.nii.gz')
apply_warp = fsl.preprocess.ApplyWarp(ref_file=standard_image,
in_file=in_file,
field_file=warp_file,
#premat=pre_mat_file,
interp='trilinear',
out_file=out_file)
apply_warp.run()
def get_scene_boundaries(self):
"""Returns the boundaries between scenes in movie time
Returns
-------
list(float)
Timestamps are given in seconds.
"""
fname = _opj(self._basedir, "stimulus", "task001", "annotations", "scenes.csv")
cr = csv.reader(open(fname))
ts = [float(line[0]) for line in cr]
return ts
def get_model_descriptions(self):
"""Return a dictionary with the models described in the dataset
Dictionary keys are integer model IDs, values are description strings.
Note that the return dictionary is not necessarily comprehensive. It
only reflects the models described in ``model_key.txt``. If a dataset
is inconsistently described, ``get_model_ids()`` actually may discover
more or less models in comparison to the avauilable model descriptions.
"""
fname = _opj(self.basedir, 'model_key.txt')
return _get_description_dict(fname, xfm_key=_id2int)
def get_dti(self, subj, instance=1):
"""Returns DTI image and b-values plus b-vectors
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the DTI dataset.
Returns
-------
NiBabel Nifti1Image, array, array
The first returned array the the vector of b-values for each volume
in the image file. The second array are the 3D b-vectors for each
volume in the image file.
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), 'dti')
return nb.load(_opj(path, 'dti%.3i.nii.gz' % instance)), \
np.loadtxt(_opj(path, 'dti%.3i.bvals' % instance)), \
np.loadtxt(_opj(path, 'dti%.3i.bvecs' % instance)).T
def get_swi(self, subj, instance=1):
"""Returns susceptibility-weighted scan.
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the SWI dataset.
Returns
-------
NiBabel Nifti1Image, Nifti1Image
Magnitude and phase image.
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), "anatomy", "other")
return (
nb.load(_opj(path, "swi%.3i_mag.nii.gz" % instance)),
nb.load(_opj(path, "swi%.3i_pha.nii.gz" % instance)),
)
def get_scene_boundaries(self):
"""Returns the boundaries between scenes in movie time
Returns
-------
list(float)
Timestamps are given in seconds.
"""
fname = _opj(self._basedir, 'stimulus', 'task001', 'annotations',
'scenes.csv')
cr = csv.reader(open(fname))
ts = [float(line[0]) for line in cr]
return ts
def get_fieldmap(self, subj, instance=1):
"""Returns fieldmap scan.
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
instance : int
ID of the fieldmap dataset.
Returns
-------
NiBabel Nifti1Image, Nifti1Image
Magnitude and phase image.
"""
import nibabel as nb
path = _opj(self._basedir, _sub2id(subj), "fieldmap")
return (
nb.load(_opj(path, "fieldmap%.3i_mag.nii.gz" % instance)),
nb.load(_opj(path, "fieldmap%.3i_pha.nii.gz" % instance)),
)
def make_ds(sub, datapath, flavor):
of = OpenFMRIDataset(datapath)
ds = of.get_model_bold_dataset(
model_id=1,
subj_id=sub,
flavor=flavor,
mask=_opj(datapath, 'sub%.3i' % sub, 'masks', 'task001_run001',
'grey.nii.gz'),
#preproc_img=smooth,
preproc_ds=detrend,
modelfx=fit_event_hrf_model,
time_attr='time_coords',
condition_attr='condition')
ds14 = ds[np.array([c in ['G1', 'G4'] for c in ds.sa['condition']])]
ds23 = ds[np.array([c in ['G2', 'G3'] for c in ds.sa['condition']])]
result_dir = _opj(datapath, 'mvpa', 'ds', flavor)
if not os.path.isdir(result_dir):
os.makedirs(result_dir)
print "{:0>3d}-ds14 {},{}".format(sub, ds14.shape, ds14.sa.condition)
print "{:0>3d}-ds23 {},{}".format(sub, ds23.shape, ds23.sa.condition)
h5save(_opj(result_dir, 'sub%.3i_14_hrf.hdf5' % sub), ds14)
h5save(_opj(result_dir, 'sub%.3i_23_hrf.hdf5' % sub), ds23)
def create_betas_per_trial_with_pymvpa_roni(study_path, subj, conf, mask_name, flavor, TR):
dhandle = OpenFMRIDataset(study_path)
model = 1
task = 1
# Do this for other tasks as well. not only the first
mask_fname = _opj(study_path, "sub{:0>3d}".format(subj), "masks", conf.mvpa_tasks[0], "{}.nii.gz".format(mask_name))
print mask_fname
run_datasets = []
for run_id in dhandle.get_task_bold_run_ids(task)[subj]:
if type(run_id) == str:
continue
# all_events = dhandle.get_bold_run_model(model, subj, run_id)
all_events = get_bold_run_model(dhandle, 2, subj, run_id)
run_events = []
i = 0
for event in all_events:
if event["task"] == task:
event["condition"] = "{}-{}".format(event["condition"], event["id"])
run_events.append(event)
i += 1
# load BOLD data for this run (with masking); add 0-based chunk ID
run_ds = dhandle.get_bold_run_dataset(subj, task, run_id, flavor=flavor, chunks=run_id - 1, mask=mask_fname)
# convert event info into a sample attribute and assign as 'targets'
run_ds.sa.time_coords = run_ds.sa.time_indices * TR
run_ds.sa["targets"] = events2sample_attr(run_events, run_ds.sa.time_coords, noinfolabel="rest")
# additional time series preprocessing can go here
poly_detrend(run_ds, polyord=1, chunks_attr="chunks")
zscore(run_ds, chunks_attr="chunks", param_est=("targets", ["rest"]), dtype="float32")
glm_dataset = fit_event_hrf_model(run_ds, run_events, time_attr="time_coords", condition_attr="condition")
glm_dataset.sa["targets"] = [x[: x.find("-")] for x in glm_dataset.sa.condition]
glm_dataset.sa["id"] = [x[x.find("-") + 1 :] for x in glm_dataset.sa.condition]
glm_dataset.sa.condition = glm_dataset.sa["targets"]
glm_dataset.sa["chunks"] = [run_id - 1] * len(glm_dataset.samples)
# If a trial was dropped (the subject pressed on a button) than the counter trial from the
# other condition should also be dropped
for pair in conf.conditions_to_compare:
cond_bool = np.array([c in pair for c in glm_dataset.sa["condition"]])
sub_dataset = glm_dataset[cond_bool]
c = Counter(sub_dataset.sa.id)
for value in c:
if c[value] < 2:
id_bool = np.array([value in cond_id for cond_id in glm_dataset.sa["id"]])
glm_dataset = glm_dataset[np.bitwise_not(np.logical_and(id_bool, cond_bool))]
run_datasets.append(glm_dataset)
return vstack(run_datasets, 0)
def make_ds(sub, datapath, flavor):
of = OpenFMRIDataset(datapath)
ds = of.get_model_bold_dataset(
model_id=1,
subj_id=sub,
flavor=flavor,
mask=_opj(datapath, "sub%.3i" % sub, "masks", "task001_run001", "grey.nii.gz"),
# preproc_img=smooth,
preproc_ds=detrend,
modelfx=fit_event_hrf_model,
time_attr="time_coords",
condition_attr="condition",
)
ds14 = ds[np.array([c in ["G1", "G4"] for c in ds.sa["condition"]])]
ds23 = ds[np.array([c in ["G2", "G3"] for c in ds.sa["condition"]])]
result_dir = _opj(datapath, "mvpa", "ds", flavor)
if not os.path.isdir(result_dir):
os.makedirs(result_dir)
print "{:0>3d}-ds14 {},{}".format(sub, ds14.shape, ds14.sa.condition)
print "{:0>3d}-ds23 {},{}".format(sub, ds23.shape, ds23.sa.condition)
h5save(_opj(result_dir, "sub%.3i_14_hrf.hdf5" % sub), ds14)
h5save(_opj(result_dir, "sub%.3i_23_hrf.hdf5" % sub), ds23)
def create_betas_per_run_with_pymvpa(study_path, subj, conf, mask_name, flavor):
of = OpenFMRIDataset(study_path)
mask_fname = _opj(study_path, "sub{:0>3d}".format(subj), "masks", conf.mvpa_tasks[0], "{}.nii.gz".format(mask_name))
ds = of.get_model_bold_dataset(
model_id=1,
subj_id=subj,
flavor=flavor,
mask=mask_fname,
# preproc_img=smooth,
preproc_ds=detrend,
modelfx=fit_event_hrf_model,
time_attr="time_coords",
condition_attr="condition",
)
return ds
def get_bold_run_model(self, model, subj, run):
"""Returns the stimulation design for a particular subject/task/run.
Parameters
----------
model : int
Model identifier.
subj : int
Subject identifier.
run : int
Run ID.
Returns
-------
dict
Nested dictionary for all tasks and conditions contained in a
particular model. First-level keys are task IDs. Second-level keys
are condition IDs. Second-level values are rec-arrays with fields
'onset', 'duration', 'intensity'.
"""
conditions = self.get_model_conditions(model)
events = []
ev_fields = ('onset', 'duration', 'intensity')
# get onset info for specific subject/task/run combo
for cond in conditions:
task_id = cond['task']
task_descr = self.get_task_descriptions()[task_id]
stim_fname = _opj(self._basedir, _sub2id(subj), 'model',
_model2id(model), 'onsets',
_taskrun(task_id, run),
'%s.txt' % _cond2id(cond['id']))
try:
evdata = np.atleast_1d(
np.recfromtxt(stim_fname, names=ev_fields))
except IOError:
warning("onset definition file '%s' not found; no information "
"about condition '%s' for run %i"
% (stim_fname, cond['name'], run))
continue
for ev in evdata:
evdict = dict(zip(ev_fields,
[ev[field] for field in ev_fields]))
evdict['task'] = task_descr
evdict['condition'] = cond['name']
evdict['run'] = run
events.append(evdict)
return events
def get_bold_run_ids(self, subj, task):
"""Returns (sorted) list of run IDs for a given subject and task
Typically, run IDs are integer values, but string IDs are supported
as well.
Parameters
----------
subj : int or str
Subject ID
task : int or str
Run ID
"""
task_prefix = _prefix('task', task)
return _subdirs2ids(_opj(self._basedir, _sub2id(subj), 'BOLD'),
'%s_' % (task_prefix,),
strip=len(task_prefix) + 4)
def get_bold_run_ids(self, subj, task):
"""Return (sorted) list of run IDs for a given subject and task
Typically, run IDs are integer values, but string IDs are supported
as well.
Parameters
----------
subj : int or str
Subject ID
task : int or str
Run ID
"""
task_prefix = _prefix('task', task)
return _subdirs2ids(_opj(self.basedir, _sub2id(subj), 'BOLD'),
'%s_' % (task_prefix, ),
strip=len(task_prefix) + 4)
def make_ds(sub, datapath, flavor): of = OpenFMRIDataset(datapath) ds = of.get_model_bold_dataset( model_id=1, subj_id=sub, #ds = of.get_bold_run_dataset(1,1,1, flavor=flavor, mask=_opj( datapath, 'sub%.3i' % sub, 'masks', 'task001_run001', 'grey.nii.gz'), #preproc_img=smooth, #preproc_ds = detrend, #modelfx=fit_event_hrf_model, time_attr='time_coords', condition_attr='condition') for i in np.unique(ds.chunks)[5:]: detrend(ds[ds.chunks == i])
def get_german_audiodescription_transcript(self):
"""Returns the transcript with star and end timestamps
Returns
-------
array(float, float), list(str)
The first return value is a 2-column array with start and end timestamp
of each narration sequence. The second return value is a list with the
corresponding transcripts in UTF8 encoding.
"""
fname = _opj(self._basedir, "stimulus", "task001", "annotations", "german_audio_description.csv")
cr = csv.reader(open(fname))
transcripts = []
ts = []
for line in cr:
ts.append([float(i) for i in line[:2]])
transcripts.append(line[2])
return np.array(ts), transcripts
def get_german_audiodescription_transcript(self):
"""Returns the transcript with star and end timestamps
Returns
-------
array(float, float), list(str)
The first return value is a 2-column array with start and end timestamp
of each narration sequence. The second return value is a list with the
corresponding transcripts in UTF8 encoding.
"""
fname = _opj(self._basedir, 'stimulus', 'task001', 'annotations',
'german_audio_description.csv')
cr = csv.reader(open(fname))
transcripts = []
ts = []
for line in cr:
ts.append([float(i) for i in line[:2]])
transcripts.append(line[2])
return np.array(ts), transcripts
def get_run_motion_estimates(self, subj, task, run):
"""Returns the motion correction estimates for a particular run
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
task : int
Task ID (see task_key.txt)
run : int
Run ID.
Returns
-------
array
Array of floats -- one row per fMRI volume, 6 columns (first three:
translation X, Y, Z in mm, last three: rotation in deg)
"""
fname = _opj(self._basedir, _sub2id(subj), "BOLD", _taskrun(task, run), "bold_dico_moco.txt")
data = np.loadtxt(fname)
return data
def get_run_motion_estimates(self, subj, task, run):
"""Returns the motion correction estimates for a particular run
Parameters
----------
subj : int or str
Subject identifier (without 'sub' prefix).
task : int
Task ID (see task_key.txt)
run : int
Run ID.
Returns
-------
array
Array of floats -- one row per fMRI volume, 6 columns (first three:
translation X, Y, Z in mm, last three: rotation in deg)
"""
fname = _opj(self._basedir, _sub2id(subj), 'BOLD', _taskrun(task, run),
'bold_dico_moco.txt')
data = np.loadtxt(fname)
return data
def create_betas_per_trial_with_pymvpa(study_path, subj, conf, mask_name, flavor, TR):
dhandle = OpenFMRIDataset(study_path)
model = 1
task = 1
# Do this for other tasks as well. not only the first
mask_fname = _opj(study_path, "sub{:0>3d}".format(subj), "masks", conf.mvpa_tasks[0], "{}.nii.gz".format(mask_name))
print mask_fname
run_datasets = []
for run_id in dhandle.get_task_bold_run_ids(task)[subj]:
if type(run_id) == str:
continue
all_events = dhandle.get_bold_run_model(model, subj, run_id)
run_events = []
i = 0
for event in all_events:
if event["task"] == task:
event["condition"] = "{}-{}".format(event["condition"], i)
run_events.append(event)
i += 1
# load BOLD data for this run (with masking); add 0-based chunk ID
run_ds = dhandle.get_bold_run_dataset(subj, task, run_id, flavor=flavor, chunks=run_id - 1, mask=mask_fname)
# convert event info into a sample attribute and assign as 'targets'
run_ds.sa.time_coords = run_ds.sa.time_indices * TR
print run_id
run_ds.sa["targets"] = events2sample_attr(run_events, run_ds.sa.time_coords, noinfolabel="rest")
# additional time series preprocessing can go here
poly_detrend(run_ds, polyord=1, chunks_attr="chunks")
zscore(run_ds, chunks_attr="chunks", param_est=("targets", ["rest"]), dtype="float32")
glm_dataset = fit_event_hrf_model(run_ds, run_events, time_attr="time_coords", condition_attr="condition")
glm_dataset.sa["targets"] = [x[: x.find("-")] for x in glm_dataset.sa.condition]
glm_dataset.sa.condition = glm_dataset.sa["targets"]
glm_dataset.sa["chunks"] = [run_id - 1] * len(glm_dataset.samples)
run_datasets.append(glm_dataset)
return vstack(run_datasets, 0)
def main():
conf = AnalysisConfiguration()
data_dir = os.environ.get('DATA_DIR') or '/home/daniel/fsl-analysis/data'
op = OpenFMRIData(data_dir, conf.study_name)
analyzer = OpenFMRIAnalyzer(op, conf)
all_subject_dirs = op.all_subjects_dirs_with_raw()
for subject in all_subject_dirs:
analyzer.extract_brain(subject)
for subject in all_subject_dirs:
analyzer.anatomical_registration(subject)
for subject in all_subject_dirs:
#for task in conf.mvpa_tasks:
#subject.remove_volumes_from_model(1, "", task, conf.num_of_volumes_to_delete)
analyzer.motion_correction(subject)
analyzer.functional_registration(subject)
if conf.func_seg:
analyzer.functional_segmentation(subject)
else:
analyzer.segmentation(subject)
analyzer.generate_functional_gm_masks(subject)
#analyzer.warp_standard_mask(subject)
for subject in all_subject_dirs:
# DO SL
out_dir = _opj(subject.path(),'results',conf.dir_name())
if not os.path.exists(out_dir):
os.makedirs(out_dir)
run_searchlight(op, subject, conf, out_dir)
from mvpa2.base.hdf5 import h5load, h5save
from mvpa2.datasets import Dataset
from mvpa2.datasets.mri import map2nifti
from mvpa2.algorithms.group_clusterthr import GroupClusterThreshold
orig = []
perms = []
perm_count = []
subj_ids = range(1, 21)
# load all subjs
print 'Loading subjs', time.asctime()
for subj in subj_ids:
print 'Loading subj %i' % subj
sds = h5load(_opj('grp_results', 'grpspace_sub%.3i.hdf5' % subj))
orig.append(sds.samples[0])
perms.append(sds.samples[1:])
perm_count.append(len(sds) - 1)
print 'Merge data', time.asctime()
orig_ds = Dataset(orig, sa=dict(subj=subj_ids), fa=sds.fa, a=sds.a)
perm_ds = Dataset(np.vstack(perms),
sa=dict(subj=np.repeat(subj_ids, perm_count)),
fa=sds.fa,
a=sds.a)
# some magic to drop the memory demand
del orig
del perms
print 'Train thresholder', time.asctime()
from os.path import join as _opj from mvpa2.datasets.sources import OpenFMRIDataset datapath = "/home/data/psyinf/forrest_gump/anondata" logpath = _opj(os.path.dirname(datapath), 'condor_logs') # dataset handler of = OpenFMRIDataset(datapath) # preamble for a condor submit file condor_submit_preamble = """ universe = vanilla output = %(logpath)s/$(CLUSTER).$(PROCESS).out error = %(logpath)s/$(CLUSTER).$(PROCESS).err log = %(logpath)s/$(CLUSTER).$(PROCESS).log initialdir = %(datapath)s getenv = True should_transfer_files = NO transfer_executable = False """ % dict(datapath=datapath, logpath=logpath)
def main():
sub = int(sys.argv[1])
data_dir = os.environ.get('DATA_DIR') or '/home/user/data'
study_name = os.environ.get('STUDY_NAME') or 'LP'
flavor = 'mcf'
make_ds(sub, _opj(data_dir, study_name), flavor)
datapath = 'BASEDIR'
of = OpenFMRIDataset(datapath)
sub = int(sys.argv[1]) + 1
def smooth(img):
# we need to preserve the original header because the smoothing function
# f***s the TR up
nimg = smooth_img(img, fwhm=2.0)
return nb.Nifti1Image(nimg.get_data(),
img.get_affine(),
header=img.get_header())
ds = of.get_model_bold_dataset(
model_id=1,
subj_id=sub,
flavor='dico_bold7Tp1_to_subjbold7Tp1',
# full brain
mask=_opj(datapath, 'sub%.3i' % sub, 'templates', 'bold7Tp1', 'qa',
'jointfgbrainmask_bold7Tp1_to_subjbold7Tp1.nii.gz'),
preproc_img=smooth,
# HP filtering is done by NiPy's GLM
modelfx=fit_event_hrf_model,
time_attr='time_coords',
condition_attr='condition')
h5save(_opj('data', 'sub%.3i_2.0mm_hrf.hdf5' % sub), ds)
def get_model_ids(self):
"""Return a sorted list of integer IDs for all available models"""
return _subdirs2ids(_opj(self.basedir, 'models'), 'model')
def get_bold_run_dataset(self,
subj,
task,
run,
flavor=None,
preproc_img=None,
add_sa=None,
**kwargs):
"""Return a dataset instance for the BOLD data of a particular
subject/task/run combination.
This method support the same functionality as fmri_dataset(), while
wrapping get_bold_run_image() to access the input fMRI data. Additional
attributes, such as subject ID, task ID, and run ID are automatically
stored as dataset sample attributes.
Parameters
----------
subj : int
Subject identifier.
task : int
Task ID (see task_key.txt)
run : int
Run ID.
flavor : None or str
BOLD data flavor to access (see dataset description). If ``flavor``
corresponds to an existing file in the respective task/run directory,
it is assumed to be a stored dataset in HDF5 format and loaded via
``h5load()`` -- otherwise datasets are constructed from NIfTI images.
preproc_img : callable or None
If not None, this callable will be called with the loaded source BOLD
image instance as an argument before fmri_dataset() is executed.
The callable must return an image instance.
add_sa: str or tuple(str)
Single or sequence of names of files in the respective BOLD
directory containing additional samples attributes. At this time
all formats supported by NumPy's loadtxt() are supported.
The number of lines in such a file needs to match the number of
BOLD volumes. Each column is converted into a separate dataset
sample attribute. The file name with a column index suffix is used
to determine the attribute name.
**kwargs:
All additional arguments are passed on to fmri_dataset()
Returns
-------
Dataset
"""
from mvpa2.datasets.mri import fmri_dataset
# check whether flavor corresponds to a particular file
if flavor is not None:
path = _opj(self.basedir, _sub2id(subj), 'BOLD',
_taskrun(task, run), flavor)
if flavor is not None and os.path.exists(path):
from mvpa2.base.hdf5 import h5load
ds = h5load(path)
else:
bold_img = self.get_bold_run_image(subj, task, run, flavor=flavor)
if preproc_img is not None:
bold_img = preproc_img(bold_img)
# load (and mask) data
ds = fmri_dataset(bold_img, **kwargs)
# inject sample attributes
for name, var in (('subj', subj), ('task', task), ('run', run)):
ds.sa[name] = np.repeat(var, len(ds))
if add_sa is None:
return ds
if isinstance(add_sa, str):
add_sa = (add_sa, )
for sa in add_sa:
# TODO: come up with a fancy way of detecting what kind of thing
# we are accessing -- in any case: first axis needs to match
# nsamples
attrs = self._load_bold_task_run_data(subj, task, run, [sa],
np.loadtxt)
if len(attrs.shape) == 1:
ds.sa[sa] = attrs
else:
for col in range(attrs.shape[1]):
ds.sa['%s_%i' % (sa, col)] = attrs[:, col]
return ds
def _load_data(self, path, loadfx):
# little helper to access stuff in datasets
path = _opj(self.basedir, *path)
return loadfx(path)
def get_scan_properties(self):
"""Return a dictionary with the scan properties listed in scan_key.txt
"""
fname = _opj(self.basedir, 'scan_key.txt')
return _get_description_dict(fname)
def get_model_ids(self):
"""Returns a sorted list of integer IDs for all available models"""
return _subdirs2ids(_opj(self._basedir, 'models'), 'model')
import nibabel as nb
from mvpa2.base.hdf5 import h5load, h5save
from mvpa2.datasets.mri import map2nifti, fmri_dataset
# +1 to be compatible with condor submission
subj = int(sys.argv[1]) + 1
res_dir = 'grp_results'
if not os.path.exists(res_dir):
os.makedirs(res_dir)
# because the stored SL results have no proper imghdr
subjtmpl = nb.load('BASEDIR/sub%.3i/templates/bold7Tp1/head.nii.gz' % subj)
# orig results
ds = h5load(_opj('results', 'sub%.3i_2.0mm_hrf_sl_orig.hdf5' % subj))
# load permutations and merge with orig results
data = np.vstack([ds.samples[0]] + [
np.load(fname) for fname in sorted(
glob(_opj('results', 'sub%.3i_2.0mm_hrf_sl_perm*.npy' % subj)))
])
#data = ds.samples
# write out as NIfTI
tdir = mkdtemp()
print tdir
orig_fname = _opj(tdir, 'data_in_orig.nii.gz')
group_fname = _opj(tdir, 'data_in_group.nii.gz')
nb.save(map2nifti(ds, data, imghdr=subjtmpl.get_header()), orig_fname)
# project into group space
