def main(sourcedata,
derivatives,
subject,
session):
out_dir = op.join(derivatives,
'pycortex',
'sub-{}'.format(subject))
for version in ['light', 'full']:
d = op.join(out_dir, version)
if not op.exists(d):
os.makedirs(d)
if subject not in cortex.db.subjects:
cortex.fmriprep.import_subj(subject, '/derivatives', None, dataset='odc')
pc_subject = 'odc.{}'.format(subject)
images = {}
t1w = get_bids_file(derivatives, 'averaged_mp2rages', 'anat',
subject, 'T1w', session, 'average')
images['t1w'] = cortex.Volume(t1w, pc_subject, 'identity', vmin=0, vmax=4095)
t1map = get_bids_file(derivatives, 'averaged_mp2rages', 'anat',
subject, 'T1map', session, 'average')
images['t1map'] = cortex.Volume(t1map, pc_subject, 'identity', vmin=1000, vmax=2200)
t2starmap = get_bids_file(derivatives, 'qmri_memp2rages', 'anat',
subject, 't2starmap', session, 'average')
images['t2starmap'] = cortex.Volume(t2starmap, pc_subject, 'identity', vmin=10, vmax=60)
s0 = get_bids_file(derivatives, 'qmri_memp2rages', 'anat',
subject, 'S0', session, 'average')
images['s0'] = cortex.Volume(s0, pc_subject, 'identity')
for echo_ix in range(1,5):
echo = get_bids_file(sourcedata, '', 'anat', subject, 'MPRAGE',
session='anat', acquisition='memp2rage', echo=echo_ix,
inversion=2, part='mag')
if echo_ix == 1:
transform = cortex.xfm.Transform(np.identity(4), echo)
transform.save(subject, 'memp2rage')
max_first_echo = np.percentile(image.load_img(echo).get_data(), 95)
images['echo{}'.format(echo_ix)] = cortex.Volume(echo,
pc_subject,
'memp2rage',
vmin=0,
vmax=max_first_echo)
ds = cortex.Dataset(t1map=images['t1map'],
s0=images['s0'],
t2starmap=images['t2starmap'])
cortex.webgl.make_static(op.join(out_dir, 'light'), ds)
cortex.webshow(ds)
ds = cortex.Dataset(**images)
cortex.webgl.make_static(op.join(out_dir, 'full'), ds)
cortex.webshow(ds)
def main(derivatives, subject, session):
all_depth_zmap_l = op.join(
derivatives, 'sampled_giis', f'sub-{subject}', f'ses-{session}',
'func',
f'sub-{subject}_ses-{session}_left_over_right_desc-zmap-depth-all_hemi-lh.gii'
)
all_depth_zmap_r = op.join(
derivatives, 'sampled_giis', f'sub-{subject}', f'ses-{session}',
'func',
f'sub-{subject}_ses-{session}_left_over_right_desc-zmap-depth-all_hemi-rh.gii'
)
all_depth_zmap = np.hstack((surface.load_surf_data(all_depth_zmap_l),
surface.load_surf_data(all_depth_zmap_r)))
abs_zmap_l = op.join(
derivatives, 'sampled_giis', f'sub-{subject}', f'ses-{session}',
'func',
f'sub-{subject}_ses-{session}_left_over_right_desc-abszmap-depth-all_hemi-lh_smoothed.gii'
)
abs_zmap_r = op.join(
derivatives, 'sampled_giis', f'sub-{subject}', f'ses-{session}',
'func',
f'sub-{subject}_ses-{session}_left_over_right_desc-abszmap-depth-all_hemi-rh_smoothed.gii'
)
abs_zmap = np.hstack((surface.load_surf_data(abs_zmap_l),
surface.load_surf_data(abs_zmap_r)))
images = {}
images['all_depth_zmap'] = cortex.Vertex(all_depth_zmap, f'odc.{subject}')
images['abs_zmap_smooth'] = cortex.Vertex(abs_zmap, f'odc.{subject}')
ds = cortex.Dataset(**images)
cortex.webshow(ds)
def test_overwrite():
tf = tempfile.NamedTemporaryFile(suffix=".hdf")
ds = cortex.Dataset(test=(np.random.randn(*volshape), subj, xfmname))
ds.save(tf.name)
ds.save()
assert ds.test.data.shape == volshape
def generate_pycortex_static(volumes, output_dir):
app_path = os.path.abspath(os.path.dirname(__file__))
tpl_path = os.path.join(app_path, 'templates/pycortex/dataview.html')
ds = cortex.Dataset(**volumes)
cortex.webgl.make_static(output_dir,
ds,
template=tpl_path,
html_embed=False,
copy_ctmfiles=False)
def test_mask_save():
tf = tempfile.NamedTemporaryFile(suffix=".hdf")
ds = cortex.Dataset(test=(np.random.randn(*volshape), subj, xfmname))
ds.append(masked=ds.test.masked['thin'])
data = ds.masked.data
ds.save(tf.name)
ds = cortex.load(tf.name)
assert ds.masked.shape == volshape
assert np.allclose(ds.masked.data, data)
def main(subject, session, sourcedata, standard_space=False, thr=thr, smoothed=False):
left, right = cortex.db.get_surf(f'sub-{subject}', 'fiducial', merge=False)
left, right = cortex.Surface(*left), cortex.Surface(*right)
d = {}
if standard_space:
space = 'fsaverage'
d['wang15_ips'] = get_wang15_ips('fsaverage', sourcedata)
fs_subject = 'fsaverage'
else:
space = 'fsnative'
d['wang15_ips'] = get_wang15_ips(subject, sourcedata)
fs_subject = f'sub-{subject}'
key = 'encoding_model.cv'
if smoothed:
key += '.smoothed'
for session in ['3t2', '7t2']:
r2_cv = []
for run in range(1, 9):
r2 = []
for hemi in ['L', 'R']:
r2.append(surface.load_surf_data(op.join(sourcedata, 'derivatives', f'{key}/sub-{subject}/ses-{session}/func/sub-{subject}_ses-{session}_run-{run}_desc-cvr2.optim_space-{space}_hemi-{hemi}.func.gii')))
r2_cv.append(np.concatenate(r2))
r2_cv = np.mean(np.clip(r2_cv, 0.0, np.inf), 0)
print(np.quantile(r2_cv, .95))
alpha = np.clip(r2_cv-thr, 0., .1) /.1
d[f'r2_cv.{session}'] = get_alpha_vertex(r2_cv, alpha, cmap='hot',
subject=subject, vmin=0.0, vmax=.5, standard_space=standard_space)
r2 = _load_parameters(subject, session, 'r2.optim', space, smoothed)
alpha = np.clip(r2.data-thr, 0., .1) /.1
d[f'r2.{session}'] = get_alpha_vertex(r2.data, alpha, cmap='hot',
subject=subject, vmin=0.0, vmax=.5, standard_space=standard_space)
ds = cortex.Dataset(**d)
cortex.webshow(ds)
x = np.linspace(0, 1, 101, True)
y = np.linspace(np.log(5), np.log(vmax), len(x), True)
def main(subject, derivatives, desc='test2', pc_subject=None):
if pc_subject is None:
pc_subject = 'odc.{}'.format(subject)
pars_grid = np.load(
op.join(derivatives, 'prf', 'vertices',
'sub-{subject}_desc-{desc}_prf_grid.npz').format(**locals()))
pars_optim = np.load(
op.join(derivatives, 'prf', 'vertices',
'sub-{subject}_desc-{desc}_prf_optim.npz').format(**locals()))
images = {}
r2_grid = pars_grid['r2']
r2_optim = pars_optim['r2']
angle_grid = pars_grid['angle']
angle_optim = pars_optim['angle']
ecc_grid = pars_grid['ecc']
ecc_optim = pars_optim['ecc']
size_grid = pars_grid['size']
size_optim = pars_optim['size']
images['r2_grid'] = cortex.Vertex(r2_grid, pc_subject, vmin=0, vmax=0.65)
images['r2_optim'] = cortex.Vertex(r2_optim, pc_subject, vmin=0, vmax=0.65)
images['angle_grid'] = cortex.Vertex(angle_grid,
pc_subject,
cmap='hsv',
vmin=-3.14,
vmax=3.14)
images['angle_optim'] = cortex.Vertex(angle_optim,
pc_subject,
cmap='hsv',
vmin=-3.14,
vmax=3.14)
images['ecc_grid'] = cortex.Vertex(ecc_grid, pc_subject, vmin=0, vmax=12)
images['ecc_optim'] = cortex.Vertex(ecc_optim, pc_subject, vmin=0, vmax=12)
images['size_grid'] = cortex.Vertex(size_grid, pc_subject, vmin=0, vmax=12)
images['size_optim'] = cortex.Vertex(size_optim,
pc_subject,
vmin=0,
vmax=12)
ds = cortex.Dataset(**images)
cortex.webshow(ds)
def test_pack():
tf = tempfile.NamedTemporaryFile(suffix=".hdf")
ds = cortex.Dataset(test=(np.random.randn(*volshape), subj, xfmname))
ds.save(tf.name, pack=True)
ds = cortex.load(tf.name)
pts, polys = cortex.db.get_surf(subj, "fiducial", "lh")
dpts, dpolys = ds.get_surf(subj, "fiducial", "lh")
assert np.allclose(pts, dpts)
rois = cortex.db.get_overlay(subj, "rois")
# Dataset.get_overlay returns a file handle, not an ROIpack ?
#assert rois.rois.keys() == ds.get_overlay(subj, "rois").rois.keys()
xfm = cortex.db.get_xfm(subj, xfmname)
assert np.allclose(xfm.xfm, ds.get_xfm(subj, xfmname).xfm)
def test_dataset_save():
tf = tempfile.NamedTemporaryFile(suffix=".hdf")
mrand = np.random.randn(2, *volshape)
rand = np.random.randn(*volshape)
ds = cortex.Dataset(test=(mrand, subj, xfmname))
ds.append(twod=cortex.Volume2D(rand, rand, subj, xfmname))
ds.append(rgb=cortex.VolumeRGB(rand, rand, rand, subj, xfmname))
ds.append(vert=cortex.Vertex.random(subj))
ds.save(tf.name)
ds = cortex.load(tf.name)
assert isinstance(ds.test, cortex.Volume)
assert ds.test.data.shape == mrand.shape
assert isinstance(ds.twod, cortex.Volume2D)
assert ds.twod.dim1.data.shape == rand.shape
assert ds.twod.dim2.data.shape == rand.shape
assert ds.rgb.volume.shape == tuple([1] + list(volshape) + [4])
assert isinstance(ds.vert, cortex.Vertex)
def generate_pycortex_static(volumes, output_dir, title=None):
"""
Parameters
----------
volumes: dict
key is volume name; value is a set of images.
output_dir: str
file location to dump output html
title: str (optional)
HTML title of pycortex viewer.
"""
app_path = os.path.abspath(os.path.dirname(__file__))
tpl_path = os.path.join(app_path, 'templates/pycortex/dataview.html')
ds = cortex.Dataset(**volumes)
title = title or ', '.join(volumes.keys())
cortex.webgl.make_static(output_dir, ds, template=tpl_path, html_embed=False,
copy_ctmfiles=False, title=title)
def test_pack():
tf = tempfile.NamedTemporaryFile(suffix=".hdf")
ds = cortex.Dataset(test=(np.random.randn(*volshape), subj, xfmname))
ds.save(tf.name, pack=True)
ds = cortex.load(tf.name)
pts, polys = cortex.db.get_surf(subj, "fiducial", "lh")
dpts, dpolys = ds.get_surf(subj, "fiducial", "lh")
assert np.allclose(pts, dpts)
overlay_db = cortex.db.get_overlay(subj, None, modify_svg_file=False)
rois_db = overlay_db.rois.labels.elements.keys()
# keep the temporary file object in memory to avoid the file being deleted
temp_file = ds.get_overlay(subj, "rois")
overlay_ds = cortex.db.get_overlay(subj,
temp_file.name,
modify_svg_file=False)
rois_ds = overlay_ds.rois.labels.elements.keys()
assert rois_db == rois_ds
xfm = cortex.db.get_xfm(subj, xfmname)
assert np.allclose(xfm.xfm, ds.get_xfm(subj, xfmname).xfm)
op.join(derivatives, 'modelfit_surf_smoothed', f'sub-*', 'func',
f'sub-*_space-fsaverage_desc-r2_hemi-L.func.gii'))
log_r2_l = np.mean([surface.load_surf_data(fn) for fn in log_r2_l], 0)
log_r2_r = glob.glob(
op.join(derivatives, 'modelfit_surf_smoothed', f'sub-*', 'func',
f'sub-*_space-fsaverage_desc-r2_hemi-R.func.gii'))
log_r2_r = np.mean([surface.load_surf_data(fn) for fn in log_r2_r], 0)
log_r2 = cortex.Vertex(np.hstack((log_r2_l, log_r2_r)), 'fsaverage')
nat_r2_l = glob.glob(
op.join(derivatives, 'modelfit_surf_smoothed_natural_space', f'sub-*',
'func', f'sub-*_space-fsaverage_desc-r2_hemi-L.func.gii'))
nat_r2_l = np.mean([surface.load_surf_data(fn) for fn in nat_r2_l], 0)
nat_r2_r = glob.glob(
op.join(derivatives, 'modelfit_surf_smoothed_natural_space', f'sub-*',
'func', f'sub-*_space-fsaverage_desc-r2_hemi-R.func.gii'))
nat_r2_r = np.mean([surface.load_surf_data(fn) for fn in nat_r2_r], 0)
nat_r2 = cortex.Vertex(np.hstack((nat_r2_l, nat_r2_r)), 'fsaverage')
diff_r2 = cortex.Vertex(log_r2.data - nat_r2.data, 'fsaverage')
ds = cortex.Dataset(log_r2=log_r2, nat_r2=nat_r2, diff_r2=diff_r2)
plt.scatter(log_r2.data, nat_r2.data)
plt.plot([0, 1], [0, 1], c='k')
plt.show()
cortex.webshow(ds)
roi_mni[roi_mni_tmp] = 1 print roi_mni.shape # Transform ROI to Subject space print "Transform ROI to subject space" roi_func = transform_mni_to_subject(subject, xfmname, roi_mni, func_to_mni) roi_func = roi_func.get_data() # roi_func = np.where(roi_func, 1, 0) # Make sure things are binary print roi_func.shape # Save ROI (MNI space) as NIFTI file roi_mni_nii = ni.Nifti1Image(roi_mni, xfm_mni) filename = "/tmp/roi_mni.nii" roi_mni_nii.to_filename(filename) # Save ROI (subject space) as NIFTI file ref_filename = cortex.db.get_xfm(subject, xfmname).reference.get_filename() xfm_subject = ni.load(ref_filename).get_affine() roi_func_nii = ni.Nifti1Image(roi_func, xfm_subject) filename = "/tmp/roi_func.nii" roi_func_nii.to_filename(filename) # Create static viewer roivol = cortex.Volume(roi_func.T, subject, xfmname, cmap='gray_r', mask=mask) mastervol = dict() mastervol["roivol"] = roivol ds = cortex.Dataset(**mastervol) viewername = "/tmp/roi_viewer" cortex.webgl.make_static(viewername, ds)
Recently, many people have start to use fmriprep as a complete preprocessing workflow of anatomical and functional data. Pycortex has a convenience function to import the output of this workflow. This example is based on the fmriprep 1.0.15 output of openfmri ds000164 that can be found on openneuro.org: https://openneuro.org/datasets/ds000164/versions/00001 NB: `cortex.fmriprep` is a work-in-progress and cannot currently handle multiple datasets when the subject IDs are the same (see https://github.com/gallantlab/pycortex/issues/304). """ import cortex from cortex import fmriprep from os import path as op # Location of the downloaded openfmri dataset source_directory = '/derivatives/ds000164' # fmriprep subject name (without "sub-") subject_id = '001' # import subject into pycortex database fmriprep.import_subj(subject_id, source_directory) # We can use visualize the imported subject's T1-weighted image anat_nifti = 'fmriprep/sub-001/anat/sub-001_T1w_preproc.nii.gz' t1_image_path = op.join(source_directory, anat_nifti) # Now we can make a volume using the built-in identity transform t1w_volume = cortex.Volume(t1_image_path, subject_id, 'identity') # And show the result. ds = cortex.Dataset(t1w=t1w_volume) cortex.webgl.show(ds)
try:
os.makedirs(dataset_dir)
os.makedirs(webviewer_dir)
except:
pass
tc_file = "{base_dir}/pp_data/{subject}/func/{subject}_task-{tc_file_end}.nii.gz".format(
base_dir=base_dir, subject=subject, tc_file_end=tc_file_end)
print('load: {} {}'.format(subject, tc_file_end))
img_tc = nb.load(tc_file)
tc = img_tc.get_data()
# create volume
volume_tc = cortex.Volume(data=tc.transpose((3, 2, 1, 0)),
subject=subject,
xfmname=xfm_name,
cmap='BuBkRd',
description='BOLD')
# create dataset
print('save pycortex dataset: time course')
dataset_tc = cortex.Dataset(data=volume_tc)
dataset_tc.save("{dataset_dir}{tc_file_end}_tc.hdf".format(
tc_file_end=tc_file_end, dataset_dir=dataset_dir))
# create webgl
print('save pycortex webviewer: time course')
cortex.webgl.make_static(outpath=webviewer_dir, data=volume_tc)
alpha,
cmap='hot',
subject=subject,
vmin=0.0,
vmax=0.4,
standard_space=True)
d[f'mu_{subject}.{session}_volsurf'] = get_alpha_vertex(
mu.data,
alpha,
cmap='nipy_spectral',
subject=subject,
vmin=np.log(5),
vmax=np.log(28),
standard_space=True)
com = surface.load_surf_data(
op.join(bids_folder, 'derivatives', 'npc_com',
f'sub-{subject}_space-fsaverage_desc-npcr_com.gii'))
com = np.concatenate((np.zeros_like(com), com))
d[f'com_npcr_{subject}.{session}_volsurf'] = cortex.Vertex(com,
'fsaverage',
vmin=.5,
vmax=1.0)
ds = cortex.Dataset(**d)
cortex.webshow(ds)
def main(pars,
make_svg,
derivatives,
old=False,
recache=False,
pc_subject=None):
if pc_subject is None:
reg = re.compile('.*/sub-(?P<subject>[a-z0-9]+)_.*')
subject = reg.match(pars).group(1)
pc_subject = 'odc.{}'.format(subject)
if old:
pc_subject += '.old'
#mean_epi = '{derivatives}/spynoza/ses-prffunc/sub-subject/.nii.gz'.format(**locals())
prf_pars = np.load(pars)
images = {}
r2 = prf_pars['r2']
mask = r2 < 0.05
angle = prf_pars['angle']
#angle[mask] = np.nan
ecc = prf_pars['ecc']
ecc[mask] = np.nan
size = prf_pars['size']
size[mask] = np.nan
images['ecc'] = cortex.Vertex(ecc, pc_subject, vmin=0, vmax=15)
r2_max = np.max(r2)
r2_max = 0.3
r2_min = 0.15
hsv_angle = np.ones((len(r2), 3))
hsv_angle[:, 0] = angle
hsv_angle[:, 1] = np.clip(r2 / r2_max * 2, 0, 1)
hsv_angle[:, 2] = r2 > r2_min
left_index = cortex.db.get_surfinfo(pc_subject).left.shape[0]
angle_ = hsv_angle[:left_index, 0]
hsv_angle[:left_index, 0] = np.clip(
((angle_ + np.pi) - 0.25 * np.pi) / (1.5 * np.pi), 0, 1)
angle_ = -hsv_angle[left_index:, 0].copy()
angle_[hsv_angle[left_index:, 0] > 0] += 2 * np.pi
angle_ = np.clip((angle_ - 0.25 * np.pi) / 1.5 / np.pi, 0, 1)
hsv_angle[left_index:, 0] = angle_
rgb_angle = colors.hsv_to_rgb(hsv_angle)
#alpha_angle = np.clip(r2 / r2_max * 2, r2_min/r2_max, 1)
#alpha_angle[alpha_angle < r2_min/r2_max] = 0
alpha_angle = hsv_angle[:, 2]
images['angle'] = cortex.VertexRGB(
rgb_angle[:, 0],
rgb_angle[:, 1],
rgb_angle[:, 2],
#alpha=np.ones(len(rgb_angle)),
alpha=alpha_angle,
subject=pc_subject)
images['angle_1d'] = cortex.Vertex(angle,
pc_subject,
vmin=-3.14,
vmax=3.14,
cmap='hsv')
images['r2'] = cortex.Vertex(r2, pc_subject, vmin=0, vmax=r2_max)
#images['ecc'] = cortex.Vertex2D(ecc/15, r2/r2_max, cmap='BuBkRd_alpha_2D', subject=pc_subject, vmin=.15, vmax=1)
v1_ix, v1_values = cortex.freesurfer.get_label(pc_subject,
'V1_exvivo',
'sub-{}'.format(subject),
fs_dir=op.join(
derivatives,
'freesurfer'))
vt_v1 = np.zeros_like(r2)
vt_v1[v1_ix] = v1_values
images['fs_v1'] = cortex.Vertex(vt_v1, pc_subject)
v2_ix, v2_values = cortex.freesurfer.get_label(pc_subject,
'V2_exvivo',
'sub-{}'.format(subject),
fs_dir=op.join(
derivatives,
'freesurfer'))
vt_v2 = np.zeros_like(r2)
vt_v2[v2_ix] = v2_values
images['fs_v2'] = cortex.Vertex(vt_v2, pc_subject)
layout = BIDSLayout(op.join(derivatives, 'tsnr'), validate=False)
veins = layout.get(subject=subject,
session='prf',
suffix='invtsnr',
return_type='file')
if len(veins) > 0:
veins = image.mean_img(veins)
t1w = cortex.db.get_anat(pc_subject, 'raw')
veins = image.resample_to_img(veins, t1w)
images['veins'] = cortex.Volume(veins.get_data().T,
subject=pc_subject,
xfmname='identity',
vmin=0,
vmax=2)
if make_svg:
cortex.utils.add_roi(data=images['angle'],
name='prf_angle',
open_inkscape=False)
cortex.utils.add_roi(data=images['angle_1d'],
name='prf_angle_1d',
open_inkscape=False)
cortex.utils.add_roi(data=images['ecc'],
name='prf_ecc',
open_inkscape=False)
cortex.utils.add_roi(data=images['fs_v1'],
name='Freesurfer V1',
open_inkscape=False)
cortex.utils.add_roi(data=images['fs_v2'],
name='Freesurfer V2',
open_inkscape=False)
else:
ds = cortex.Dataset(**images)
cortex.webshow(ds, recache=recache)
def main(derivatives, subject):
pc_subject = 'odc.{}'.format(subject)
coordinates = []
for hemi in ['lh', 'rh']:
coordinates.append(
pd.read_pickle(
op.join(
derivatives, 'coordinate_patches', 'sub-{subject}', 'anat',
'sub-{subject}_hemi-{hemi}_coordinatepatch.pkl').format(
**locals())))
coordinates = pd.concat(coordinates, axis=0, ignore_index=True)
print(coordinates.shape)
print(coordinates.head())
print(coordinates['x'].dtype)
images = {}
images['x'] = cortex.Vertex(coordinates['x'].values,
'odc.{}'.format(subject),
cmap='BROYG',
vmin=-35,
vmax=35)
images['y'] = cortex.Vertex(coordinates['y'].values,
'odc.{}'.format(subject),
cmap='BROYG',
vmin=-35,
vmax=35)
# PRFs
prf_pars = np.load(
op.join(derivatives,
'prf/vertices/sub-{subject}_desc-test2_prf_optim.npz').format(
**locals()))
r2 = prf_pars['r2']
mask = r2 < 0.1
angle = prf_pars['angle']
angle[mask] = np.nan
ecc = prf_pars['ecc']
ecc[mask] = np.nan
size = prf_pars['size']
size[mask] = np.nan
r2_max = np.max(r2)
r2_max = 0.3
r2_min = 0.05
hsv_angle = np.ones((len(r2), 3))
hsv_angle[:, 0] = angle.copy()
hsv_angle[:, 1] = np.clip(r2 / r2_max * 2, 0, 1)
hsv_angle[:, 2] = r2 > r2_min
left_index = cortex.db.get_surfinfo(pc_subject).left.shape[0]
angle_ = hsv_angle[:left_index, 0]
hsv_angle[:left_index, 0] = np.clip(
((angle_ + np.pi) - 0.25 * np.pi) / (1.5 * np.pi), 0, 1)
angle_ = -hsv_angle[left_index:, 0].copy()
angle_[hsv_angle[left_index:, 0] > 0] += 2 * np.pi
angle_ = np.clip((angle_ - 0.25 * np.pi) / 1.5 / np.pi, 0, 1)
hsv_angle[left_index:, 0] = angle_
rgb_angle = colors.hsv_to_rgb(hsv_angle)
alpha_angle = np.clip(r2 / r2_max * 2, r2_min / r2_max, 1)
alpha_angle[alpha_angle < r2_min / r2_max] = 0
alpha_angle = hsv_angle[:, 2]
images['angle'] = cortex.VertexRGB(
rgb_angle[:, 0],
rgb_angle[:, 1],
rgb_angle[:, 2],
#alpha=np.ones(len(rgb_angle)),
alpha=alpha_angle,
subject=pc_subject)
#images['r2'] = cortex.Vertex(prf_pars['r2'], pc_subject, cmap='inferno')
images['ecc'] = cortex.Vertex(ecc,
pc_subject,
vmin=0,
vmax=15,
cmap='inferno')
#images['angle_1d'] = cortex.Vertex(angle, pc_subject, vmin=-3.14, vmax=3.14, cmap='hsv')
#images['size'] = cortex.Vertex(size, pc_subject, vmin=0, vmax=10)
cortex.webshow(cortex.Dataset(**images))
parss_r = parss_l.replace('hemi-L', 'hemi-R')
parss = np.vstack((surface.load_surf_data(parss_r),
surface.load_surf_data(parss_r)))
mu_v = cortex.Vertex(np.exp(parss[:, 0]),
'fsaverage', vmin=0, vmax=60)
mu_log_v = cortex.Vertex(parss[:, 0], 'fsaverage', vmin=0, vmax=60)
sd_v = cortex.Vertex(np.exp(parss[:, 1]),
'fsaverage', vmin=0, vmax=60)
amplitude_v = cortex.Vertex(parss[:, 2], 'fsaverage')
baseline_v = cortex.Vertex(parss[:, 3], 'fsaverage')
ds = cortex.Dataset(
r2=r2s_v,
r2_triallise=r2s_trialwise_v,
mu=mu_v,
mu_log=mu_log_v,
sd=sd_v,
amplitude=amplitude_v,
baseline=baseline_v)
cortex.webshow(ds)
else:
subject = '*'
# r2s_cv_l = op.join(derivatives, 'modelfitsurf_cv_smoothed',
# f'sub-{subject}', 'func', f'sub-{subject}_space-fsaverage_desc-r2_hemi-L_cvrun-*.func.gii')
# r2s_cv_r = r2s_cv_l.replace('hemi-L', 'hemi-R')
# r2s_cv_l = np.clip([surface.load_surf_data(fn)
# for fn in glob.glob(r2s_cv_l)], 0, 1)
# r2s_cv_r = np.clip([surface.load_surf_data(fn)
def test_convertraw():
ds = cortex.Dataset(test=(np.random.randn(*volshape), subj, xfmname))
ds.test.raw
def main(sourcedata, derivatives, subject, session, cache=True, dataset='odc'):
if subject in []:
trans_str = '_trans'
else:
trans_str = ''
pc_subject = '{}.{}'.format(dataset, subject)
zmap = '{derivatives}/modelfitting/glm7/sub-{subject}/ses-{session}/func/sub-{subject}_ses-{session}_left_over_right_zmap{trans_str}.nii.gz'.format(
**locals())
#zmap2 = '{derivatives}/modelfitting/glm8/sub-{subject}/ses-{session}/func/sub-{subject}_ses-{session}_left_over_right_zmap{trans_str}.nii.gz'.format(**locals())
#zmap_task = '{derivatives}/modelfitting/glm7/sub-{subject}/ses-{session}/sub-{subject}_ses-{session}_left_over_right_task_zmap.nii.gz'.format(**locals())
if subject == '01':
mean_epi = '{derivatives}/spynoza/sub-{subject}/ses-{session}/func/sub-{subject}_ses-{session}_task-checkerboard_acq-07_run-03_reference{trans_str}.nii.gz'.format(
**locals())
else:
mean_epi = '{derivatives}/spynoza/sub-{subject}/ses-{session}/func/sub-{subject}_ses-{session}_task-fixation_acq-07_run-03_reference{trans_str}.nii.gz'.format(
**locals())
#psc = '{derivatives}/modelfitting/glm7/sub-{subject}/ses-{session}/sub-{subject}_ses-{session}_left_over_right_effect_size.nii.gz'.format(**locals())
abs_zmap_l = op.join(
derivatives, 'sampled_giis', f'sub-{subject}', f'ses-{session}',
'func',
f'sub-{subject}_ses-{session}_left_over_right_desc-abszmap-depth-all_hemi-lh_smoothed.gii'
)
abs_zmap_r = op.join(
derivatives, 'sampled_giis', f'sub-{subject}', f'ses-{session}',
'func',
f'sub-{subject}_ses-{session}_left_over_right_desc-abszmap-depth-all_hemi-rh_smoothed.gii'
)
images = {}
if op.exists(abs_zmap_l):
abs_zmap = np.hstack((surface.load_surf_data(abs_zmap_l),
surface.load_surf_data(abs_zmap_r)))
images['abs_zmap'] = cortex.Vertex(abs_zmap,
pc_subject,
vmin=.5,
vmax=2.3)
t1w = cortex.db.get_anat(pc_subject)
zmap = image.resample_to_img(zmap, t1w)
transform = cortex.xfm.Transform(np.identity(4), t1w)
mask = image.math_img('np.abs(zmap)', zmap=zmap)
zmap = zmap.get_data().T
zmap[zmap == 0] = np.nan
#zmap2 = zmap2.get_data().T
#zmap2[zmap2 == 0] = np.nan
mask = mask.get_data().T
images['zmap'] = cortex.Volume2D(zmap,
mask,
pc_subject,
'identity',
vmin=-3.5,
vmax=3.5,
vmin2=0,
vmax2=3,
cmap='BuBkRd_alpha_2D')
#images['zmap2'] = cortex.Volume2D(zmap2,
#mask,
#pc_subject,
#'identity.t1w', vmin=-3, vmax=3, vmin2=0, vmax2=3,
#cmap='BuBkRd_alpha_2D')
#images['abs_zmap'] = cortex.Volume(np.abs(zmap),
#pc_subject,
#'identity.t1w', vmin=-3, vmax=3, vmin2=0, vmax2=3)
##cmap='BuBkRd_alpha_2D')
#zmap_task = zmap_task.get_data().T
#zmap_task[zmap_task == 0] = np.nan
#images['zmap_task'] = cortex.Volume2D(zmap_task,
#mask,
#pc_subject,
#'identity.t1w', vmin=-3, vmax=3, vmin2=0, vmax2=3,
#cmap='BuBkRd_alpha_2D')
#images['mean_epi'] = cortex.Volume(mean_epi.get_data().T,
#pc_subject,
#'identity.t1w')
# PRFs
prf_pars = np.load(
op.join(derivatives,
'prf/vertices/sub-{subject}_desc-test2_prf_optim.npz').format(
**locals()))
r2 = prf_pars['r2']
mask = r2 < 0.1
angle = prf_pars['angle']
#angle[mask] = np.nan
ecc = prf_pars['ecc']
ecc[mask] = np.nan
size = prf_pars['size']
size[mask] = np.nan
r2_max = np.max(r2)
r2_max = 0.3
r2_min = 0.15
hsv_angle = np.ones((len(r2), 3))
hsv_angle[:, 0] = angle
hsv_angle[:, 1] = np.clip(r2 / r2_max * 2, 0, 1)
hsv_angle[:, 2] = r2 > r2_min
left_index = cortex.db.get_surfinfo(pc_subject).left.shape[0]
angle_ = hsv_angle[:left_index, 0]
hsv_angle[:left_index, 0] = np.clip(
((angle_ + np.pi) - 0.25 * np.pi) / (1.5 * np.pi), 0, 1)
angle_ = -hsv_angle[left_index:, 0].copy()
angle_[hsv_angle[left_index:, 0] > 0] += 2 * np.pi
angle_ = np.clip((angle_ - 0.25 * np.pi) / 1.5 / np.pi, 0, 1)
hsv_angle[left_index:, 0] = angle_
rgb_angle = colors.hsv_to_rgb(hsv_angle)
#alpha_angle = np.clip(r2 / r2_max * 2, r2_min/r2_max, 1)
#alpha_angle[alpha_angle < r2_min/r2_max] = 0
alpha_angle = hsv_angle[:, 2]
images['angle'] = cortex.VertexRGB(
rgb_angle[:, 0],
rgb_angle[:, 1],
rgb_angle[:, 2],
#alpha=np.ones(len(rgb_angle)),
alpha=alpha_angle,
subject=pc_subject)
#images['r2'] = cortex.Vertex(prf_pars['r2'], pc_subject, cmap='inferno')
images['ecc'] = cortex.Vertex(ecc,
pc_subject,
vmin=0,
vmax=15,
cmap='inferno')
#images['angle_1d'] = cortex.Vertex(angle, pc_subject, vmin=-3.14, vmax=3.14, cmap='hsv')
#images['size'] = cortex.Vertex(size, pc_subject, vmin=0, vmax=10)
# VEIN MASK
layout = BIDSLayout(op.join(derivatives, 'veins_mask'), validate=False)
veins = layout.get(subject=subject,
session=session,
suffix='veins',
return_type='file')
if len(veins) == 1:
veins = veins[0]
t1w = cortex.db.get_anat(pc_subject, 'raw')
veins = image.resample_to_img(veins, t1w)
veins = veins.get_data().T
veins[veins == 0] = np.nan
images['veins'] = cortex.Volume(veins,
subject=pc_subject,
xfmname='identity',
vmin=0,
vmax=2)
veins_surf_l = op.join(
derivatives, 'tsnr', f'sub-{subject}', f'ses-{session}', 'func',
f'sub-{subject}_ses-{session}_desc-depth.all_hemi-lh_invtsnr.gii')
veins_surf_r = op.join(
derivatives, 'tsnr', f'sub-{subject}', f'ses-{session}', 'func',
f'sub-{subject}_ses-{session}_desc-depth.all_hemi-rh_invtsnr.gii')
veins_d = np.hstack((surface.load_surf_data(veins_surf_l),
surface.load_surf_data(veins_surf_r)))
veins_d[np.isinf(veins_d)] = np.nan
images['veins_surf'] = cortex.Vertex(veins_d, pc_subject)
ds = cortex.Dataset(**images)
# cortex.webgl.make_static(outpath=op.join(derivatives, 'pycortex', subject),
# data=ds)
cortex.webgl.make_static(outpath=op.join(derivatives, 'pycortex',
f'{subject}.{session}', 'light'),
data={
'ODCs': images['zmap'],
'PRF polar angle': images['angle']
},
anonymize=False,
sampler='trilinear')
'data': data['retinal_gain_index'].T, # data to draw
'cmap': cmap_gain, # colormap to use
'alpha': alpha.T, # alpha map
'vmin': 0, # minimal value iqn colormap
'vmax': 1, # maximal value in colormap
'curv_brightness': 0.05, # curvature brightness
'curv_contrast': 0.1, # curvature contrast
'cbar': 'discrete'
} # color bar layout
vol_names.append('retinal_gain_index') # save volume name
# draw volumes, add to the overlay, create dataset
dataset_name = 'loo_dataset_{mask_dir}.hdf'.\
format(mask_dir = mask_dir) # define dataset name
dataset_webgl = cortex.Dataset() # pre-define dataset
for vol_name in vol_names:
roi_name = 'loo_{vol_name}_{mask_dir}'.\
format(vol_name = vol_name, mask_dir = mask_dir) # define roi name
if mask_dir == 'pos':
roi_param = {
'add_roi': True, # add roi to overlay.svg
'roi_name': roi_name
} # name of the roi
exec(
'param_{vol_name}.update(roi_param)'.format(vol_name=vol_name))
else:
roi_param = {
'add_roi': False, # add roi to overlay.svg
zmap = image.resample_img(zmap, zmap.affine, new_shape, fill_value=np.nan)
zmap.to_filename('/tmp/zmap.nii.gz')
transform = cortex.xfm.Transform(np.identity(4), zmap.get_filename())
transform.save(pc_subject, 'identity.zmap.extended')
mask = image.math_img('np.abs(zmap)', zmap=zmap)
mask = mask.get_data().T
zmap_vox = cortex.Volume2D(zmap.get_data().T,
mask,
pc_subject,
'identity.zmap.extended',
vmin=-3.5,
vmax=3.5,
vmin2=0,
vmax2=3,
cmap='BuBkRd_alpha_2D')
cds_vox = cortex.Volume(coordinates, pc_subject, 'identity.zmap.extended')
curvature_v = cortex.db.get_surfinfo(pc_subject)
random_data = np.random.rand(*curvature_v.data.shape)
random_data_v = cortex.Vertex(random_data, pc_subject)
ds = cortex.Dataset(zmap=zmap_vox,
voxels=cds_vox,
curvature=curvature_v,
random_data=random_data_v)
cortex.webshow(ds)
transform = cortex.xfm.Transform(np.identity(4), ref_file)
transform.save(subject, xfm_name, 'magnet')
# Add masks to pycortex transform
# -------------------------------
print('create pycortex transform')
xfm_masks = analysis_info['xfm_masks']
ref = nb.load(ref_file)
for xfm_mask in xfm_masks:
mask = cortex.get_cortical_mask(subject=subject,
xfmname=xfm_name,
type=xfm_mask)
mask_img = nb.Nifti1Image(dataobj=mask.transpose((2, 1, 0)),
affine=ref.affine,
header=ref.header)
mask_file = "{cortex_dir}/transforms/{xfm_name}/mask_{xfm_mask}.nii.gz".format(
cortex_dir=cortex_dir, xfm_name=xfm_name, xfm_mask=xfm_mask)
mask_img.to_filename(mask_file)
# Create participant pycortex overlays
# ------------------------------------
print('create subject pycortex overlays to check')
voxel_vol = cortex.Volume(np.random.randn(mask.shape[0], mask.shape[1],
mask.shape[2]),
subject=subject,
xfmname=xfm_name)
ds = cortex.Dataset(rand=voxel_vol)
cortex.webgl.make_static(outpath=temp_dir, data=ds)
def main(subject,
session,
sourcedata,
standard_space=False,
thr=thr,
smoothed=False):
left, right = cortex.db.get_surf(f'sub-{subject}', 'fiducial', merge=False)
left, right = cortex.Surface(*left), cortex.Surface(*right)
d = {}
if standard_space:
space = 'fsaverage'
d['wang15_ips'] = get_wang15_ips('fsaverage', sourcedata)
else:
space = 'fsnative'
d['wang15_ips'] = get_wang15_ips(subject, sourcedata)
concatenated = False
for session in ['3t1', '7t1', '3t2', '7t2']:
# for desc, split_certainty in zip(['', '.certain', '.uncertain'], [False, True, True]):
for desc, split_certainty in zip([''], [False]):
ext = ''
# if pca_confounds:
# ext += '.pca_confounds'
if smoothed:
ext += '.smoothed'
print(desc)
r2 = _load_parameters(subject,
session,
'r2.optim' + desc,
space,
smoothed,
split_certainty=split_certainty,
concatenated=concatenated,
pca_confounds=False)
if r2 is not None:
alpha = np.clip(r2.data - thr, 0., .1) / .1
d[f'r2.{session}{ext}{desc}'] = get_alpha_vertex(
r2.data,
alpha,
cmap='hot',
subject=subject,
vmin=0.0,
vmax=.5,
standard_space=standard_space)
mu = _load_parameters(subject,
session,
'mu.optim' + desc,
space,
smoothed,
split_certainty=split_certainty,
concatenated=concatenated)
d[f'mu.{session}{ext}{desc}'] = get_alpha_vertex(
mu.data,
alpha,
cmap='nipy_spectral',
subject=subject,
vmin=np.log(5),
vmax=np.log(28),
standard_space=standard_space)
ds = cortex.Dataset(**d)
cortex.webshow(ds)
x = np.linspace(0, 1, 101, True)
y = np.linspace(np.log(5), np.log(vmax), len(x), True)
plt.imshow(plt.cm.nipy_spectral(x)[np.newaxis, ...],
extent=[np.log(5),
np.log(vmax),
np.log(5),
np.log(vmax)],
aspect=1. / 10.,
origin='lower')
ns = np.array([5, 7, 10, 14, 20, 28, 40, 56, 80])
ns = ns[ns <= vmax]
plt.xticks(np.log(ns), ns)
# plt.xlim(np.olg(5, np.log(vmax))
plt.show()
def main(sourcedata, derivatives, subject='tk', dataset='odc'):
pc_subject = '{}.{}'.format(dataset, subject)
template = '{derivatives}/modelfitting/glm7/sub-{subject}/ses-{session}/func/sub-{subject}_ses-{session}_left_over_right_zmap.nii.gz'
session = 'odc2'
zmap1 = template.format(**locals())
session = 'odc3'
zmap2 = template.format(**locals())
session = 'cas'
zmap3 = template.format(**locals())
t1w = get_bids_file(derivatives, 'averaged_mp2rages', 'anat', subject,
'T1w', 'anat', 'average')
zmap1 = image.resample_to_img(zmap1, t1w, interpolation='nearest')
zmap2 = image.resample_to_img(zmap2, t1w, interpolation='nearest')
zmap3 = image.resample_to_img(zmap3, t1w, interpolation='nearest')
transform = cortex.xfm.Transform(np.identity(4), t1w)
#transform.save(pc_subject, 'identity.t1w', 'magnet')
mask1 = image.math_img('np.abs(zmap)', zmap=zmap1).get_data().T
mask2 = image.math_img('np.abs(zmap)', zmap=zmap2).get_data().T
mask3 = image.math_img('np.abs(zmap) > 2', zmap=zmap3).get_data().T
print(mask3.sum())
mask3 = ndimage.binary_closing(mask3, iterations=2)
print(mask3.sum())
prf_pars = np.load(
op.join(derivatives,
'prf/vertices/sub-{subject}_desc-test2_prf_optim.npz').format(
**locals()))
r2 = prf_pars['r2']
mask = r2 < 0.1
angle = prf_pars['angle']
#angle[mask] = np.nan
ecc = prf_pars['ecc']
ecc[mask] = np.nan
size = prf_pars['size']
size[mask] = np.nan
r2_max = np.max(r2)
r2_max = 0.3
r2_min = 0.15
hsv_angle = np.ones((len(r2), 3))
hsv_angle[:, 0] = angle
hsv_angle[:, 1] = np.clip(r2 / r2_max * 2, 0, 1)
hsv_angle[:, 2] = r2 > r2_min
left_index = cortex.db.get_surfinfo(pc_subject).left.shape[0]
angle_ = hsv_angle[:left_index, 0]
hsv_angle[:left_index, 0] = np.clip(
((angle_ + np.pi) - 0.25 * np.pi) / (1.5 * np.pi), 0, 1)
angle_ = -hsv_angle[left_index:, 0].copy()
angle_[hsv_angle[left_index:, 0] > 0] += 2 * np.pi
angle_ = np.clip((angle_ - 0.25 * np.pi) / 1.5 / np.pi, 0, 1)
hsv_angle[left_index:, 0] = angle_
rgb_angle = colors.hsv_to_rgb(hsv_angle)
#alpha_angle = np.clip(r2 / r2_max * 2, r2_min/r2_max, 1)
#alpha_angle[alpha_angle < r2_min/r2_max] = 0
alpha_angle = hsv_angle[:, 2]
images = {}
zmap1 = zmap1.get_data().T
zmap1[zmap1 == 0] = np.nan
zmap2 = zmap2.get_data().T
zmap2[zmap2 == 0] = np.nan
zmap3 = zmap3.get_data().T
zmap3[zmap3 == 0] = np.nan
images['PRF polar angle'] = cortex.VertexRGB(rgb_angle[:, 0],
rgb_angle[:, 1],
rgb_angle[:, 2],
alpha=alpha_angle,
subject=pc_subject)
#images['zmap_ses-odc2'] = cortex.Volume2D(zmap1,
#mask,
#pc_subject,
#'identity.t1w', vmin=-3, vmax=3, vmin2=0, vmax2=3,
#cmap='BuBkRd_alpha_2D')
#images['zmap_ses-odc3'] = cortex.Volume2D(zmap2,
#mask,
#pc_subject,
#'identity.t1w', vmin=-3, vmax=3, vmin2=0, vmax2=3,
#cmap='BuBkRd_alpha_2D')
images['ODCs Amsterdam 1'] = cortex.Volume2D(zmap1,
mask3,
pc_subject,
'identity.t1w',
vmin=-3,
vmax=3,
vmin2=0,
vmax2=3,
cmap='BuBkRd_alpha_2D')
images['ODCs Amsterdam 2'] = cortex.Volume2D(zmap2,
mask3,
pc_subject,
'identity.t1w',
vmin=-3,
vmax=3,
vmin2=0,
vmax2=3,
cmap='BuBkRd_alpha_2D')
images['ODCs Beijing'] = cortex.Volume2D(zmap3,
mask3,
pc_subject,
'identity.t1w',
vmin=-3,
vmax=3,
vmin2=0,
vmax2=3,
cmap='BuBkRd_alpha_2D')
ds = cortex.Dataset(**images)
cortex.webgl.make_static(outpath=op.join(derivatives, 'pycortex', subject),
data=ds)
cortex.webshow(ds)
vmin2=settings['rsq_threshold'],
vmax2=1.0,
cmap='RdBu_r_alpha')
vrsq = cortex.Volume2D(rsq.T,
rsq.T,
'sub-{subject}'.format(subject=subject),
'fmriprep_T1',
vmin=0,
vmax=0.8,
vmin2=settings['rsq_threshold'],
vmax2=1.0,
cmap='fire_alpha')
ds = cortex.Dataset(polar=vrgba,
ecc=vecc,
size=vsize,
amplitude=vbeta,
baseline=vbaseline,
rsq=vrsq)
ds.save(
os.path.join(base_dir, 'derivatives', 'out', 'pp',
'sub-{subject}'.format(subject=subject),
'ses-{ses}'.format(ses=settings['session']),
'pycortex_ds.h5'))
if args.webgl_pRFs == 1:
outpath = os.path.join(base_dir, 'derivatives', 'out', 'pp',
'sub-{subject}'.format(subject=subject),
'ses-{ses}'.format(ses=settings['session']),
'webgl')
print("making static pycortex webgl instance in {outpath}".format(
outpath=outpath))
def main(derivatives, subject, session):
pc_subject = 'odc.{}'.format(subject)
left, right = cortex.db.get_surf('odc.{}'.format(subject), 'fiducial')
left_surface = cortex.polyutils.Surface(left[0], left[1])
right_surface = cortex.polyutils.Surface(right[0], right[1])
max_wavelengths = {}
max_orientations = {}
zmaps = {}
for hemi, surf in zip(['lh', 'rh'], [left_surface, right_surface]):
energies = op.join(
derivatives, 'zmap_spatfreq', 'sub-{subject}', 'ses-{session}',
'func',
'sub-{subject}_ses-{session}_hemi-{hemi}_energies.pkl').format(
subject=subject, session=session, hemi=hemi)
xy = pd.read_pickle(
op.join(derivatives, 'coordinate_patches', 'sub-{subject}', 'anat',
'sub-{subject}_hemi-{hemi}_coordinatepatch.pkl').format(
**locals()))
energies = pd.read_pickle(energies)
energies = energies.loc[:, ~energies.isnull().any(0)]
max_frequency = energies.groupby(['depth', 'frequency']).sum().groupby(
'depth', as_index=True).apply(
lambda d: d.reset_index('depth', drop=True).idxmax())
max_wavelengths[hemi] = 1. / max_frequency
max_orientations[hemi] = []
zmaps[hemi] = []
for depth, d in energies.groupby('depth'):
tmp = d.loc[(depth, max_frequency.loc[depth]), :].idxmax()
tmp = tmp.apply(lambda x: x[2] if not x is np.nan else None)
tmp = pd.DataFrame(tmp, columns=pd.Index([depth], name='depth')).T
tmp.columns = energies.columns
max_orientations[hemi].append(tmp)
zmap = op.join(derivatives, 'sampled_giis', 'sub-{subject}', 'ses-{session}',
'func', 'sub-{subject}_ses-{session}_left_over_right_desc-zmap-depth-{depth}_hemi-{hemi}.gii'). \
format(**locals())
zmaps[hemi].append(surface.load_surf_data(zmap))
zmaps[hemi] = np.array(zmaps[hemi])
max_orientations[hemi] = pd.concat(max_orientations[hemi])
ss = pd.DataFrame([], columns=np.arange(surf.pts.shape[0]))
max_wavelengths[hemi] = pd.concat((ss, max_wavelengths[hemi])).values
max_orientations[hemi] = pd.concat((ss, max_orientations[hemi])).values
print(max_wavelengths['lh'].shape, max_wavelengths['rh'].shape)
max_wavelengths = np.concatenate(
[max_wavelengths['lh'], max_wavelengths['rh']], axis=-1)
max_orientations = np.concatenate(
[max_orientations['lh'], max_orientations['rh']], axis=-1)
print(zmaps['lh'].shape, zmaps['rh'].shape)
zmaps = np.concatenate([zmaps['lh'], zmaps['rh']], axis=-1)
images = {}
images['wavelength'] = cortex.Vertex(max_wavelengths,
'odc.{}'.format(subject),
vmin=0,
vmax=10)
images['orientation'] = cortex.Vertex(max_orientations,
'odc.{}'.format(subject),
vmin=0,
vmax=np.pi,
cmap='hsv')
images['zmap'] = cortex.Vertex(zmaps,
'odc.{}'.format(subject),
vmin=-3,
vmax=3)
layout = BIDSLayout(op.join(derivatives, 'tsnr'), validate=False)
veins = layout.get(subject=subject,
session=session,
suffix='invtsnr',
extension='nii.gz',
return_type='file')
veins = image.mean_img(veins)
t1w = cortex.db.get_anat(pc_subject, 'raw')
veins = image.resample_to_img(veins, t1w)
images['veins'] = cortex.Volume(veins.get_data().T,
subject=pc_subject,
xfmname='identity',
vmin=0,
vmax=2)
zmap = '{derivatives}/modelfitting/glm7/sub-{subject}/ses-{session}/func/sub-{subject}_ses-{session}_left_over_right_zmap.nii.gz'.format(
**locals())
t1w = get_bids_file(derivatives, 'averaged_mp2rages', 'anat', subject,
'T1w', 'anat', 'average')
zmap = image.resample_to_img(zmap, t1w)
transform = cortex.xfm.Transform(np.identity(4), t1w)
if not np.in1d(subject, ['01', '06']):
transform.save(pc_subject, 'identity.t1w', 'magnet')
mask = image.math_img('np.abs(zmap)', zmap=zmap)
zmap = zmap.get_data().T
zmap[zmap == 0] = np.nan
mask = mask.get_data().T
images['zmap'] = cortex.Volume2D(zmap,
mask,
pc_subject,
'identity.t1w',
vmin=-3,
vmax=3,
vmin2=0,
vmax2=3,
cmap='BuBkRd_alpha_2D')
ds = cortex.Dataset(**images)
cortex.webshow(ds)
freq_log10 = np.log10(freq)
#freq[freq <1] = np.nan
#freq[freq > 60] = np.nan
#freq[r2 < .1] = np.nan
images = {}
images['frequency'] = cortex.Volume(freq,
pc_subject,
'identity.t1w.v2',
vmin=0.1,
vmax=60)
images['r2'] = cortex.Volume(r2,
pc_subject,
'identity.t1w.v2',
vmin=0,
vmax=0.7)
images['log_freq'] = cortex.Volume(log_freq.get_data().T,
pc_subject,
'identity.t1w.v2',
vmin=-1,
vmax=5)
images['log10'] = cortex.Volume(freq_log10, pc_subject, 'identity.t1w.v2')
images['amplitude'] = cortex.Volume(amplitude.get_data().T, pc_subject,
'identity.t1w.v2')
images['log_sd'] = cortex.Volume(log_sd.get_data().T, pc_subject,
'identity.t1w.v2')
ds = cortex.Dataset(**images)
cortex.webshow(images)
'sub-' + sub_num,
'fmriprep_T1',
vmin=0,
vmax=1,
vmin2=0,
vmax2=5,
cmap='BROYG_2D') #'my_autumn')
#convert into a `Dataset`
DS = cortex.Dataset(polar=vrgba,
ecc=vecc,
size=vsize,
amplitude=vbeta,
baseline=vbaseline,
rsq=vrsq,
mean_epi=mean_epi,
face=v_face,
upper_limb=v_upper,
lower_limb=v_lower,
RvsL_upper=rl_upper,
RvsL_lower=rl_lower,
comb_FUL=v_combined,
Lhand=v_Lfingers_combined,
Rhand=v_Rfingers_combined)
# save in prf params dir
#DS.save(os.path.join(output_dir, 'pycortex_ds.h5'))
# Creates a static webGL MRI viewer in your filesystem
cortex.webgl.make_static(web_path,
DS) #,template='SBref_sub-'+sub_num+'.html')
