def save_time_series(k):
if simulation.has_key(k):
fn_stim_induced = add_prefix(op.join(output_dir, k + '.nii'),
prefix)
logger.info('%s flat shape %s', k, str(simulation[k].shape))
vol = expand_array_in_mask(simulation[k], mask_vol, flat_axis=1)
write_volume(np.rollaxis(vol, 0, 4), fn_stim_induced)
def save_time_series(k):
if simulation.has_key(k):
fn_stim_induced = add_prefix(
op.join(output_dir, k + '.nii'), prefix)
logger.info('%s flat shape %s', k, str(simulation[k].shape))
vol = expand_array_in_mask(simulation[k], mask_vol, flat_axis=1)
write_volume(np.rollaxis(vol, 0, 4), fn_stim_induced)
def __init__(self, outputPrefix='', roiAverage=False, pass_error=True):
xmlio.XMLable2.__init__(self)
if len(outputPrefix) == 0: outputPrefix = 'pyhrf_'
self.outPrefix = outputPrefix
self.outFile = add_prefix('outputs.xml', self.outPrefix)
self.roiAverage = roiAverage
self.pass_error = pass_error
def make_outputs_single_subject(self, data_rois, irois, all_outputs,
targetAxes, ext, meta_data, output_dir):
coutputs = {}
output_fns = []
roi_masks = [(data_roi.roiMask != data_roi.backgroundLabel)
for data_roi in data_rois]
np_roi_masks = [np.where(roi_mask) for roi_mask in roi_masks]
for output_name, roi_outputs in all_outputs.iteritems():
logger.info('Merge output %s ...', output_name)
try:
if roi_outputs[0].has_axis('voxel'):
logger.debug('Merge as expansion ...')
dest_c = None
for i_roi, c in enumerate(roi_outputs):
dest_c = c.expand(roi_masks[i_roi],
'voxel', targetAxes,
dest=dest_c, do_checks=False,
m=np_roi_masks[i_roi])
else:
logger.debug('Merge as stack (%d elements)...', len(irois))
c_to_stack = [roi_outputs[i] for i in np.argsort(irois)]
# print 'c_to_stack:', c_to_stack
# print 'sorted(irois):', sorted(irois)
dest_c = stack_cuboids(c_to_stack, domain=sorted(irois),
axis='ROI')
except Exception, e:
print "Could not merge outputs for %s" % output_name
print "Exception was:"
print e
# raise e #stop here
if 0 and dest_c is not None:
print '-> ', dest_c.data.shape
output_fn = op.join(output_dir, output_name + ext)
output_fn = add_prefix(output_fn, self.outPrefix)
output_fns.append(output_fn)
logger.debug('Save output %s to %s', output_name, output_fn)
try:
if dest_c.meta_data:
tmp_meta_data = (meta_data[0], meta_data[1].copy())
tmp_meta_data[1]["descrip"] = dest_c.meta_data[1]["descrip"]
dest_c.meta_data = tmp_meta_data
dest_c.save(output_fn, set_MRI_orientation=True)
else:
dest_c.save(output_fn, meta_data=meta_data,
set_MRI_orientation=True)
except Exception:
print 'Could not save output "%s", error stack was:' \
% output_name
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback,
limit=4, file=sys.stdout)
coutputs[output_name] = dest_c
def __init__(self,
outputPrefix='',
roiAverage=False,
pass_error=True,
gzip_outputs=False):
xmlio.XmlInitable.__init__(self)
if len(outputPrefix) == 0:
outputPrefix = 'pyhrf_'
self.outPrefix = outputPrefix
self.outFile = add_prefix('outputs.xml', self.outPrefix)
self.roiAverage = roiAverage
self.pass_error = pass_error
self.gzip_outputs = gzip_outputs
def make_outfile(fn, path, pre='', suf=''):
if fn is None or path is None:
return None
ofn = op.join(path, fn)
return add_prefix(add_suffix(ofn, suf), pre)
from pyhrf.ui.jde import DEFAULT_CFG_FILE as DEFAULT_CFG_FILE_JDE
from pyhrf.jde.models import BOLDGibbsSampler as BG
from pyhrf.jde.beta import BetaSampler as BS
from pyhrf.jde.nrl.bigaussian import NRLSampler as NS
from pyhrf.jde.nrl.trigaussian import GGGNRLSampler as NS3
from pyhrf.jde.hrf import RHSampler as HVS
from pyhrf.jde.hrf import HRFSampler as HS
#VT = FMRIVolumeTreatment
#ST = FMRISurfaceTreatment
DEFAULT_JDE_OUT_MASK_VOL = add_prefix(DEFAULT_OUT_MASK_VOL_FILE, 'jde_')
DEFAULT_JDE_OUT_MASK_SURF = add_prefix(DEFAULT_OUT_MASK_SURF_FILE, 'jde_')
def make_outfile(fn, path, pre='', suf=''):
if fn is None or path is None:
return None
ofn = op.join(path, fn)
return add_prefix(add_suffix(ofn, suf), pre)
def create_treatment(boldFiles, parcelFile, dt, tr, paradigmFile,
nbIterations=4000,
writeXmlSetup=True, parallelize=False,
outputDir=None, outputSuffix=None, outputPrefix=None,
contrasts=None, beta=.6, estimBeta=True,
pfMethod='ps', estimHrf=True, hrfVar=.01,
roiIds=None,
def make_outputs_multi_subjects(self, data_rois, irois, all_outputs,
targetAxes, ext, meta_data, output_dir):
coutputs = {}
output_fns = []
roi_masks = [[(ds.roiMask != ds.backgroundLabel)
for ds in dr.data_subjects]
for dr in data_rois]
#-> roi_masks[roi_id][subject]
np_roi_masks = [[np.where(roi_subj_mask)
for roi_subj_mask in roi_subj_masks]
for roi_subj_masks in roi_masks]
#-> np_roi_masks[roi_id][subject]
for output_name, roi_outputs in all_outputs.iteritems():
logger.info('Merge output %s ...', output_name)
dest_c = {}
try:
if roi_outputs[0].has_axis('voxel'):
if not roi_outputs[0].has_axis('subject'):
raise Exception('Voxel-mapped output "%s" does not'
'have a subject axis')
logger.debug('Merge as expansion ...')
dest_c_tmp = None
for isubj in roi_outputs[0].get_domain('subject'):
for i_roi, c in enumerate(roi_outputs):
m = np_roi_masks[i_roi][isubj]
dest_c_tmp = c.expand(roi_masks[i_roi][isubj],
'voxel', targetAxes,
dest=dest_c_tmp,
do_checks=False,
m=m)
dest_c[output_name] = dest_c_tmp
else:
logger.debug('Merge as stack (%d elements)...', len(irois))
c_to_stack = [roi_outputs[i] for i in np.argsort(irois)]
dest_c[output_name] = stack_cuboids(c_to_stack,
domain=sorted(irois),
axis='ROI')
except Exception, e:
logger.error("Could not merge outputs for %s", output_name)
logger.error("Exception was:")
logger.error(e)
for output_name, c in dest_c.iteritems():
output_fn = op.join(output_dir, output_name + ext)
output_fn = add_prefix(output_fn, self.outPrefix)
output_fns.append(output_fn)
logger.debug('Save output %s to %s', output_name, output_fn)
try:
c.save(output_fn, meta_data=meta_data,
set_MRI_orientation=True)
except Exception:
print 'Could not save output "%s", error stack was:' \
% output_name
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value,
exc_traceback,
limit=4, file=sys.stdout)
coutputs[output_name] = c
def simulation_save_vol_outputs(simulation,
output_dir,
bold_3D_vols_dir=None,
simulation_graph_output=None,
prefix=None,
vol_meta=None):
""" simulation_graph_output : None, 'simple', 'thumbnails' #TODO
"""
if simulation.has_key('paradigm'):
fn = add_prefix(op.join(output_dir, 'paradigm.csv'), prefix)
simulation['paradigm'].save_csv(fn)
# Save all volumes in nifti format:
if simulation.has_key('labels_vol'):
mask_vol = np.ones_like(simulation['labels_vol'][0])
elif simulation.has_key('mask'):
mask_vol = simulation.get('mask', None)
elif simulation.has_key('labels'):
mask_vol = np.ones_like(simulation['labels'][0])
else:
raise Exception('Dunno where to get mask')
logger.info('Vol mask of shape %s', str(mask_vol.shape))
fn_mask = add_prefix(op.join(output_dir, 'mask.nii'), prefix)
write_volume(mask_vol.astype(np.int32), fn_mask, vol_meta)
if simulation.has_key('hrf_territories'):
fn_h_territories = add_prefix(
op.join(output_dir, 'hrf_territories.nii'), prefix)
ht = expand_array_in_mask(simulation['hrf_territories'] + 1, mask_vol)
write_volume(ht, fn_h_territories, vol_meta)
if simulation.has_key('hrf'):
from pyhrf.ndarray import MRI3Daxes
fn_hrf = add_prefix(op.join(output_dir, 'hrf.nii'), prefix)
logger.info('hrf flat shape %s', str(simulation['hrf'].shape))
if simulation['hrf'].ndim == 1:
hrf = (np.ones(mask_vol.size) * simulation['hrf'][:, np.newaxis])
else:
hrf = simulation['hrf']
hrfs_vol = expand_array_in_mask(hrf, mask_vol, flat_axis=1)
dt = simulation['dt']
chrfs = xndarray(
hrfs_vol,
axes_names=[
'time',
] + MRI3Daxes,
axes_domains={'time': np.arange(hrfs_vol.shape[0]) * dt})
chrfs.save(fn_hrf, vol_meta)
ttp_vol = hrfs_vol.argmax(0)
fn_ttp = add_prefix(op.join(output_dir, 'ttp.nii'), prefix)
write_volume(ttp_vol, fn_ttp, vol_meta)
if simulation.has_key('brf'):
from pyhrf.ndarray import MRI3Daxes
fn_brf = add_prefix(op.join(output_dir, 'brf.nii'), prefix)
logger.info('brf flat shape %s', str(simulation['brf'].shape))
brfs_vol = expand_array_in_mask(simulation['brf'],
mask_vol,
flat_axis=1)
dt = simulation['dt']
cbrfs = xndarray(
brfs_vol,
axes_names=[
'time',
] + MRI3Daxes,
axes_domains={'time': np.arange(brfs_vol.shape[0]) * dt})
cbrfs.save(fn_brf, vol_meta)
if simulation.has_key('prf'):
from pyhrf.ndarray import MRI3Daxes
fn_brf = add_prefix(op.join(output_dir, 'prf.nii'), prefix)
logger.info('prf flat shape %s', str(simulation['prf'].shape))
brfs_vol = expand_array_in_mask(simulation['prf'],
mask_vol,
flat_axis=1)
dt = simulation['dt']
cbrfs = xndarray(
brfs_vol,
axes_names=[
'time',
] + MRI3Daxes,
axes_domains={'time': np.arange(brfs_vol.shape[0]) * dt})
cbrfs.save(fn_brf, vol_meta)
if simulation.has_key('drift'):
fn_drift = add_prefix(op.join(output_dir, 'drift.nii'), prefix)
logger.info('drift flat shape %s', str(simulation['drift'].shape))
drift_vol = expand_array_in_mask(simulation['drift'],
mask_vol,
flat_axis=1)
write_volume(np.rollaxis(drift_vol, 0, 4), fn_drift)
if simulation.has_key('drift_coeffs'):
fn_drift = add_prefix(op.join(output_dir, 'drift_coeffs.nii'), prefix)
logger.info('drift flat shape %s',
str(simulation['drift_coeffs'].shape))
drift_vol = expand_array_in_mask(simulation['drift'],
mask_vol,
flat_axis=1)
write_volume(np.rollaxis(drift_vol, 0, 4), fn_drift)
if simulation.has_key('noise'):
fn_noise = add_prefix(op.join(output_dir, 'noise.nii'), prefix)
logger.info('noise flat shape %s', str(simulation['noise'].shape))
noise_vol = expand_array_in_mask(simulation['noise'],
mask_vol,
flat_axis=1)
write_volume(np.rollaxis(noise_vol, 0, 4), fn_noise, vol_meta)
fn_noise = add_prefix(op.join(output_dir, 'noise_emp_var.nii'), prefix)
noise_vol = expand_array_in_mask(simulation['noise'].var(0), mask_vol)
write_volume(noise_vol, fn_noise, vol_meta)
if simulation.has_key('noise_var'):
fn_noise_var = add_prefix(op.join(output_dir, 'noise_var.nii'), prefix)
logger.info('noise_var flat shape %s',
str(simulation['noise_var'].shape))
noise_var_vol = expand_array_in_mask(simulation['noise_var'], mask_vol)
write_volume(noise_var_vol, fn_noise_var, vol_meta)
if simulation.has_key('stim_induced_signal'):
fn_stim_induced = add_prefix(op.join(output_dir, 'stim_induced.nii'),
prefix)
logger.info('stim_induced flat shape %s',
str(simulation['stim_induced_signal'].shape))
stim_induced_vol = expand_array_in_mask(
simulation['stim_induced_signal'], mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
if simulation.has_key('perf_stim_induced'):
fn_stim_induced = add_prefix(
op.join(output_dir, 'perf_stim_induced.nii'), prefix)
logger.info('asl_stim_induced flat shape %s',
str(simulation['perf_stim_induced'].shape))
stim_induced_vol = expand_array_in_mask(
simulation['perf_stim_induced'], mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
fn_stim_induced = add_prefix(
op.join(output_dir, 'perf_stim_induced_ct.nii'), prefix)
logger.info('asl_stim_induced flat shape %s',
str(simulation['perf_stim_induced'].shape))
dsf = simulation['dsf']
perf = np.dot(simulation['ctrl_tag_mat'],
simulation['perf_stim_induced'][0:-1:dsf])
stim_induced_vol = expand_array_in_mask(perf, mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
if simulation.has_key('perf_baseline'):
fn = add_prefix(op.join(output_dir, 'perf_baseline.nii'), prefix)
pb = np.zeros_like(simulation['bold']) + simulation['perf_baseline']
write_volume(expand_array_in_mask(pb[0], mask_vol), fn, vol_meta)
if simulation.has_key('bold_stim_induced'):
fn_stim_induced = add_prefix(
op.join(output_dir, 'bold_stim_induced.nii'), prefix)
logger.info('asl_stim_induced flat shape %s',
str(simulation['bold_stim_induced'].shape))
stim_induced_vol = expand_array_in_mask(
simulation['bold_stim_induced'], mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
m = np.where(mask_vol)
labels_and_mask = mask_vol.copy()[m]
for ic in xrange(simulation['labels'].shape[0]):
if simulation.has_key('condition_defs'):
c_name = simulation['condition_defs'][ic].name
else:
c_name = 'cond%d' % ic
fn_labels = add_prefix(op.join(output_dir, 'labels_%s.nii' % c_name),
prefix)
if simulation.has_key('labels'):
labels_c = simulation['labels'][ic]
labels_and_mask[np.where(labels_c)] = ic + 2
write_volume(
expand_array_in_mask(labels_c, mask_vol).astype(np.int32),
fn_labels, vol_meta)
elif simulation.has_key('labels_vol'):
labels_c = simulation['labels_vol'][ic]
labels_and_mask[np.where(labels_c[m])] = ic + 2
write_volume(labels_c.astype(np.int32), fn_labels, vol_meta)
if simulation.has_key('nrls'):
nrls_c = simulation['nrls'][ic]
fn = add_prefix(op.join(output_dir, 'nrls_%s.nii' % c_name),
prefix)
write_volume(expand_array_in_mask(nrls_c, mask_vol), fn, vol_meta)
if simulation.has_key('nrls_session'):
nrls_session_c = simulation['nrls_session'][ic]
fn = add_prefix(
op.join(output_dir, 'nrls_session_%s.nii' % (c_name)), prefix)
write_volume(expand_array_in_mask(nrls_session_c, mask_vol), fn,
vol_meta)
if simulation.has_key('brls'):
brls_c = simulation['brls'][ic]
fn = add_prefix(op.join(output_dir, 'brls_%s.nii' % c_name),
prefix)
write_volume(expand_array_in_mask(brls_c, mask_vol), fn, vol_meta)
if simulation.has_key('prls'):
prls_c = simulation['prls'][ic]
fn = add_prefix(op.join(output_dir, 'prls_%s.nii' % c_name),
prefix)
write_volume(expand_array_in_mask(prls_c, mask_vol), fn, vol_meta)
if simulation.has_key('neural_efficacies'):
ne_c = simulation['neural_efficacies'][ic]
fn = add_prefix(
op.join(output_dir, 'neural_efficacies_%s.nii' % c_name),
prefix)
write_volume(expand_array_in_mask(ne_c, mask_vol), fn, vol_meta)
fn_labels_and_mask = add_prefix(op.join(output_dir, 'mask_and_labels.nii'),
prefix)
write_volume(
expand_array_in_mask(labels_and_mask, mask_vol).astype(int),
fn_labels_and_mask, vol_meta)
if simulation.has_key('bold_full_vol') or simulation.has_key('bold'):
fn = add_prefix(op.join(output_dir, 'bold.nii'), prefix)
if simulation.has_key('bold_full_vol'):
bold4D = simulation['bold_full_vol']
else:
bold = simulation['bold']
bold4D = expand_array_in_mask(bold, mask_vol, flat_axis=1)
write_volume(np.rollaxis(bold4D, 0, 4), fn, vol_meta)
def save_time_series(k):
if simulation.has_key(k):
fn_stim_induced = add_prefix(op.join(output_dir, k + '.nii'),
prefix)
logger.info('%s flat shape %s', k, str(simulation[k].shape))
vol = expand_array_in_mask(simulation[k], mask_vol, flat_axis=1)
write_volume(np.rollaxis(vol, 0, 4), fn_stim_induced)
save_time_series('flow_induction')
save_time_series('cbv')
save_time_series('hbr')
save_time_series('bold_stim_induced_rescaled')
if simulation.has_key('asl'):
fn = add_prefix(op.join(output_dir, 'asl.nii'), prefix)
asl4D = expand_array_in_mask(simulation['asl'], mask_vol, flat_axis=1)
write_volume(np.rollaxis(asl4D, 0, 4), fn, vol_meta)
if simulation.has_key('outliers'):
fn = add_prefix(op.join(output_dir, 'outliers.nii'), prefix)
outliers = expand_array_in_mask(simulation['outliers'],
mask_vol,
flat_axis=1)
write_volume(np.rollaxis(outliers, 0, 4), fn, vol_meta)
if simulation.has_key('hrf_group'):
hrfgroup = simulation['hrf_group']
nb_vox = mask_vol.size
fn_hrf = add_prefix(op.join(output_dir, 'hrf_group.nii'), prefix)
logger.info('hrf group shape %s', str(simulation['hrf_group'].shape))
hrfGd = duplicate_hrf(nb_vox, hrfgroup)
hrfs_vol = expand_array_in_mask(hrfGd, mask_vol, flat_axis=1)
dt = simulation['dt']
chrfs = xndarray(
hrfs_vol,
axes_names=[
'time',
] + MRI3Daxes,
axes_domains={'time': np.arange(hrfs_vol.shape[0]) * dt})
chrfs.save(fn_hrf, vol_meta)
if bold_3D_vols_dir is not None:
assert op.exists(bold_3D_vols_dir)
for iscan, bscan in enumerate(bold4D):
fnout = add_prefix('bold_%06d.nii' % (iscan), prefix)
write_volume(bscan, op.join(bold_3D_vols_dir, fnout), vol_meta)
def make_outputs_multi_subjects(self, data_rois, irois, all_outputs,
targetAxes, ext, meta_data, output_dir):
coutputs = {}
output_fns = []
roi_masks = [[(ds.roiMask != ds.backgroundLabel)
for ds in dr.data_subjects] for dr in data_rois]
#-> roi_masks[roi_id][subject]
np_roi_masks = [[
np.where(roi_subj_mask) for roi_subj_mask in roi_subj_masks
] for roi_subj_masks in roi_masks]
#-> np_roi_masks[roi_id][subject]
for output_name, roi_outputs in all_outputs.iteritems():
logger.info('Merge output %s ...', output_name)
dest_c = {}
try:
if roi_outputs[0].has_axis('voxel'):
if not roi_outputs[0].has_axis('subject'):
raise Exception('Voxel-mapped output "%s" does not'
'have a subject axis')
logger.debug('Merge as expansion ...')
dest_c_tmp = None
for isubj in roi_outputs[0].get_domain('subject'):
for i_roi, c in enumerate(roi_outputs):
m = np_roi_masks[i_roi][isubj]
dest_c_tmp = c.expand(roi_masks[i_roi][isubj],
'voxel',
targetAxes,
dest=dest_c_tmp,
do_checks=False,
m=m)
dest_c[output_name] = dest_c_tmp
else:
logger.debug('Merge as stack (%d elements)...', len(irois))
c_to_stack = [roi_outputs[i] for i in np.argsort(irois)]
dest_c[output_name] = stack_cuboids(c_to_stack,
domain=sorted(irois),
axis='ROI')
except Exception, e:
logger.error("Could not merge outputs for %s", output_name)
logger.error("Exception was:")
logger.error(e)
for output_name, c in dest_c.iteritems():
output_fn = op.join(output_dir, output_name + ext)
output_fn = add_prefix(output_fn, self.outPrefix)
output_fns.append(output_fn)
logger.debug('Save output %s to %s', output_name, output_fn)
try:
c.save(output_fn,
meta_data=meta_data,
set_MRI_orientation=True)
except Exception:
print 'Could not save output "%s", error stack was:' \
% output_name
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type,
exc_value,
exc_traceback,
limit=4,
file=sys.stdout)
coutputs[output_name] = c
def make_outputs_single_subject(self, data_rois, irois, all_outputs,
targetAxes, ext, meta_data, output_dir):
coutputs = {}
output_fns = []
roi_masks = [(data_roi.roiMask != data_roi.backgroundLabel)
for data_roi in data_rois]
np_roi_masks = [np.where(roi_mask) for roi_mask in roi_masks]
for output_name, roi_outputs in all_outputs.iteritems():
logger.info('Merge output %s ...', output_name)
try:
if roi_outputs[0].has_axis('voxel'):
logger.debug('Merge as expansion ...')
dest_c = None
for i_roi, c in enumerate(roi_outputs):
dest_c = c.expand(roi_masks[i_roi],
'voxel',
targetAxes,
dest=dest_c,
do_checks=False,
m=np_roi_masks[i_roi])
else:
logger.debug('Merge as stack (%d elements)...', len(irois))
c_to_stack = [roi_outputs[i] for i in np.argsort(irois)]
# print 'c_to_stack:', c_to_stack
# print 'sorted(irois):', sorted(irois)
dest_c = stack_cuboids(c_to_stack,
domain=sorted(irois),
axis='ROI')
except Exception, e:
print "Could not merge outputs for %s" % output_name
print "Exception was:"
print e
# raise e #stop here
if 0 and dest_c is not None:
print '-> ', dest_c.data.shape
output_fn = op.join(output_dir, output_name + ext)
output_fn = add_prefix(output_fn, self.outPrefix)
output_fns.append(output_fn)
logger.debug('Save output %s to %s', output_name, output_fn)
try:
if dest_c.meta_data:
tmp_meta_data = (meta_data[0], meta_data[1].copy())
tmp_meta_data[1]["descrip"] = dest_c.meta_data[1][
"descrip"]
dest_c.meta_data = tmp_meta_data
dest_c.save(output_fn, set_MRI_orientation=True)
else:
dest_c.save(output_fn,
meta_data=meta_data,
set_MRI_orientation=True)
except Exception:
print 'Could not save output "%s", error stack was:' \
% output_name
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type,
exc_value,
exc_traceback,
limit=4,
file=sys.stdout)
coutputs[output_name] = dest_c
def simulation_save_vol_outputs(
simulation, output_dir, bold_3D_vols_dir=None, simulation_graph_output=None, prefix=None, vol_meta=None
):
""" simulation_graph_output : None, 'simple', 'thumbnails' #TODO
"""
if simulation.has_key("paradigm"):
fn = add_prefix(op.join(output_dir, "paradigm.csv"), prefix)
simulation["paradigm"].save_csv(fn)
# Save all volumes in nifti format:
if simulation.has_key("labels_vol"):
mask_vol = np.ones_like(simulation["labels_vol"][0])
elif simulation.has_key("mask"):
mask_vol = simulation.get("mask", None)
elif simulation.has_key("labels"):
mask_vol = np.ones_like(simulation["labels"][0])
else:
raise Exception("Dunno where to get mask")
logger.info("Vol mask of shape %s", str(mask_vol.shape))
fn_mask = add_prefix(op.join(output_dir, "mask.nii"), prefix)
write_volume(mask_vol.astype(np.int32), fn_mask, vol_meta)
if simulation.has_key("hrf_territories"):
fn_h_territories = add_prefix(op.join(output_dir, "hrf_territories.nii"), prefix)
ht = expand_array_in_mask(simulation["hrf_territories"] + 1, mask_vol)
write_volume(ht, fn_h_territories, vol_meta)
if simulation.has_key("hrf"):
from pyhrf.ndarray import MRI3Daxes
fn_hrf = add_prefix(op.join(output_dir, "hrf.nii"), prefix)
logger.info("hrf flat shape %s", str(simulation["hrf"].shape))
if simulation["hrf"].ndim == 1:
hrf = np.ones(mask_vol.size) * simulation["hrf"][:, np.newaxis]
else:
hrf = simulation["hrf"]
hrfs_vol = expand_array_in_mask(hrf, mask_vol, flat_axis=1)
dt = simulation["dt"]
chrfs = xndarray(
hrfs_vol, axes_names=["time"] + MRI3Daxes, axes_domains={"time": np.arange(hrfs_vol.shape[0]) * dt}
)
chrfs.save(fn_hrf, vol_meta)
ttp_vol = hrfs_vol.argmax(0)
fn_ttp = add_prefix(op.join(output_dir, "ttp.nii"), prefix)
write_volume(ttp_vol, fn_ttp, vol_meta)
if simulation.has_key("brf"):
from pyhrf.ndarray import MRI3Daxes
fn_brf = add_prefix(op.join(output_dir, "brf.nii"), prefix)
logger.info("brf flat shape %s", str(simulation["brf"].shape))
brfs_vol = expand_array_in_mask(simulation["brf"], mask_vol, flat_axis=1)
dt = simulation["dt"]
cbrfs = xndarray(
brfs_vol, axes_names=["time"] + MRI3Daxes, axes_domains={"time": np.arange(brfs_vol.shape[0]) * dt}
)
cbrfs.save(fn_brf, vol_meta)
if simulation.has_key("prf"):
from pyhrf.ndarray import MRI3Daxes
fn_brf = add_prefix(op.join(output_dir, "prf.nii"), prefix)
logger.info("prf flat shape %s", str(simulation["prf"].shape))
brfs_vol = expand_array_in_mask(simulation["prf"], mask_vol, flat_axis=1)
dt = simulation["dt"]
cbrfs = xndarray(
brfs_vol, axes_names=["time"] + MRI3Daxes, axes_domains={"time": np.arange(brfs_vol.shape[0]) * dt}
)
cbrfs.save(fn_brf, vol_meta)
if simulation.has_key("drift"):
fn_drift = add_prefix(op.join(output_dir, "drift.nii"), prefix)
logger.info("drift flat shape %s", str(simulation["drift"].shape))
drift_vol = expand_array_in_mask(simulation["drift"], mask_vol, flat_axis=1)
write_volume(np.rollaxis(drift_vol, 0, 4), fn_drift)
if simulation.has_key("drift_coeffs"):
fn_drift = add_prefix(op.join(output_dir, "drift_coeffs.nii"), prefix)
logger.info("drift flat shape %s", str(simulation["drift_coeffs"].shape))
drift_vol = expand_array_in_mask(simulation["drift"], mask_vol, flat_axis=1)
write_volume(np.rollaxis(drift_vol, 0, 4), fn_drift)
if simulation.has_key("noise"):
fn_noise = add_prefix(op.join(output_dir, "noise.nii"), prefix)
logger.info("noise flat shape %s", str(simulation["noise"].shape))
noise_vol = expand_array_in_mask(simulation["noise"], mask_vol, flat_axis=1)
write_volume(np.rollaxis(noise_vol, 0, 4), fn_noise, vol_meta)
fn_noise = add_prefix(op.join(output_dir, "noise_emp_var.nii"), prefix)
noise_vol = expand_array_in_mask(simulation["noise"].var(0), mask_vol)
write_volume(noise_vol, fn_noise, vol_meta)
if simulation.has_key("noise_var"):
fn_noise_var = add_prefix(op.join(output_dir, "noise_var.nii"), prefix)
logger.info("noise_var flat shape %s", str(simulation["noise_var"].shape))
noise_var_vol = expand_array_in_mask(simulation["noise_var"], mask_vol)
write_volume(noise_var_vol, fn_noise_var, vol_meta)
if simulation.has_key("stim_induced_signal"):
fn_stim_induced = add_prefix(op.join(output_dir, "stim_induced.nii"), prefix)
logger.info("stim_induced flat shape %s", str(simulation["stim_induced_signal"].shape))
stim_induced_vol = expand_array_in_mask(simulation["stim_induced_signal"], mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
if simulation.has_key("perf_stim_induced"):
fn_stim_induced = add_prefix(op.join(output_dir, "perf_stim_induced.nii"), prefix)
logger.info("asl_stim_induced flat shape %s", str(simulation["perf_stim_induced"].shape))
stim_induced_vol = expand_array_in_mask(simulation["perf_stim_induced"], mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
fn_stim_induced = add_prefix(op.join(output_dir, "perf_stim_induced_ct.nii"), prefix)
logger.info("asl_stim_induced flat shape %s", str(simulation["perf_stim_induced"].shape))
dsf = simulation["dsf"]
perf = np.dot(simulation["ctrl_tag_mat"], simulation["perf_stim_induced"][0:-1:dsf])
stim_induced_vol = expand_array_in_mask(perf, mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
if simulation.has_key("perf_baseline"):
fn = add_prefix(op.join(output_dir, "perf_baseline.nii"), prefix)
pb = np.zeros_like(simulation["bold"]) + simulation["perf_baseline"]
write_volume(expand_array_in_mask(pb[0], mask_vol), fn, vol_meta)
if simulation.has_key("bold_stim_induced"):
fn_stim_induced = add_prefix(op.join(output_dir, "bold_stim_induced.nii"), prefix)
logger.info("asl_stim_induced flat shape %s", str(simulation["bold_stim_induced"].shape))
stim_induced_vol = expand_array_in_mask(simulation["bold_stim_induced"], mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
m = np.where(mask_vol)
labels_and_mask = mask_vol.copy()[m]
for ic in xrange(simulation["labels"].shape[0]):
if simulation.has_key("condition_defs"):
c_name = simulation["condition_defs"][ic].name
else:
c_name = "cond%d" % ic
fn_labels = add_prefix(op.join(output_dir, "labels_%s.nii" % c_name), prefix)
if simulation.has_key("labels"):
labels_c = simulation["labels"][ic]
labels_and_mask[np.where(labels_c)] = ic + 2
write_volume(expand_array_in_mask(labels_c, mask_vol).astype(np.int32), fn_labels, vol_meta)
elif simulation.has_key("labels_vol"):
labels_c = simulation["labels_vol"][ic]
labels_and_mask[np.where(labels_c[m])] = ic + 2
write_volume(labels_c.astype(np.int32), fn_labels, vol_meta)
if simulation.has_key("nrls"):
nrls_c = simulation["nrls"][ic]
fn = add_prefix(op.join(output_dir, "nrls_%s.nii" % c_name), prefix)
write_volume(expand_array_in_mask(nrls_c, mask_vol), fn, vol_meta)
if simulation.has_key("nrls_session"):
nrls_session_c = simulation["nrls_session"][ic]
fn = add_prefix(op.join(output_dir, "nrls_session_%s.nii" % (c_name)), prefix)
write_volume(expand_array_in_mask(nrls_session_c, mask_vol), fn, vol_meta)
if simulation.has_key("brls"):
brls_c = simulation["brls"][ic]
fn = add_prefix(op.join(output_dir, "brls_%s.nii" % c_name), prefix)
write_volume(expand_array_in_mask(brls_c, mask_vol), fn, vol_meta)
if simulation.has_key("prls"):
prls_c = simulation["prls"][ic]
fn = add_prefix(op.join(output_dir, "prls_%s.nii" % c_name), prefix)
write_volume(expand_array_in_mask(prls_c, mask_vol), fn, vol_meta)
if simulation.has_key("neural_efficacies"):
ne_c = simulation["neural_efficacies"][ic]
fn = add_prefix(op.join(output_dir, "neural_efficacies_%s.nii" % c_name), prefix)
write_volume(expand_array_in_mask(ne_c, mask_vol), fn, vol_meta)
fn_labels_and_mask = add_prefix(op.join(output_dir, "mask_and_labels.nii"), prefix)
write_volume(expand_array_in_mask(labels_and_mask, mask_vol).astype(int), fn_labels_and_mask, vol_meta)
if simulation.has_key("bold_full_vol") or simulation.has_key("bold"):
fn = add_prefix(op.join(output_dir, "bold.nii"), prefix)
if simulation.has_key("bold_full_vol"):
bold4D = simulation["bold_full_vol"]
else:
bold = simulation["bold"]
bold4D = expand_array_in_mask(bold, mask_vol, flat_axis=1)
write_volume(np.rollaxis(bold4D, 0, 4), fn, vol_meta)
def save_time_series(k):
if simulation.has_key(k):
fn_stim_induced = add_prefix(op.join(output_dir, k + ".nii"), prefix)
logger.info("%s flat shape %s", k, str(simulation[k].shape))
vol = expand_array_in_mask(simulation[k], mask_vol, flat_axis=1)
write_volume(np.rollaxis(vol, 0, 4), fn_stim_induced)
save_time_series("flow_induction")
save_time_series("cbv")
save_time_series("hbr")
save_time_series("bold_stim_induced_rescaled")
if simulation.has_key("asl"):
fn = add_prefix(op.join(output_dir, "asl.nii"), prefix)
asl4D = expand_array_in_mask(simulation["asl"], mask_vol, flat_axis=1)
write_volume(np.rollaxis(asl4D, 0, 4), fn, vol_meta)
if simulation.has_key("outliers"):
fn = add_prefix(op.join(output_dir, "outliers.nii"), prefix)
outliers = expand_array_in_mask(simulation["outliers"], mask_vol, flat_axis=1)
write_volume(np.rollaxis(outliers, 0, 4), fn, vol_meta)
if simulation.has_key("hrf_group"):
hrfgroup = simulation["hrf_group"]
nb_vox = mask_vol.size
fn_hrf = add_prefix(op.join(output_dir, "hrf_group.nii"), prefix)
logger.info("hrf group shape %s", str(simulation["hrf_group"].shape))
hrfGd = duplicate_hrf(nb_vox, hrfgroup)
hrfs_vol = expand_array_in_mask(hrfGd, mask_vol, flat_axis=1)
dt = simulation["dt"]
chrfs = xndarray(
hrfs_vol, axes_names=["time"] + MRI3Daxes, axes_domains={"time": np.arange(hrfs_vol.shape[0]) * dt}
)
chrfs.save(fn_hrf, vol_meta)
if bold_3D_vols_dir is not None:
assert op.exists(bold_3D_vols_dir)
for iscan, bscan in enumerate(bold4D):
fnout = add_prefix("bold_%06d.nii" % (iscan), prefix)
write_volume(bscan, op.join(bold_3D_vols_dir, fnout), vol_meta)
def simulation_save_vol_outputs(simulation, output_dir, bold_3D_vols_dir=None,
simulation_graph_output=None, prefix=None,
vol_meta=None):
""" simulation_graph_output : None, 'simple', 'thumbnails' #TODO
"""
if simulation.has_key('paradigm'):
fn = add_prefix(op.join(output_dir, 'paradigm.csv'), prefix)
simulation['paradigm'].save_csv(fn)
# Save all volumes in nifti format:
if simulation.has_key('labels_vol'):
mask_vol = np.ones_like(simulation['labels_vol'][0])
elif simulation.has_key('mask'):
mask_vol = simulation.get('mask', None)
elif simulation.has_key('labels'):
mask_vol = np.ones_like(simulation['labels'][0])
else:
raise Exception('Dunno where to get mask')
logger.info('Vol mask of shape %s', str(mask_vol.shape))
fn_mask = add_prefix(op.join(output_dir, 'mask.nii'), prefix)
write_volume(mask_vol.astype(np.int32), fn_mask, vol_meta)
if simulation.has_key('hrf_territories'):
fn_h_territories = add_prefix(op.join(output_dir, 'hrf_territories.nii'),
prefix)
ht = expand_array_in_mask(simulation['hrf_territories'] + 1, mask_vol)
write_volume(ht, fn_h_territories, vol_meta)
if simulation.has_key('hrf'):
from pyhrf.ndarray import MRI3Daxes
fn_hrf = add_prefix(op.join(output_dir, 'hrf.nii'), prefix)
logger.info('hrf flat shape %s', str(simulation['hrf'].shape))
if simulation['hrf'].ndim == 1:
hrf = (np.ones(mask_vol.size) * simulation['hrf'][:, np.newaxis])
else:
hrf = simulation['hrf']
hrfs_vol = expand_array_in_mask(hrf, mask_vol, flat_axis=1)
dt = simulation['dt']
chrfs = xndarray(hrfs_vol, axes_names=['time', ] + MRI3Daxes,
axes_domains={'time': np.arange(hrfs_vol.shape[0]) * dt})
chrfs.save(fn_hrf, vol_meta)
ttp_vol = hrfs_vol.argmax(0)
fn_ttp = add_prefix(op.join(output_dir, 'ttp.nii'), prefix)
write_volume(ttp_vol, fn_ttp, vol_meta)
if simulation.has_key('brf'):
from pyhrf.ndarray import MRI3Daxes
fn_brf = add_prefix(op.join(output_dir, 'brf.nii'), prefix)
logger.info('brf flat shape %s', str(simulation['brf'].shape))
brfs_vol = expand_array_in_mask(
simulation['brf'], mask_vol, flat_axis=1)
dt = simulation['dt']
cbrfs = xndarray(brfs_vol, axes_names=['time', ] + MRI3Daxes,
axes_domains={'time': np.arange(brfs_vol.shape[0]) * dt})
cbrfs.save(fn_brf, vol_meta)
if simulation.has_key('prf'):
from pyhrf.ndarray import MRI3Daxes
fn_brf = add_prefix(op.join(output_dir, 'prf.nii'), prefix)
logger.info('prf flat shape %s', str(simulation['prf'].shape))
brfs_vol = expand_array_in_mask(
simulation['prf'], mask_vol, flat_axis=1)
dt = simulation['dt']
cbrfs = xndarray(brfs_vol, axes_names=['time', ] + MRI3Daxes,
axes_domains={'time': np.arange(brfs_vol.shape[0]) * dt})
cbrfs.save(fn_brf, vol_meta)
if simulation.has_key('drift'):
fn_drift = add_prefix(op.join(output_dir, 'drift.nii'), prefix)
logger.info('drift flat shape %s', str(simulation['drift'].shape))
drift_vol = expand_array_in_mask(simulation['drift'], mask_vol,
flat_axis=1)
write_volume(np.rollaxis(drift_vol, 0, 4), fn_drift)
if simulation.has_key('drift_coeffs'):
fn_drift = add_prefix(op.join(output_dir, 'drift_coeffs.nii'), prefix)
logger.info(
'drift flat shape %s', str(simulation['drift_coeffs'].shape))
drift_vol = expand_array_in_mask(simulation['drift'], mask_vol,
flat_axis=1)
write_volume(np.rollaxis(drift_vol, 0, 4), fn_drift)
if simulation.has_key('noise'):
fn_noise = add_prefix(op.join(output_dir, 'noise.nii'), prefix)
logger.info('noise flat shape %s', str(simulation['noise'].shape))
noise_vol = expand_array_in_mask(simulation['noise'], mask_vol,
flat_axis=1)
write_volume(np.rollaxis(noise_vol, 0, 4), fn_noise, vol_meta)
fn_noise = add_prefix(op.join(output_dir, 'noise_emp_var.nii'), prefix)
noise_vol = expand_array_in_mask(simulation['noise'].var(0), mask_vol)
write_volume(noise_vol, fn_noise, vol_meta)
if simulation.has_key('noise_var'):
fn_noise_var = add_prefix(op.join(output_dir, 'noise_var.nii'), prefix)
logger.info(
'noise_var flat shape %s', str(simulation['noise_var'].shape))
noise_var_vol = expand_array_in_mask(simulation['noise_var'], mask_vol)
write_volume(noise_var_vol, fn_noise_var, vol_meta)
if simulation.has_key('stim_induced_signal'):
fn_stim_induced = add_prefix(op.join(output_dir, 'stim_induced.nii'),
prefix)
logger.info('stim_induced flat shape %s',
str(simulation['stim_induced_signal'].shape))
stim_induced_vol = expand_array_in_mask(simulation['stim_induced_signal'],
mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
if simulation.has_key('perf_stim_induced'):
fn_stim_induced = add_prefix(op.join(output_dir, 'perf_stim_induced.nii'),
prefix)
logger.info('asl_stim_induced flat shape %s',
str(simulation['perf_stim_induced'].shape))
stim_induced_vol = expand_array_in_mask(simulation['perf_stim_induced'],
mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
fn_stim_induced = add_prefix(op.join(output_dir,
'perf_stim_induced_ct.nii'),
prefix)
logger.info('asl_stim_induced flat shape %s',
str(simulation['perf_stim_induced'].shape))
dsf = simulation['dsf']
perf = np.dot(simulation['ctrl_tag_mat'],
simulation['perf_stim_induced'][0:-1:dsf])
stim_induced_vol = expand_array_in_mask(perf, mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
if simulation.has_key('perf_baseline'):
fn = add_prefix(op.join(output_dir, 'perf_baseline.nii'), prefix)
pb = np.zeros_like(simulation['bold']) + simulation['perf_baseline']
write_volume(expand_array_in_mask(pb[0], mask_vol), fn, vol_meta)
if simulation.has_key('bold_stim_induced'):
fn_stim_induced = add_prefix(op.join(output_dir, 'bold_stim_induced.nii'),
prefix)
logger.info('asl_stim_induced flat shape %s',
str(simulation['bold_stim_induced'].shape))
stim_induced_vol = expand_array_in_mask(simulation['bold_stim_induced'],
mask_vol, flat_axis=1)
write_volume(np.rollaxis(stim_induced_vol, 0, 4), fn_stim_induced)
m = np.where(mask_vol)
labels_and_mask = mask_vol.copy()[m]
for ic in xrange(simulation['labels'].shape[0]):
if simulation.has_key('condition_defs'):
c_name = simulation['condition_defs'][ic].name
else:
c_name = 'cond%d' % ic
fn_labels = add_prefix(op.join(output_dir, 'labels_%s.nii' % c_name),
prefix)
if simulation.has_key('labels'):
labels_c = simulation['labels'][ic]
labels_and_mask[np.where(labels_c)] = ic + 2
write_volume(expand_array_in_mask(labels_c, mask_vol).astype(np.int32),
fn_labels, vol_meta)
elif simulation.has_key('labels_vol'):
labels_c = simulation['labels_vol'][ic]
labels_and_mask[np.where(labels_c[m])] = ic + 2
write_volume(labels_c.astype(np.int32), fn_labels, vol_meta)
if simulation.has_key('nrls'):
nrls_c = simulation['nrls'][ic]
fn = add_prefix(
op.join(output_dir, 'nrls_%s.nii' % c_name), prefix)
write_volume(expand_array_in_mask(nrls_c, mask_vol), fn, vol_meta)
if simulation.has_key('nrls_session'):
nrls_session_c = simulation['nrls_session'][ic]
fn = add_prefix(op.join(output_dir, 'nrls_session_%s.nii'
% (c_name)), prefix)
write_volume(expand_array_in_mask(nrls_session_c, mask_vol),
fn, vol_meta)
if simulation.has_key('brls'):
brls_c = simulation['brls'][ic]
fn = add_prefix(
op.join(output_dir, 'brls_%s.nii' % c_name), prefix)
write_volume(expand_array_in_mask(brls_c, mask_vol), fn, vol_meta)
if simulation.has_key('prls'):
prls_c = simulation['prls'][ic]
fn = add_prefix(
op.join(output_dir, 'prls_%s.nii' % c_name), prefix)
write_volume(expand_array_in_mask(prls_c, mask_vol), fn, vol_meta)
if simulation.has_key('neural_efficacies'):
ne_c = simulation['neural_efficacies'][ic]
fn = add_prefix(op.join(output_dir, 'neural_efficacies_%s.nii'
% c_name), prefix)
write_volume(expand_array_in_mask(ne_c, mask_vol), fn, vol_meta)
fn_labels_and_mask = add_prefix(op.join(output_dir, 'mask_and_labels.nii'),
prefix)
write_volume(expand_array_in_mask(labels_and_mask, mask_vol).astype(int),
fn_labels_and_mask, vol_meta)
if simulation.has_key('bold_full_vol') or simulation.has_key('bold'):
fn = add_prefix(op.join(output_dir, 'bold.nii'), prefix)
if simulation.has_key('bold_full_vol'):
bold4D = simulation['bold_full_vol']
else:
bold = simulation['bold']
bold4D = expand_array_in_mask(bold, mask_vol, flat_axis=1)
write_volume(np.rollaxis(bold4D, 0, 4), fn, vol_meta)
def save_time_series(k):
if simulation.has_key(k):
fn_stim_induced = add_prefix(
op.join(output_dir, k + '.nii'), prefix)
logger.info('%s flat shape %s', k, str(simulation[k].shape))
vol = expand_array_in_mask(simulation[k], mask_vol, flat_axis=1)
write_volume(np.rollaxis(vol, 0, 4), fn_stim_induced)
save_time_series('flow_induction')
save_time_series('cbv')
save_time_series('hbr')
save_time_series('bold_stim_induced_rescaled')
if simulation.has_key('asl'):
fn = add_prefix(op.join(output_dir, 'asl.nii'), prefix)
asl4D = expand_array_in_mask(simulation['asl'], mask_vol, flat_axis=1)
write_volume(np.rollaxis(asl4D, 0, 4), fn, vol_meta)
if simulation.has_key('outliers'):
fn = add_prefix(op.join(output_dir, 'outliers.nii'), prefix)
outliers = expand_array_in_mask(simulation['outliers'], mask_vol,
flat_axis=1)
write_volume(np.rollaxis(outliers, 0, 4), fn, vol_meta)
if simulation.has_key('hrf_group'):
hrfgroup = simulation['hrf_group']
nb_vox = mask_vol.size
fn_hrf = add_prefix(op.join(output_dir, 'hrf_group.nii'), prefix)
logger.info('hrf group shape %s', str(simulation['hrf_group'].shape))
hrfGd = duplicate_hrf(nb_vox, hrfgroup)
hrfs_vol = expand_array_in_mask(hrfGd, mask_vol, flat_axis=1)
dt = simulation['dt']
chrfs = xndarray(hrfs_vol, axes_names=['time', ] + MRI3Daxes,
axes_domains={'time': np.arange(hrfs_vol.shape[0]) * dt})
chrfs.save(fn_hrf, vol_meta)
if bold_3D_vols_dir is not None:
assert op.exists(bold_3D_vols_dir)
for iscan, bscan in enumerate(bold4D):
fnout = add_prefix('bold_%06d.nii' % (iscan), prefix)
write_volume(bscan, op.join(bold_3D_vols_dir, fnout), vol_meta)
def make_outfile(fn, path, pre='', suf=''):
if fn is None or path is None:
return None
ofn = op.join(path, fn)
return add_prefix(add_suffix(ofn, suf), pre)
from pyhrf.ui.vb_jde_analyser import JDEVEMAnalyser as VBJDE
from pyhrf.ui.jde import DEFAULT_CFG_FILE as DEFAULT_CFG_FILE_JDE
from pyhrf.jde.models import BOLDGibbsSampler as BG
from pyhrf.jde.beta import BetaSampler as BS
from pyhrf.jde.nrl.bigaussian import NRLSampler as NS
from pyhrf.jde.nrl.trigaussian import GGGNRLSampler as NS3
from pyhrf.jde.hrf import RHSampler as HVS
from pyhrf.jde.hrf import HRFSampler as HS
#VT = FMRIVolumeTreatment
#ST = FMRISurfaceTreatment
DEFAULT_JDE_OUT_MASK_VOL = add_prefix(DEFAULT_OUT_MASK_VOL_FILE, 'jde_')
DEFAULT_JDE_OUT_MASK_SURF = add_prefix(DEFAULT_OUT_MASK_SURF_FILE, 'jde_')
def make_outfile(fn, path, pre='', suf=''):
if fn is None or path is None:
return None
ofn = op.join(path, fn)
return add_prefix(add_suffix(ofn, suf), pre)
def create_treatment(boldFiles,
parcelFile,
dt,
tr,
paradigmFile,
def outputResults_old2(self, results, output_dir, filter='.\A',):
"""
Return: a tuple (dictionary of outputs, output file names)
"""
if output_dir is None:
return {}, []
if not isinstance(results[0][0], FmriData, FmriGroupData):
self.outputResults_back_compat(results, output_dir, filter)
return {}, []
pyhrf.verbose(1,'Building outputs from %d results ...' %len(results))
pyhrf.verbose(6, 'results :')
pyhrf.verbose.printDict(6, results, exclude=['xmlHandler'])
to_pop = []
for i,r in enumerate(results[:]):
roi_data,result,report = r
roi_id = roi_data.get_roi_id()
if report != 'ok':
pyhrf.verbose(1, '-> Sampling crashed, roi %d!' \
%roi_id)
pyhrf.verbose(2, report)
to_pop.insert(0,i)
elif result is None:
pyhrf.verbose(1, '-> Sampling crashed (result is None), '
'roi %d!' %roi_id)
to_pop.insert(0,i)
for i in to_pop:
results.pop(i)
if len(results) == 0:
pyhrf.verbose(1, 'No more result to treat. Did everything crash ?')
return {}, []
target_shape = results[0][0].spatial_shape
meta_data = results[0][0].meta_obj
if len(target_shape) == 3: #Volumic data:
targetAxes = MRI3Daxes #['axial','coronal', 'sagittal']
ext = '.nii'
else: #surfacic
targetAxes = ['voxel']
ext = '.gii'
def genzip(gens):
while True:
yield [g.next() for g in gens]
coutputs = {}
output_fns = []
pyhrf.verbose(1,'Get each ROI output ...')
#print 'roi outputs:'
if hasattr(results[0][1], 'getOutputs'):
gen_outputs = [r[1].getOutputs() for r in results]
else:
gen_outputs = [r[1].iteritems() for r in results]
data_rois = [r[0] for r in results]
irois = [d.get_roi_id() for d in data_rois]
for roi_outputs in genzip(gen_outputs):
output_name = roi_outputs[0][0]
pyhrf.verbose(3,'Merge output %s ...' %output_name)
try:
if roi_outputs[0][1].has_axis('voxel'):
pyhrf.verbose(5,'Merge as expansion ...')
dest_c = None
for data_roi,output in zip(data_rois,roi_outputs):
_, c = output
roi_mask = (data_roi.roiMask != data_roi.backgroundLabel)
dest_c = c.expand(roi_mask, 'voxel', targetAxes,
dest=dest_c)
else:
pyhrf.verbose(5,'Merge as stack (%d elements)...' \
%len(irois))
c_to_stack = [roi_outputs[i][1] for i in np.argsort(irois)]
# print 'c_to_stack:', c_to_stack
# print 'sorted(irois):', sorted(irois)
dest_c = stack_cuboids(c_to_stack, domain=sorted(irois),
axis='ROI')
except Exception, e:
print "Could not merge outputs for %s" %output_name
print "Exception was:"
print e
#raise e #stop here
if 0 and dest_c is not None:
print '-> ', dest_c.data.shape
output_fn = op.join(output_dir,output_name + ext)
output_fn = add_prefix(output_fn, self.outPrefix)
output_fns.append(output_fn)
pyhrf.verbose(5,'Save output %s to %s' %(output_name, output_fn))
try:
dest_c.save(output_fn, meta_data=meta_data,
set_MRI_orientation=True)
except Exception:
print 'Could not save output "%s", error stack was:' \
%output_name
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback,
limit=4, file=sys.stdout)
coutputs[output_name] = dest_c
