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 read_manual(segments, subject, hemi, style="inflated"):
global obj
global surface
direc = subject + '-' + hemi
v = create(direc)
pts, polys = cortex.db.get_surf(subject, style, hemi)
surface = cortex.polyutils.Surface(pts, polys)
seams, walls = get_ends(direc, segments)
return seams, walls, pts
# visualize the cuts
for j in range(segments):
path = cortex.polyutils.Surface.geodesic_path(surface, seam[j],
seam[j + 1])
obj[path] = 3 + i
# visualize the walls
for j in range(segments):
path = cortex.polyutils.Surface.geodesic_path(surface, wall[j],
wall[j + 1])
obj[path] = 3 + i + len(seams)
cortex.webshow(v)
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(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 show(self,nii=None,**kwargs):
# get data from nii image
data = self._get_nii_data(nii_name=nii)
print(data)
# create pycortex volume structure
#####use vmin/vmax kwrags######
self.vol = cortex.Volume(data,self.pycx_id,self.xfm_name,
# with_curvature=True,
# curvature_contrast=0.65,
# curvature_brightness=0.16,
# curvature_threshold=True,
**kwargs)
# open in browser
self.view = cortex.webshow(self.vol,autoclose=False,
# with_curvature=True,
# curvature_contrast=0.65,
# curvature_brightness=0.16,
# curvature_threshold=True,
**kwargs)
# view = cortex.webs`how(vol, port=port, autoclose=False,
# template=html_template, title='instabrain')
self.view.animate([{'state':'surface.%s.specularity'%(self.subj.fsub),'idx':0,'value':0}])
if self.subj.fsub == 'fsaverage':
time.sleep(3)
self.view.animate([{'state':'mix','idx':.5,'value':.5}])
if nii is None or 'mask' in nii:
self.view.setVminmax(-1,1)
def __init__(self, subject, xfm_name, mask_type='thick', vmin=-1., vmax=1., **kwargs): super(PyCortexViewer, self).__init__() npts = cortex.db.get_mask(subject, xfm_name, mask_type).sum() data = np.zeros(npts) vol = cortex.Volume(data, subject, xfm_name) self.subject = subject self.xfm_name = xfm_name self.mask_type = mask_type self.ctx_client = cortex.webshow(vol) self.vmin = vmin self.vmax = vmax self.active = True
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)
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)
# for fn in glob.glob(r2s_cv_r)], 0, 1)
# r2s_cv = np.hstack((np.nanmean(r2s_cv_l, 0), np.nanmean(r2s_cv_r, 0)))
# r2s_cv_v = cortex.Vertex(r2s_cv, 'fsaverage')
# r2s_trialwise_l = op.join(derivatives, 'modelfit_trialwise_surf_smoothed',
from bids import BIDSLayout
from nilearn import image
derivatives = '/data/odc/derivatives'
subject = '06'
pc_subject = 'odc.{}'.format(subject)
session = 'odc'
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])
example_gabors = op.join(
derivatives, 'zmap_spatfreq', 'sub-{subject}', 'ses-{session}', 'func',
'sub-{subject}_ses-{session}_dynamicbw_example_gabors.pkl').format(
subject=subject, session=session)
example_gabors = pd.read_pickle(example_gabors)
mask = np.zeros(len(left_surface.pts))
mask[example_gabors.columns] = True
ss = left_surface.create_subsurface(mask.astype(bool))
example_gabors = ss.lift_subsurface_data(example_gabors.values)
v_example_gabors = cortex.Vertex(example_gabors,
pc_subject,
vmin=-0.1,
vmax=0.1,
cmap='BuBkRd')
cortex.webshow(v_example_gabors)
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 save_3d_views(
volume,
base_name="fig",
list_angles=["lateral_pivot"],
list_surfaces=["inflated"],
viewer_params=dict(labels_visible=[], overlays_visible=["rois"]),
interpolation="nearest",
layers=1,
size=(1024 * 4, 768 * 4),
trim=True,
sleep=10,
):
"""Saves 3D views of `volume` under multiple specifications.
Needs to be run on a system with a display (will launch webgl viewer).
The best way to get the expected results is to keep the webgl viewer
visible during the process.
Parameters
----------
volume: pycortex.Volume
Data to be displayed.
base_name: str
Base name for images.
list_angles: list of (str or dict)
Views to be used. Should be of length one, or of the same length as
`list_surfaces`. Choices are:
'left', 'right', 'front', 'back', 'top', 'bottom', 'flatmap',
'medial_pivot', 'lateral_pivot', 'bottom_pivot',
or a custom dictionary of parameters.
list_surfaces: list of (str or dict)
Surfaces to be used. Should be of length one, or of the same length as
`list_angles`. Choices are:
'inflated', 'flatmap', 'fiducial', 'inflated_cut',
or a custom dictionary of parameters.
viewer_params: dict
Parameters passed to the viewer.
interpolation: str
Interpolation used to visualize the data. Possible choices are "nearest",
"trilinear". (Default: "nearest").
layers: int
Number of layers between the white and pial surfaces to average prior to
plotting the data. (Default: 1).
size: tuple of int
Size of produced image (before trimming).
trim: bool
Whether to trim the white borders of the image.
sleep: float > 0
Time in seconds, to let the viewer open.
Returns
-------
file_names: list of str
Image paths.
"""
msg = "list_angles and list_surfaces should have the same length."
assert len(list_angles) == len(list_surfaces), msg
# Create viewer
handle = cortex.webshow(volume, **viewer_params)
# Wait for the viewer to be loaded
time.sleep(sleep)
# Add interpolation and layers params
interpolation_params = {
"surface.{subject}.sampler": interpolation,
"surface.{subject}.layers": layers
}
file_names = []
for view, surface in zip(list_angles, list_surfaces):
if isinstance(view, str):
if view == "flatmap" or surface == "flatmap":
# force flatmap correspondence
view = surface = "flatmap"
view_params = angle_view_params[view]
else:
view_params = view
if isinstance(surface, str):
surface_params = unfold_view_params[surface]
else:
surface_params = surface
# Combine view parameters
this_view_params = default_view_params.copy()
this_view_params.update(interpolation_params)
this_view_params.update(view_params)
this_view_params.update(surface_params)
print(this_view_params)
# apply params
handle._set_view(**this_view_params)
# wait for the view to have changed
for _ in range(100):
for k, v in this_view_params.items():
k = k.format(subject=volume.subject) if "{subject}" in k else k
if handle.ui.get(k)[0] != v:
print("waiting for", k, handle.ui.get(k)[0], "->", v)
time.sleep(0.1)
continue
break
time.sleep(0.1)
# Save image, store file_name
file_name = file_pattern.format(base=base_name,
view=view,
surface=surface)
file_names.append(file_name)
handle.getImage(file_name, size)
# Wait for browser to dump file, before applying new view parameters
while not os.path.exists(file_name):
pass
time.sleep(1)
# Trim white edges
if trim:
try:
import subprocess
subprocess.call(["convert", "-trim", file_name, file_name])
except Exception as e:
print(str(e))
pass
# Try to close the window
try:
handle.close()
handle.server.stop()
except Exception as e:
print(str(e))
print("Could not close viewer.")
return file_names
This demo shows how to plot example retinotopy data onto a subject's brain
in a web viewer. In order for this demo to work, you need to download this
dataset_, but that can also be done automatically through the `urllib`
command that is included.
.. _dataset: http://gallantlab.org/pycortex/S1_retinotopy.hdf
S1 is the example subject that comes with pycortex, but if you want to plot
data onto a different subject, you will need to have them in your filestore.
This demo will not actually open the web viewer for you, but if you run it
yourself you will get a viewer showing something like the following.
.. image:: ../../webgl/angle_left.png
"""
import cortex
try: # python 2
from urllib import urlretrieve
except ImportError: # python 3
from urllib.request import urlretrieve
# Download and load in retinotopy data
_ = urlretrieve("http://gallantlab.org/pycortex/S1_retinotopy.hdf",
"S1_retinotopy.hdf")
ret_data = cortex.load("S1_retinotopy.hdf")
# Open the webviewer
cortex.webshow(ret_data)
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))
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)
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',
freesurfer_subject_dir='/mnt/c/Users/ACH/Desktop',
).save(subject='MNI2009c',
name='tal', # places into subj/transforms/xfm_name
xfmtype='coord')
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(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', subject,
'light'),
data=images['zmap'])
cortex.webshow(ds, recache=cache)
in a web viewer. In order for this demo to work, you need to download this
dataset_, but that can also be done automatically through the `urllib`
command that is included.
.. _dataset: http://gallantlab.org/pycortex/S1_retinotopy.hdf
S1 is the example subject that comes with pycortex, but if you want to plot
data onto a different subject, you will need to have them in your filestore.
This demo will not actually open the web viewer for you, but if you run it
yourself you will get a viewer showing something like the following.
.. image:: ../../webgl/angle_left.png
"""
import cortex
try: # python 2
from urllib import urlretrieve
except ImportError: # python 3
from urllib.request import urlretrieve
# Download and load in retinotopy data
_ = urlretrieve("http://gallantlab.org/pycortex/S1_retinotopy.hdf",
"S1_retinotopy.hdf")
ret_data = cortex.load("S1_retinotopy.hdf")
# Open the webviewer
cortex.webshow(ret_data)
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)
def save_3d_views(
data,
root,
path_base,
size=(1024, 768),
trim=True,
view_names=["lateral", "front", "back", "top", "bottom", "medial"]):
"""Saves 3D views of `data` in and around `root`.
"""
# Create viewer
handle = cortex.webshow(data)
# Wait until it's up or something?
# (this is f*****g stupid
# there should be some way to see that it's open
# but I don't know what it is)
time.sleep(5.0)
# Set up params
basic = dict(projection=['orthographic'], radius=260)
views = dict(lateral=dict(altitude=90.5, azimuth=181, pivot=180),
medial=dict(altitude=90.5, azimuth=0, pivot=180),
front=dict(altitude=90.5, azimuth=0, pivot=0),
back=dict(altitude=90.5, azimuth=181, pivot=0),
top=dict(altitude=0, azimuth=180, pivot=0),
bottom=dict(altitude=180, azimuth=0, pivot=0))
views = dict([(s, views[s]) for s in view_names])
surfaces = dict(inflated=dict(mix=0.5), fiducial=dict(mix=0.0))
# Save views!
filenames = dict([(key, {}) for key in surfaces.keys()])
# filenames = []
for view, vparams in views.items():
for surf, sparams in surfaces.items():
# Combine basic, view, and surface parameters
params = _combine(_combine(basic, vparams), sparams)
# Set the view
handle._set_view(**_tolists(params))
# Save image, store filename
filename = file_pattern.format(base=path_base,
view=view,
surface=surf)
filenames[surf][view] = filename
# filenames.append(filename)
output_path = os.path.join(root, filename)
handle.saveIMG(output_path, size)
# Trim edges?
if trim:
# Wait for browser to dump file
while not os.path.exists(output_path):
pass
time.sleep(0.5)
try:
import subprocess
subprocess.call(
["convert", "-trim", output_path, output_path])
except:
pass
# Close the window!
try:
handle.close()
return filenames
except:
return filenames
mask_previous = []
for a in ['V1','V2','V3','V4','Vhigher1','Vhigher2']:
roi_mask = voxel_ROI_masks['lh'][a].copy();
if len(shape(mask_previous)) == 3:
print('here')
nonzeros = np.where(mask_previous > 0)
for x,y,z in zip(nonzeros[0],nonzeros[1],nonzeros[2]):
roi_mask[x,y,z] = 0
mask_previous = roi_mask
m += f * roi_mask
f += 0.5
display_slice(reference,surfaces,20,m,'multi-ROI')
cortex.webshow((pycortex_transpose(m),subject,transform_name))
ori = ori_data.copy()
ori[np.isnan(ori)]=0
cortex.webshow((pycortex_transpose(ori),subject,transform_name))
# Freesurfer commands to prepare flat surfaces:
"""
tksurfer S12015 lh smoothwm
save patch as: lh.S12015_flat.patch.3d
cd freesurfer/subjects/S12015/surf/
mris_flatten lh.S12015_flat.patch.3d lh.S12015_flat.flat.patch.3d
mris_convert -p lh.S12015_flat.flat.patch.3d flat_lh.gii
tksurfer S12015 rh smoothwm
[file:load curvature]
save patch as: rh.S12015_flat.patch.3d
