def test_int64_in_dataviewrgb():
data = np.arange(np.product(volshape)).reshape(volshape, order='C')
view = cortex.VolumeRGB(data,
data + 1,
data + 2,
subject=subj,
xfmname=xfmname)
cortex.quickshow(view)
data = np.arange(nverts)
view = cortex.VertexRGB(data, data + 1, data + 2, subject=subj)
cortex.quickshow(view)
def get_thr_map(par, r2, par_min=1.5, par_max=2.5, r2_thr=0.09):
par = (par - par_min) / (par_max - par_min)
red, green, blue = cm.jet(par)[:, :3].T
alpha = r2 > r2_thr
red[~alpha] = np.nan
green[~alpha] = np.nan
blue[~alpha] = np.nan
return cortex.VertexRGB(
red=red, green=green, blue=blue, subject='fsaverage', alpha=alpha.astype(float) * 0.7)
def get_alpha_vertex(data,
alpha,
cmap='nipy_spectral',
vmin=np.log(5),
vmax=np.log(80),
standard_space=False,
subject='fsaverage'):
data = np.clip((data - vmin) / (vmax - vmin), 0., .99)
red, green, blue = getattr(cm, cmap)(data, )[:, :3].T
if (subject == 'fsaverage') or standard_space:
fs_subject = 'fsaverage'
else:
fs_subject = f'sub-{subject}'
print(fs_subject)
# Get curvature
curv = cortex.db.get_surfinfo(fs_subject)
# Adjust curvature contrast / color. Alternately, you could work
# with curv.data, maybe threshold it, and apply a color map.
curv.data = np.sign(curv.data.data) * .25
curv.vmin = -1
curv.vmax = 1
curv.cmap = 'gray'
curv_rgb = np.vstack(
[curv.raw.red.data, curv.raw.green.data,
curv.raw.blue.data]).astype(np.float32)
vx_rgb = (np.vstack([red.data, green.data, blue.data]) * 255.).astype(
np.float32)
display_data = vx_rgb * alpha[np.newaxis, :] + curv_rgb * (
1. - alpha[np.newaxis, :])
return cortex.VertexRGB(*display_data.astype(np.uint8), fs_subject)
def test_vertex_rgb_movie():
r = g = b = np.random.randn(nverts)
rgb = cortex.VertexRGB(r, g, b, subj)
# hemisphere based on vertex number
test1 = np.hstack((np.arange(num_verts[0]), np.arange(num_verts[1])))
# Picking a different vertex in each hemisphere to create another fake
# gradient away from that vertex
second_verts = [n / 4 for n in num_verts]
test2 = np.hstack((np.abs(np.arange(num_verts[0]) - second_verts[0]),
np.abs(np.arange(num_verts[1]) - second_verts[1])))
# Creating a third dataset that is random stripes
third_verts = np.random.randint(num_verts[0] + num_verts[1], size=(20, ))
test3 = np.zeros(num_verts[0] + num_verts[1])
for v in third_verts:
test3[v - 1000:v + 1000] = 1
# Scaling the three datasets to be between 0-255
test1_scaled = test1 / np.max(test1) * 255
test2_scaled = test2 / np.max(test2) * 255
test3_scaled = test3 / np.max(test3) * 255
# Creating three cortex.Volume objects with the test data as np.uint8
red = cortex.Vertex(test1_scaled, subject)
green = cortex.Vertex(test2_scaled, subject)
blue = cortex.Vertex(test3_scaled, subject)
# This creates a 2D Vertex object with both of our test datasets for the
# given subject
vertex_data = cortex.VertexRGB(red, green, blue, subject)
cortex.quickshow(vertex_data, with_colorbar=False)
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)
for _, val in enumerate(masked_rsq)
]).T #why transpose? because of orientation of pycortex volume?
# create alpha array weighted by rsq values
alpha = np.sqrt(masked_rsq.copy()) #np.ones(alpha_mask.shape)
alpha[alpha_mask] = np.nan
# create alpha array with nan = transparent = values with rsq below thresh and 1 = opaque = values above thresh
alpha_ones = np.ones(alpha_mask.shape)
alpha_ones[alpha_mask] = np.nan
images = {}
images['polar'] = cortex.VertexRGB(rgb[..., 0].T,
rgb[..., 1].T,
rgb[..., 2].T,
subject='fsaverage_gross',
alpha=alpha)
#cortex.quickshow(images['polar'],with_curvature=True,with_sulci=True,with_colorbar=False)
filename = os.path.join(
figure_out,
'flatmap_space-fsaverage_rsq-%0.2f_type-polar_angle.svg' % rsq_threshold)
print('saving %s' % filename)
_ = cortex.quickflat.make_png(filename,
images['polar'],
recache=True,
with_colorbar=False,
with_curvature=True,
with_sulci=True)
images['polar_noalpha'] = cortex.VertexRGB(rgb[..., 0].T,
weighted_sd = cortex.Vertex(weighted_pars[:, 1], 'fsaverage')
weighted_amplitude = cortex.Vertex(
np.clip(weighted_pars[:, 2], 0, 100), 'fsaverage')
weighted_baseline = cortex.Vertex(weighted_pars[:, 3], 'fsaverage')
mu_min = 1.5
mu_max = 2.5
r2_thr = 0.09
mu_exp = np.exp(weighted_mu)
mu_exp = weighted_mu
mu_exp = (mu_exp - mu_min) / (mu_max - mu_min)
weighted_mu_hsv = np.zeros((3, len(weighted_mu)))
weighted_mu_hsv[0] = mu_exp
# weighted_mu_hsv[1] = r2s_mean_v.data / np.max(r2s_mean_v.data)
weighted_mu_hsv[1] = 1
weighted_mu_hsv[2] = 1.
alpha = r2s_mean_v.data > r2_thr
# red, green, blue = colors.hsv_to_rgb(weighted_mu_hsv.T).T# * 256
red, green, blue = cm.jet(mu_exp)[:, :3].T
red[~alpha] = np.nan
green[~alpha] = np.nan
blue[~alpha] = np.nan
weighted_mu_rgb_v = cortex.VertexRGB(
red=red, green=green, blue=blue, subject='fsaverage', alpha=alpha.astype(float) * 0.7)
cortex.utils.add_roi(weighted_mu_rgb_v, 'weighted_mu', open_inkscape=False)
cortex.utils.add_roi(r2s_mean_v, 'R2', open_inkscape=False)
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')
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)
B.set_bad(alpha=0)
data = {group:{phase:np.concatenate((np.array(image.get_data(f'ers_comps/surf/lh_{group}_{phase}.mgh').ravel()),np.array(image.get_data(f'ers_comps/surf/rh_{group}_{phase}.mgh').ravel()))) for phase in ['acquisition','extinction']} for group in ['healthy','ptsd']}
data['healthy']['acquisition'] = R(acq_norm(data['healthy']['acquisition']))
data['healthy']['extinction'] = B(ext_norm(data['healthy']['extinction']))
data['ptsd']['acquisition'] = R(acq_norm(data['ptsd']['acquisition']))
data['ptsd']['extinction'] = B(ext_norm(data['ptsd']['extinction']))
verts = []
for group in ['healthy','ptsd']:
for phase in ['acquisition','extinction']:
verts.append(cortex.VertexRGB(data[group][phase][:,0],data[group][phase][:,1],data[group][phase][:,2],subject='MNI2009c',alpha=data[group][phase][:,3],description=f'{group}_{phase}') )
verts = {str(i):verts[i] for i in range(4)}
cortex.webshow(verts)
cortex.freesurfer.import_subj('MNI2009c',freesurfer_subject_dir='/mnt/c/Users/ACH/Desktop',)
cortex.xfm.Transform.from_freesurfer('/mnt/c/Users/ACH/Desktop/MNI2009c/mri/transforms/talairach.xfm',
'/mnt/c/Users/ACH/Desktop/standard/MNI152NLin2009cAsym_T1_1mm_brain.nii.gz',
'MNI2009c',
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))
rgb = colors.hsv_to_rgb(hsv)
# define alpha channel - which specifies the opacity for a color
# 0 = transparent = values with rsq below thresh and 1 = opaque = values above thresh
alpha_mask = (rsq <= rsq_threshold
).T #why transpose? because of orientation of pycortex volume?
alpha = np.ones(alpha_mask.shape)
alpha[alpha_mask] = 0
# define Vertex images
#contains RGBA colors for each voxel in a volumetric dataset
# vertex for polar angles
images['polar'] = cortex.VertexRGB(rgb[..., 0].T,
rgb[..., 1].T,
rgb[..., 2].T,
subject='fsaverage',
alpha=alpha)
# vertex for ecc
images['ecc'] = cortex.Vertex2D(eccentricity.T,
alpha * 10,
'fsaverage',
vmin=0,
vmax=10,
vmin2=0,
vmax2=1.0,
cmap='BROYG_2D')
#images['ecc'] = cortex.Vertex2D(eccentricity.T, rsq.T, 'fsaverage',
# vmin=0, vmax=10,
# vmin2=rsq_threshold, vmax2=1.0, cmap='BROYG_2D')
