def main():
if not os.path.isdir(MEM_DIR):
os.mkdir(MEM_DIR)
mem = Memory(base_dir=MEM_DIR)
layout = BIDSLayout(BIDS_DIR)
# func_files[subject_index][run_index]
if num_runs > 1:
func_files = [[
layout.get(type='bold',
task=task,
run=i + 1,
subject=subj,
extensions='nii.gz')[0] for i in range(num_runs)
] for subj in SUBJECTS]
else:
func_files = [
layout.get(type='bold',
task=task,
subject=subj,
extensions='nii.gz') for subj in SUBJECTS
]
events = get_events(func_files)
confounds = get_confounds(func_files)
info = get_info(events, confounds)
specify_model_results = specify_model(layout, func_files, info)
level1design_results = lv1_design(mem, layout, func_files,
specify_model_results)
modelgen_results = feat_model(mem, level1design_results)
mask_results = masking(mem, func_files)
film_gls(mem, mask_results, modelgen_results)
def get_bids_surf_data(path_bids, subject, session, output_dir):
"""
Function to get the aparcaseg and the pre-processed BOLD fmri filepaths from BIDS dataset
"""
from bids.grabbids import BIDSLayout
from os.path import join as opj
import os
layout = BIDSLayout(path_bids)
try:
layout_surfs = layout.get(space="fsaverage",
subject=subject,
session=session)
surfaces = [hemisphere.filename for hemisphere in layout_surfs]
if surfaces[0].find(".R.") != -1:
rh_surf, lh_surf = surfaces[0], surfaces[1]
else:
rh_surf, lh_surf = surfaces[1], surfaces[0]
confounds = layout.get(type="confounds",
subject=subject,
session=session)[0].filename
prefix = "sub-" + subject + "_ses-" + session + "_task-" + layout_surfs[
0].task + "-fsaverage_"
except IndexError:
raise Exception("Data missing for subject : {}, session : {}".format(
subject, session))
outDir = opj(output_dir, "sub-" + subject, "ses-" + session, "func")
if not os.path.exists(outDir):
print("\n\n{} created\n\n".format(outDir))
os.makedirs(outDir)
return lh_surf, rh_surf, confounds, outDir, prefix
def get_nifti_filenames(subject_id,data_dir):
# Remember that all the necesary imports need to be INSIDE the function for the Function Interface to work!
from bids.grabbids import BIDSLayout
layout = BIDSLayout(data_dir) # TODO takes lot of time to execute. Move it out in the next version
# DEBUG Tried moving out. gave deep copy error..
run = 1
session = 1
if session != 0:
anat_file_path = [f.filename for f in layout.get(subject=subject_id, type='T1w', session = session, run=run, extensions=['nii', 'nii.gz'])]
func_file_path = [f.filename for f in layout.get(subject=subject_id, type='bold',session = session, run=run, extensions=['nii', 'nii.gz'])]
else:
anat_file_path = [f.filename for f in layout.get(subject=subject_id, type='T1w' , extensions=['nii', 'nii.gz'])]
func_file_path = [f.filename for f in layout.get(subject=subject_id, type='bold', run=run, extensions=['nii', 'nii.gz'])]
if len(func_file_path) == 0:
print('Error with subject ID %s' % subject_id )
raise Exception('No Functional File with subject ID %s' % subject_id)
if len(anat_file_path) == 0:
return None, func_file_path[0] # No Anatomical files present
return anat_file_path[0],func_file_path[0]
def _get_func_and_confounds(fmriprep_folder, sourcedata_folder):
fmriprep_layout = BIDSLayout(fmriprep_folder)
sourcedata_layout = BIDSLayout(sourcedata_folder)
files = fmriprep_layout.get(extensions=['.nii', 'nii.gz'],
modality='func',
type='preproc')
confounds = []
metadata = []
for f in files:
kwargs = {}
for key in ['subject', 'run', 'task', 'session']:
if hasattr(f, key):
kwargs[key] = getattr(f, key)
c = fmriprep_layout.get(type='confounds', **kwargs)
c = c[0]
confounds.append(c)
sourcedata_file = sourcedata_layout.get(modality='func',
extensions='nii.gz',
**kwargs)
assert (len(sourcedata_file) == 1)
md = sourcedata_layout.get_metadata(sourcedata_file[0].filename)
metadata.append(md)
return list(zip(files, confounds, metadata))
def get_BidsData(pathBids, subject, session, outputDir):
"""
Function to get the aparcaseg and the pre-processed BOLD fmri filepaths from BIDS dataset
"""
from bids.grabbids import BIDSLayout
from os.path import join as opj
import os
layout = BIDSLayout(pathBids)
try:
prep = layout.get(type="preproc",
space="T1w",
subject=subject,
session=session)[0]
aparcaseg = layout.get(type="roi",
label="aparcaseg",
space="T1w",
subject=subject,
session=session)[0].filename
preproc = prep.filename
confounds = layout.get(type="confounds",
subject=subject,
session=session)[0].filename
prefix = "sub-" + prep.subject + "_ses-" + prep.session + "_task-" + prep.task + "-" + prep.type + "_"
except IndexError:
raise Exception("Data missing for subject : {}, session : {}".format(
subject, session))
outDir = opj(outputDir, "sub-" + subject, "ses-" + session, "func")
if not os.path.exists(outDir):
os.makedirs(outDir)
return aparcaseg, preproc, confounds, outDir, prefix
def volumeCorrect(data_directory, subject_list, run=1, session=None, vols=None):
'''
load BIDS data grabber
load the VOLUMES from metadata for each subject
Create a Sub_ID_VOlumes dict
select subjects that have volumes > threshold
'''
from bids.grabbids import BIDSLayout
print('Data Directory %s'% data_directory)
print('Run %s Session %s'%(run,session))
# = '/mnt/project1/home1/varunk/data/ABIDE2RawDataBIDS'
layout = BIDSLayout(data_directory)
# subjects = layout.get_subjects()
subjects = subject_list
subid_vol_dict = {}
subject_list = []
for subject_id in subjects:
if session == None:
func_file_path = [f.filename for f in layout.get(subject=subject_id, type='bold', run=run, extensions=['nii', 'nii.gz'])]
if len(func_file_path) == 0:
print('No Func file: %s'%subject_id)
continue
else:
func_file_path = [f.filename for f in layout.get(subject=subject_id, type='bold',session = session[0], run=run, extensions=['nii', 'nii.gz'])]
if len(func_file_path) == 0:
func_file_path = [f.filename for f in layout.get(subject=subject_id, type='bold',session = session[1], run=run, extensions=['nii', 'nii.gz'])]
if len(func_file_path) == 0:
print('No Func file: %s'%subject_id)
continue
# print(func_file_path)
metadata = layout.get_metadata(path=func_file_path[0])
volumes = metadata['NumberofMeasurements']
try:
volumes = int(volumes)
except ValueError:
# Mixed Volumes site
brain_img = nib.load(func_file_path[0])
volumes = brain_img.shape[-1]
if volumes >= vols:
subid_vol_dict[subject_id] = volumes
subject_list.append(subject_id)
return subject_list, subid_vol_dict
def collect_bids_data(dataset,
participant_label=None,
session=None,
run=None,
queries=None,
modalities=None):
"""Get files in dataset"""
# Start a layout
layout = BIDSLayout(dataset)
# Find all sessions
if session:
session_list = [session]
else:
session_list = layout.unique('session')
if session_list == []:
session_list = [None]
# Find all runs
if run:
run_list = [run]
else:
run_list = layout.unique('run')
if run_list == []:
run_list = [None]
# Set modalities
if modalities is None:
modalities = deepcopy(DEFAULT_MODALITIES)
# Set queries
if queries is None:
queries = deepcopy(DEFAULT_QUERIES)
# Set participants
if participant_label is not None:
if not isinstance(participant_label, list):
for key in queries.keys():
queries[key]['subject'] = participant_label
else:
participant_label = ['{}'.format(sub) for sub in participant_label]
participant_label = [
sub[4:] if sub.startswith('sub-') else sub
for sub in participant_label
]
# For some reason, outer subject ids are filtered out
participant_label.insert(0, 'null')
participant_label.append('null')
for key in queries.keys():
queries[key]['subject'] = 'sub-\\(' + '|'.join(
participant_label) + '\\){1}'
# Start querying
imaging_data = {}
for mod in modalities:
imaging_data[mod] = [x.filename for x in layout.get(**queries[mod])]
return imaging_data
def write_scantsv(bids_dir, dicom_dir=None, live=False):
"""Make subject scan files (needed for NDA submission)"""
# TODO: improved with metadata
if not os.path.exists(dicom_dir):
logging.warning('Specify valid dicom directory with [-d] flag')
return
layout = BIDSLayout(bids_dir)
subs = sorted([x for x in layout.get_subjects()])
for sid in subs:
dcm = read_file(glob(op(dicom_dir, '*' + sid, '*'))[-1],
force=True).AcquisitionDate
date = '-'.join([dcm[:4], dcm[4:6], dcm[6:]])
logging.info("{0}'s scan date: {1}".format(sid, date))
scans = []
for scan in [
f.filename
for f in layout.get(subject=sid, extensions=['nii', 'nii.gz'])
]:
paths = scan.split(os.sep)
scans.append(os.sep.join(paths[-2:]))
outname = op(bids_dir, paths[-3], paths[-3] + '_scans.tsv')
if live:
with open(outname, 'wt') as tsvfile:
writer = csv.writer(tsvfile, delimiter='\t')
writer.writerow(['filename', 'acq_time'])
for scan in sorted(scans):
writer.writerow([scan, date])
logging.info('Wrote {0}'.format(outname))
def create_workflow():
parser = argparse.ArgumentParser()
parser.add_argument('-d', dest='data', help="Path to bids dataset")
args = parser.parse_args()
if not os.path.exists(args.data):
raise IOError('Input data not found')
if not os.path.exists(OUTDIR):
os.makedirs(OUTDIR)
# grab data from bids structure
layout = BIDSLayout(args.data)
subj = layout.get_subjects()[0]
func = [
f.filename
for f in layout.get(subject=subj, type='bold', extensions=['nii.gz'])
][0]
outfile = os.path.join(OUTDIR, 'test_{}_{}_motcor'.format(subj, ENV['os']))
# run interface
# Just SpatialRealign for the moment - TODO add time element with tr/slices
realign = SpaceTimeRealigner()
realign.inputs.in_file = [func]
# no out_file input, will need to be renamed after
res = realign.run()
# write out json to keep track of information
ENV.update({'inputs': res.inputs})
ENV.update({'nipype_version': nipype.__version__})
#ENV.update({'outputs': res.outputs})
# write out to json
env_to_json(ENV, outname=outfile + '.json')
def get_events(subject_id, data_dir, task=[]):
"""get_niftis gets niftis from a data_dir
Parameters
----------
subject_id : TYPE
Description
data_dir : TYPE
Description
task : list, optional
Description
Returns
-------
TYPE
Description
"""
from bids.grabbids import BIDSLayout
layout = BIDSLayout(data_dir)
event_files = layout.get(subject=subject_id,
task=task,
modality="func",
type="events",
extensions=['.tsv'])
event_files = [ev.filename for ev in event_files]
return event_files
def create_workflow():
parser = argparse.ArgumentParser()
parser.add_argument('-d', dest='data', help="Path to bids dataset")
args = parser.parse_args()
if not os.path.exists(args.data):
raise IOError('Input data not found')
if not os.path.exists(OUTDIR):
os.makedirs(OUTDIR)
# grab data from bids structure
layout = BIDSLayout(args.data)
subj = layout.get_subjects()[0]
t1 = [
f.filename
for f in layout.get(subject=subj, type='T1w', extensions=['nii.gz'])
][0]
outfile = os.path.join(OUTDIR, 'test_{}_{}_brain'.format(subj, ENV['os']))
# run afni skullstrip
skullstrip = SkullStrip()
skullstrip.inputs.in_file = t1
skullstrip.inputs.outputtype = 'NIFTI_GZ'
# FIX: this has to be unique for each environment
skullstrip.inputs.out_file = outfile + '.nii.gz'
res = skullstrip.run()
# write out json to keep track of information
ENV.update({'inputs': res.inputs})
#ENV.update({'outputs': res.outputs})
# write out to json
env_to_json(ENV, outname=outfile + '.json')
def create_workflow():
parser = argparse.ArgumentParser()
parser.add_argument('-d', dest='data', help="Path to bids dataset")
args = parser.parse_args()
if not os.path.exists(args.data):
raise IOError('Input data not found')
if not os.path.exists(OUTDIR):
os.makedirs(OUTDIR)
# grab data from bids structure
layout = BIDSLayout(args.data)
subj = layout.get_subjects()[0]
func = [
f.filename
for f in layout.get(subject=subj, type='bold', extensions=['nii.gz'])
][0]
outfile = os.path.join(OUTDIR, 'test_{}_{}_motcor'.format(subj, ENV['os']))
# run interface
realign = Realign()
realign.inputs.in_files = func
# FIX: this has to be unique for each environment
realign.inputs.out_prefix = outfile
res = realign.run()
# write out json to keep track of information
ENV.update({'inputs': res.inputs})
ENV.update({'nipype_version': nipype.__version__})
#ENV.update({'outputs': res.outputs})
# write out to json
env_to_json(ENV, outname=outfile + '.json')
def get_niftis(subject_id, data_dir):
# Remember that all the necesary imports need to be INSIDE the function for the Function Interface to work!
from bids.grabbids import BIDSLayout
layout = BIDSLayout(data_dir)
bolds = [
f.filename for f in layout.get(
subject=subject_id, type='bold', extensions=['nii', 'nii.gz'])
]
T1ws = [
f.filename for f in layout.get(
subject=subject_id, type='T1w', extensions=['nii', 'nii.gz'])
]
return bolds, T1ws
def main(sourcedata, derivatives, subject, session, tmp_dir):
sourcedata_layout = BIDSLayout(sourcedata)
sourcedata_df = sourcedata_layout.as_data_frame()
events = sourcedata_df[(sourcedata_df['type'] == 'events')
& (sourcedata_df['subject'] == subject) &
(sourcedata_df['session'] == session)]
derivatives_layout = BIDSLayout(os.path.join(derivatives, 'spynoza'))
derivatives_df = derivatives_layout.as_data_frame()
bold = derivatives_df[(derivatives_df['type'] == 'preproc')
& (derivatives_df['subject'] == subject) &
(derivatives_df['session'] == session)]
mask = derivatives_layout.get(subject=subject,
session=session,
type='mask',
return_type='file')[0]
mask = image.math_img('(im > .5).astype(int)', im=mask)
print(mask)
row = bold.iloc[0]
results_dir = os.path.join(derivatives, 'modelfitting_av', 'glm2',
'sub-{}'.format(row['subject']))
os.makedirs(results_dir, exist_ok=True)
av_bold_fn = os.path.join(
results_dir,
'sub-{}_ses-{}_bold_average.nii.gz'.format(row['subject'],
row['session']))
av_bold = average_over_runs(bold.path.tolist(), output_filename=av_bold_fn)
av_bold = image.math_img('(av_bold / av_bold.mean(-1)[..., np.newaxis])',
av_bold=av_bold)
av_bold.to_filename(av_bold_fn)
model = FirstLevelModel(t_r=4, mask=mask, drift_model=None)
paradigm = pd.read_table(events.iloc[0]['path'])
model.fit(av_bold, paradigm)
left_right = model.compute_contrast('eye_L - eye_R', output_type='z_score')
left_right.to_filename(
os.path.join(
results_dir, 'sub-{}_ses-{}_left_over_right_zmap.nii.gz'.format(
row['subject'],
row['session'],
)))
left_right = model.compute_contrast('eye_L - eye_R',
output_type='effect_size')
left_right.to_filename(
os.path.join(
results_dir, 'sub-{}_ses-{}_left_over_right_psc.nii.gz'.format(
row['subject'], row['session'])))
def reduce_sub_files(bids_dir, output_file, sub_file):
df = pd.DataFrame([])
layout = BIDSLayout(bids_dir)
files = layout.get(extensions=sub_file)
for file in [f.filename for f in files]:
print(file)
df_ = read_tsv(file)
df = pd.concat((df, df_))
to_tsv(df, os.path.join(bids_dir, output_file))
def collect_bids_data(dataset, participant_label=None, session=None, run=None,
queries=None, task=None, modalities=None):
"""Get files in dataset"""
# Start a layout
layout = BIDSLayout(dataset)
# Set queries
if queries is None:
queries = deepcopy(DEFAULT_QUERIES)
# Set modalities
if modalities is None:
modalities = deepcopy(DEFAULT_MODALITIES)
if session:
for mod in modalities:
queries[mod]['session'] = [session]
if run:
for mod in modalities:
queries[mod]['run'] = run
if task:
if isinstance(task, list) and len(task) == 1:
task = task[0]
queries['bold']['task'] = task
# Set participants
if participant_label is not None:
if isinstance(participant_label, (bytes, str)):
participant_label = [participant_label]
participant_label = ['{}'.format(sub) for sub in participant_label]
participant_label = [sub[4:] if sub.startswith('sub-') else sub
for sub in participant_label]
participant_label = [sub[:-1] if sub.endswith('*') else (sub + '$')
for sub in participant_label]
participant_label = [sub[1:] if sub.startswith('*') else ('^' + sub)
for sub in participant_label]
# For some reason, outer subject ids are filtered out
participant_label.insert(0, 'null')
participant_label.append('null')
for key in queries.keys():
queries[key]['subject'] = 'sub-\\(' + '|'.join(participant_label) + '\\){1}'
# Start querying
imaging_data = {}
for mod in modalities:
imaging_data[mod] = [x.filename for x in layout.get(**queries[mod])]
return imaging_data
def get_nifti_filenames(subject_id, data_dir):
# Remember that all the necesary imports need to be INSIDE the function for the Function Interface to work!
from bids.grabbids import BIDSLayout
layout = BIDSLayout(data_dir)
run = 1
anat_file_path = [
f.filename for f in layout.get(
subject=subject_id, type='T1w', extensions=['nii', 'nii.gz'])
]
func_file_path = [
f.filename for f in layout.get(subject=subject_id,
type='bold',
run=run,
extensions=['nii', 'nii.gz'])
]
if len(anat_file_path) == 0:
return None, func_file_path[0] # No Anatomical files present
return anat_file_path[0], func_file_path[0]
def create_RDD(self, sc):
sub_dir = "tar_files"
layout = BIDSLayout(self.bids_dataset)
participants = layout.get_subjects()
# Create RDD of file paths as key and tarred subject data as value
if self.use_hdfs:
for sub in participants:
layout.get(subject=sub)
self.create_tar_file(sub_dir, "sub-{0}.tar".format(sub),
layout.files)
return sc.binaryFiles("file://" + os.path.abspath(sub_dir))
# Create RDD of tuples containing tuples of subject names and no data
it = iter(participants)
empty_list = [None] * len(participants)
list_participants = zip(it, empty_list)
return sc.parallelize(list_participants)
class PathManager(object):
def __init__(self, basedir):
self.basedir = basedir
self.layout = BIDSLayout(basedir)
def get(self, **params):
paths = list()
for path in self.layout.get(**params):
paths.append(path.filename)
return paths
def make(self,
in_file,
pipeline_name,
derivative,
tags=None,
extension=None):
pipeline_dir = os.path.join(self.basedir, 'derivatives', pipeline_name)
path, filename = os.path.split(in_file)
inner_structure_path = list()
while path != self.basedir:
path, dir = os.path.split(path)
inner_structure_path.append(dir)
inner_structure_path = reversed(inner_structure_path)
if extension:
filename, _ = os.path.splitext(filename)
if _ == '.gz':
filename, _ = os.path.splitext(filename)
else:
filename, extension = os.path.splitext(filename)
if extension == '.gz':
filename, subextension = os.path.splitext(filename)
extension = subextension + extension
if tags:
tags_str = ''
for tag_name, tag_value in tags:
tags_str += '_{}-{}'.format(tag_name, tag_value)
filename += '{}_{}{}'.format(tags_str, derivative, extension)
else:
filename += '_{}{}'.format(derivative, extension)
out_file = os.path.join(pipeline_dir, *inner_structure_path, filename)
return out_file
def get_preproc_data(dset, cfg, data_dir='../data'):
"""
Get echo-sorted list of fMRIPrep-preprocessed files and echo times in ms.
"""
keys = ['subject', 'run', 'task']
data_dir = op.abspath(data_dir)
dset_dir = op.join(data_dir, dset, cfg['version'], 'uncompressed')
layout = BIDSLayout(dset_dir)
kwargs = {k: cfg[k] for k in keys if k in cfg.keys()}
echoes = sorted(layout.get_echoes())
in_files = []
echo_times = []
for i, echo in enumerate(echoes):
# Get echo time in ms
orig_file = layout.get(modality='func',
type='bold',
extensions='nii.gz',
echo=echo,
**kwargs)
if len(orig_file) != 1:
raise Exception('{0} files found for echo {1} of {2}: '
'{3}'.format(len(orig_file), echo, dset, cfg))
orig_file = orig_file[0].filename
metadata = layout.get_metadata(orig_file)
echo_time = metadata['EchoTime'] * 1000
echo_times.append(np.round(echo_time, 3)) # be wary, but seems okay
# Get preprocessed file associated with echo
func_file = orig_file.replace(
dset_dir, op.join(dset_dir, 'derivatives/fmriprep'))
func_file = func_file.replace(
'bold.nii.gz', 'bold_space-MNI152NLin2009cAsym_preproc.nii.gz')
if not op.isfile(func_file):
# print('File DNE: {0}'.format(func_file))
pass
in_files.append(func_file)
if i == 0:
mask_file = func_file.replace('_preproc.nii.gz',
'_brainmask.nii.gz')
if not op.isfile(mask_file):
# print('File DNE: {0}'.format(mask_file))
pass
return in_files, echo_times, mask_file
def output_BIDS_summary(bids_dir):
"""
Get a summary of the BIDS dataset input
"""
# call pybids
layout = BIDSLayout(bids_dir)
print('Below are some available keys in the dataset to filter on:\n')
# show availiable keys
keys = ['subject', 'session', 'run', 'type', 'task', 'modality']
for k in keys:
query = layout.get(target=k, return_type='id')
print('Availiable {}:'.format(k))
for q in query:
print(q, end=' ')
print('\n')
def drop_underscore(data_dir, live=False):
"""Remove underscore from subject id"""
# Change directories first, then files
subjs = sorted([x for x in os.listdir(data_dir) if x.startswith('sub-')])
for subj in subjs:
if subj.count('_') == 0:
continue
corr = subj.replace('_', '')
logging.info(msg.format(op(data_dir, subj), op(data_dir, corr)))
if not live:
return
os.rename(op(data_dir, subj), op(data_dir, corr))
# refresh after each rename
layout = BIDSLayout(data_dir)
files = [f.filename for f in layout.get() if subj in f.filename]
for file in files:
fix = file.replace(subj, corr)
os.rename(file, fix)
def transform(self, X, y=None):
agg_results = dict()
in_files_search_param = self.gather_steps[1]
if type(X[0]) == str and \
self.gather_steps[0] != 'source':
"""
in_files_dir = os.path.join(self.project_path,
'derivatives',
self.pipeline_name,
'steps',
self.gather_steps[0])
print(in_files_dir)
"""
layout = BIDSLayout(self.project_path)
X.copy()
for subject in X:
print('SUBJECT {}'.format(subject))
in_files = layout.get(subject=subject, **in_files_search_param)
print(in_files_search_param)
print(in_files)
sessions = []
dirnames = []
for in_file in in_files:
print('in_file {}'.format(in_file))
path, filename = os.path.split(in_file.filename)
session = filename.split('_')[1][4:]
if session not in sessions:
sessions.append(session)
print('session {}'.format(session))
if path not in dirnames:
dirnames.append(path)
print('path {}'.format(path))
for dirname, session in zip(dirnames, sessions):
agg_results[(subject, session)] = self.function(dirname)
return pd.DataFrame(agg_results).T
def get_bids_onsets(bids_folder):
"""
Get event onsets from a BIDS folder in a nideconv-ready
format.
Parameters
----------
bids_folder: str
Folder containing fMRI dataset according to BIDS-standard.
Returns
-------
onsets: DataFrame
Dataframe containing onsets, with subject and potentially
session, task and run as indices.
"""
layout = BIDSLayout(bids_folder)
events = layout.get(type='events', extensions='tsv')
onsets = []
index_keys = []
for event in events:
onsets_ = pd.read_table(event.filename)
for key in ['subject', 'run', 'task', 'session']:
if hasattr(event, key):
onsets_[key] = getattr(event, key)
if key not in index_keys:
index_keys.append(key)
onsets.append(onsets_)
onsets = pd.concat(onsets).set_index(index_keys)
return onsets
def check_query(bids_query, bids_dir):
"""
Check BIDS selection query
"""
from bids.grabbids import BIDSLayout
# get bids layout
layout = BIDSLayout(bids_dir)
# parse bids query
print('\n')
output = {}
for key in bids_query:
# return the query
output[key] = layout.get(**bids_query[key])
# print the output of the query
print('{}:'.format(key))
for o in output[key]:
print(o.filename)
print('Files listed are to be processed.\n\n')
def get_scan_duration(output_dir, modality="func", task="rest"):
"""
"""
layout = BIDSLayout(output_dir)
subjects_list = layout.get_subjects()
scan_duration = pd.DataFrame([])
#
for sub_id in subjects_list:
sub_dir = os.path.join(output_dir, "sub-" + sub_id)
ses_id_list = layout.get_sessions(subject=sub_id)
for ses_id in ses_id_list:
sub_ses_path = os.path.join(sub_dir, "ses-" + ses_id)
f = layout.get(subject=sub_id,
session=ses_id,
modality=modality,
task=task,
extensions='.nii.gz')
if len(f) > 1:
raise Exception(
"something went wrong, more than one %s %s file detected: %s"
% (modality, task, f))
elif len(f) == 1:
duration = (layout.get_metadata(
f[0].filename)["ScanDurationSec"])
scan_duration_sub = pd.DataFrame(
OrderedDict([("subject_id", sub_id),
("sesssion_id", ses_id),
("scan_duration_s", [duration])]))
scan_duration = scan_duration.append(scan_duration_sub)
out_str = modality
if task:
out_str += "_" + task
output_file = os.path.join(output_dir, "scan_duration_%s.tsv" % out_str)
print("Writing scan duration to %s" % output_file)
to_tsv(scan_duration, output_file)
def get_niftis(subject_id, data_dir, task=[], space='mni'):
"""get_niftis gets niftis from a data_dir
Parameters
----------
subject_id : TYPE
Description
data_dir : TYPE
Description
task : list, optional
Description
space : str, optional
Description
Returns
-------
TYPE
Description
"""
from bids.grabbids import BIDSLayout # renamed into bids.layout
layout = BIDSLayout(data_dir)
nii_files = layout.get(subject=subject_id,
task=task,
modality="func",
extensions=['.nii.gz'])
# select the proper space
if space == 'mni':
nii_files = [
mf for mf in nii_files if 'space-MNI152NLin2009cAsym_preproc' in mf.filename]
elif space == 'T1w':
nii_files = [
mf for mf in nii_files if 'space-T1w_preproc' in mf.filename]
nii_files = [nf.filename for nf in nii_files]
return nii_files
# Select subjects
subjects_to_analyze = []
T1w_files = []
# only for a subset of subjects
if args.participant_label:
subjects_to_analyze = args.participant_label
# for all subjects
else:
subjects_to_analyze = layout.get_subjects()
# Convert subjects to T1W files
for subject_label in subjects_to_analyze:
subject_T1w_files = layout.get(subject=subject_label,
type='T1w',
extensions=['.nii', '.nii.gz'],
return_type='file')
if len(subject_T1w_files) == 0:
raise Exception("No T1w files found for participant %s" %
subject_label)
else:
# If template phase, limit templates to first timepoint for subjects
if args.analysis_level == "participant1":
T1w_files.append(subject_T1w_files[0])
else:
T1w_files.extend(subject_T1w_files)
# Setup magetbrain inputs
os.chdir(args.output_dir)
run('mb.sh -- init')
def collect_data(dataset, participant_label, task=None):
"""
Uses grabbids to retrieve the input data for a given participant
>>> bids_root, _ = collect_data('ds054', '100185')
>>> bids_root['fmap'] # doctest: +ELLIPSIS
['.../ds054/sub-100185/fmap/sub-100185_magnitude1.nii.gz', \
'.../ds054/sub-100185/fmap/sub-100185_magnitude2.nii.gz', \
'.../ds054/sub-100185/fmap/sub-100185_phasediff.nii.gz']
>>> bids_root['bold'] # doctest: +ELLIPSIS
['.../ds054/sub-100185/func/sub-100185_task-machinegame_run-01_bold.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-02_bold.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-03_bold.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-04_bold.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-05_bold.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-06_bold.nii.gz']
>>> bids_root['sbref'] # doctest: +ELLIPSIS
['.../ds054/sub-100185/func/sub-100185_task-machinegame_run-01_sbref.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-02_sbref.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-03_sbref.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-04_sbref.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-05_sbref.nii.gz', \
'.../ds054/sub-100185/func/sub-100185_task-machinegame_run-06_sbref.nii.gz']
>>> bids_root['t1w'] # doctest: +ELLIPSIS
['.../ds054/sub-100185/anat/sub-100185_T1w.nii.gz']
>>> bids_root['t2w'] # doctest: +ELLIPSIS
[]
"""
layout = BIDSLayout(dataset, exclude='derivatives')
queries = {
'fmap': {'subject': participant_label, 'modality': 'fmap',
'extensions': ['nii', 'nii.gz']},
'bold': {'subject': participant_label, 'modality': 'func', 'type': 'bold',
'extensions': ['nii', 'nii.gz']},
'sbref': {'subject': participant_label, 'modality': 'func', 'type': 'sbref',
'extensions': ['nii', 'nii.gz']},
'flair': {'subject': participant_label, 'modality': 'anat', 'type': 'FLAIR',
'extensions': ['nii', 'nii.gz']},
't2w': {'subject': participant_label, 'modality': 'anat', 'type': 'T2w',
'extensions': ['nii', 'nii.gz']},
't1w': {'subject': participant_label, 'modality': 'anat', 'type': 'T1w',
'extensions': ['nii', 'nii.gz']},
'roi': {'subject': participant_label, 'modality': 'anat', 'type': 'roi',
'extensions': ['nii', 'nii.gz']},
}
if task:
queries['bold']['task'] = task
subj_data = {modality: [x.filename for x in layout.get(**query)]
for modality, query in queries.items()}
def _grp_echos(x):
if '_echo-' not in x:
return x
echo = re.search("_echo-\\d*", x).group(0)
return x.replace(echo, "_echo-?")
if subj_data["bold"] is not []:
bold_sess = subj_data["bold"]
if any(['_echo-' in bold for bold in bold_sess]):
ses_uids = [list(bold) for _, bold in groupby(bold_sess, key=_grp_echos)]
ses_uids = [x[0] if len(x) == 1 else x for x in ses_uids]
else:
ses_uids = bold_sess
subj_data.update({"bold": ses_uids})
return subj_data, layout
def files_to_dict(file_list):
"""Convert list of BIDS Files to dictionary where key is
acquisition time (datetime.datetime object) and value is
the File object.
"""
out_dict = {}
for f in file_list:
fn = f.filename
with open(fn, 'r') as fi:
data = json.load(fi)
dt = parse(data['AcquisitionTime'])
out_dict[dt] = f
return out_dict
# Get json files for field maps
fmap_jsons = layout.get(subject= subj, modality='fmap', extensions='.json')
for dir_ in ['AP', 'PA']:
# Run field map directions independently
dir_jsons = [fm for fm in fmap_jsons if '_dir-{0}_'.format(dir_) in fm.filename]
fmap_dict = files_to_dict(dir_jsons)
dts = sorted(fmap_dict.keys())
intendedfor_dict = {fmap.filename: [] for fmap in dir_jsons}
# Get all scans with associated field maps (bold + dwi)
func_jsons = layout.get(subject= subj, type='bold', extensions='.json') +\
layout.get(subject= subj, type='dwi', extensions='.json')
func_dict = files_to_dict(func_jsons)
for func in func_dict.keys():
fn, _ = splitext(func_dict[func].filename)
def generateApine(bids_dir, dset=None):
"""generateApine takes a bids directory and optionally dataset name,
and generates an Apine JSON object.
Parameters
----------
bids_dir : str
The BIDS data directory.
dset : str
The dataset name. If none is provided, the directory will be used.
Returns
-------
dict
Apine dictionary object.
"""
bids = BIDSLayout(bids_dir)
apine = list()
# For every entity...
for subid in bids.get_subjects():
current = OrderedDict()
current["dataset"] = bids_dir if dset is None else dset
current["participant"] = subid
if not op.isdir(op.join(bids_dir, 'sub-{}'.format(subid))):
print("sub-{} detected, but no directory found!!".format(subid))
continue
# And for every session...
nosesh = len(bids.get_sessions()) == 0
sesh_array = [None] if nosesh else bids.get_sessions()
for sesid in sesh_array:
if not nosesh:
current["session"] = sesid
# And for every modality...
for mod in bids.get_modalities():
current["modality"] = mod
# Get corresponding data
if nosesh:
data = bids.get(subject=subid,
modality=mod,
extensions="nii|nii.gz")
else:
data = bids.get(subject=subid,
session=sesid,
modality=mod,
extensions="nii|nii.gz")
# Now, for every piece of data for this participant, session, and modality...
for dat in data:
# Add the filename
current["filename"] = op.basename(dat.filename)
cleanname = op.basename(dat.filename).split('.')[0]
current["filename_keys"] = [
keyval for keyval in cleanname.split("_")
if "sub-" not in keyval and "ses-" not in keyval
]
tmp = deepcopy(current)
apine += [tmp]
return apine
def collect_bids_data(dataset, subject, task=None, session=None, run=None):
subject = str(subject)
if subject.startswith('sub-'):
subject = subject[4:]
layout = BIDSLayout(dataset)
if session:
session_list = [session]
else:
session_list = layout.unique('session')
if session_list == []:
session_list = [None]
if run:
run_list = [run]
else:
run_list = layout.unique('run')
if run_list == []:
run_list = [None]
queries = {
'fmap': {'modality': 'fmap', 'ext': 'nii'},
'epi': {'modality': 'func', 'type': 'bold', 'ext': 'nii'},
'sbref': {'modality': 'func', 'type': 'sbref', 'ext': 'nii'},
't1w': {'type': 'T1w', 'ext': 'nii'}
}
if task:
queries['epi']['task'] = task
# Add a subject key pair to each query we make so that we only deal with
# files related to this workflows specific subject. Could be made opt...
for key in queries.keys():
queries[key]['subject'] = subject
imaging_data = copy.deepcopy(INPUTS_SPEC)
fieldmap_files = [x.filename for x in layout.get(**queries['fmap'])]
imaging_data['fmap'] = fieldmap_files
t1_files = [x.filename for x in layout.get(**queries['t1w'])]
imaging_data['t1w'] = t1_files
sbref_files = [x.filename for x in layout.get(**queries['sbref'])]
imaging_data['sbref'] = sbref_files
epi_files = [x.filename for x in layout.get(**queries['epi'])]
imaging_data['func'] = epi_files
'''
loop_on = ['session', 'run', 'acquisition', 'task']
get_kwargs = {}
for key in loop_on:
unique_list = layout.unique(key)
if unique_list:
get_kwargs[key] = unique_list
query_kwargs = []
for key in get_kwargs:
query_kwargs.append([(key, x) for x in get_kwargs[key]])
query_kwargs = itertools.product(*query_kwargs)
for elem in query_kwargs:
epi_files = [x.filename for x
in layout.get(**dict(dict(elem), **queries['epi']))]
if epi_files:
imaging_data['func'] += epi_files
'''
return imaging_data
"graph_type": None,
"staticURL": file_server,
"usePeerJS": False,
"logPainter": False,
"logContours": False,
"logPoints": True,
"qc_options": {"pass": 1, "fail": 1, "needs_edits": 0, "edited": 0, "assignTo": 0, "notes": 1, "confidence": 1}}
layout = BIDSLayout(bids_dir)
# Loop through files, adding them to the manifest
# add entity types to a set to be used to populate the
# autogenerated settings
manifest = []
entry_types = set()
for img in layout.get(extensions = ".nii.gz"):
img_dict = {}
img_dict["check_masks"] = [img.filename.replace(bids_dir,"")]
entry_types.add(img.type)
img_dict["entry_type"] = img.type
img_dict["metrics"] = {}
img_dict["name"] = os.path.split(img.filename)[1].split('.')[0]
img_dict["subject"] = 'sub-' + img.subject
img_dict["session"] = 'ses-' + img.session
manifest.append(img_dict)
# Populate modules list
modules = []
for et in entry_types:
et_module = default_module.copy()
et_module["name"] = et
