def roi_mask_v2(self, roimask, contrast_data):
filename = tempfile.mktemp(suffix='.png',
dir=self.tmp_image_dir,
prefix='roi_masks-')
mask = cortex.db.get_mask('MNI', 'atlas')
# a = b
roimask = roimask * 1.0
roimask[mask == False] = np.nan
roivol = cortex.Volume(roimask, 'MNI', 'atlas', mask=mask)
# Create flatmap
fig = cortex.quickflat.make_figure(cortex.Volume(contrast_data,
'MNI',
'atlas',
vmin=0,
vmax=1,
cmap='Blues'),
with_colorbar=False,
with_curvature=True,
bgcolor=None)
# Add rois
#if not contrast_data.isPmap:
# add_hash_layer(fig, roivol, [255,255,255], [0,8,12])
add_hash_layer(fig, roivol, [10, 0, 0], [3, 8, 8])
dpi = 100
imsize = fig.get_axes()[0].get_images()[0].get_size()
fig.set_size_inches(np.array(imsize)[::-1] / float(dpi))
fig.savefig(filename, transparent=True, dpi=dpi)
fig.clf()
pltclose(fig)
return filename
def save_cca_volweights(fmri_weights, mask_file, out_dir, prefix_name,
out_png=True, two_side=False):
"""Save fmri weights derived from CCA as nifti files."""
n_components = fmri_weights.shape[1]
mask = data_swap(mask_file)
vxl_idx = np.nonzero(mask.flatten()==1)[0]
for i in range(n_components):
tmp = np.zeros_like(mask.flatten(), dtype=np.float64)
tmp[vxl_idx] = fmri_weights[:, i]
tmp = tmp.reshape(mask.shape)
nii_file = os.path.join(out_dir, prefix_name+'%s.nii.gz'%(i+1))
save2nifti(tmp, nii_file)
if out_png:
import cortex
from matplotlib import cm
subj_id = out_dir.split('/')[-3]
if two_side:
img = cortex.quickflat.make_figure(cortex.Volume(nii_file,
subj_id, 'func2anat', cmap=cm.bwr,
vmin=-1., vmax=1.),
with_curvature=True)
else:
img = cortex.quickflat.make_figure(cortex.Volume(nii_file,
subj_id, 'func2anat', cmap=cm.hot,
vmin=0., vmax=1.),
with_curvature=True)
png_file = os.path.join(out_dir, prefix_name+'%s.png'%(i+1))
img.savefig(png_file, dpi=200)
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 __init__(self,
data,
permuted_data,
name,
transform,
func_to_mni,
vmin,
vmax,
cmap='RdBu_r'):
cortex.Volume.__init__(self,
data,
name,
transform,
vmin=vmin,
vmax=vmax,
cmap=cmap)
self.permuted_contrast_pval = None
self.threshold_05 = None
self.threshold_01 = None
self.threshold_05_mni = None
self.threshold_01_mni = None
if permuted_data is not None:
# permuted contrast pycortex value
self.permuted_contrast_pval = permuted_data
# threshold 05
threshold_05 = permuted_data
threshold_05[threshold_05 > 0] = FDR(
threshold_05[threshold_05 > 0], 0.05, do_correction=False)[0]
self.threshold_05 = cortex.Volume(threshold_05,
name,
transform,
vmin=-0.5,
vmax=0.5)
# threshold 05 mni
self.threshold_05_mni = transform_to_mni(self.threshold_05,
func_to_mni).get_data().T
# threshold 01
threshold_01 = permuted_data
threshold_01[threshold_01 > 0] = FDR(
threshold_01[threshold_01 > 0], 0.01, do_correction=False)[0]
self.threshold_01 = cortex.Volume(threshold_01,
name,
transform,
vmin=-0.5,
vmax=0.5)
# threshold 01 mni
self.threshold_01_mni = transform_to_mni(self.threshold_01,
func_to_mni).get_data().T
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 debug_roi_mask(self, roimask, contrast_data):
# Create random filename
# filename = tempfile.mktemp(suffix='.png', dir=self.path, prefix='flatmap-')
prefix = 'group'
if contrast_data.isPmap:
print('This is a Pmap!')
filename = '{0}_{1}_{2}_flatPmap.png'.format(
prefix, contrast_data.contrast.experiment.name,
contrast_data.contrast.contrast_name)
else:
print('This is a not a Pmap!')
filename = '{0}_{1}_{2}_flatmap.png'.format(
prefix, contrast_data.contrast.experiment.name,
contrast_data.contrast.contrast_name)
filename = os.path.join(self.path, filename)
print filename
# mask = cortex.db.get_mask('MNI', 'atlas')
roivol = cortex.Volume(roimask, 'MNI', 'atlas')
# roivol[mask==False] = np.nan
# Save flatmap
cortex.quickflat.make_png(os.path.join(self.output_root, filename),
contrast_data,
with_colorbar=False,
with_curvature=True,
extra_hatch=(roivol, [255, 255, 255]),
bgcolor='black')
# Create HTML pointing to flatmap
html = "<img src='{filename}'/>".format(filename=filename)
return html
def __init__(self, name, transform, path):
# basic attributes
self.name = name
self.transform = transform
self.func_to_mni = cortex.db.get_mnixfm(name, transform)
# attributes from file
with tables.open_file(path) as tf:
# voxels_predicted
self.pred_score = tf.root.corr.read()
threshold = 0.05
self.voxels_predicted = self.pred_score > threshold
# weights
self.weights = tf.root.udwt.read()
self.weights[:, self.voxels_predicted is False] = 0
#predicted_mask_mni
tmp = cortex.Volume(self.voxels_predicted.astype("float"), name,
transform)
self.predicted_mask_mni = cortex.mni.transform_to_mni(
tmp, self.func_to_mni).get_data().T
self.predicted_mask_mni = (self.predicted_mask_mni > 0) * 1.0
def permuted_contrast_pval(self):
if not hasattr(self, "_permuted_contrast"):
p_contrast_vecs = np.dot(self.contrast.permuted_vectors,
self.ref_to_subject.weights)
contrast_vect = np.dot(self.contrast.vector,
self.ref_to_subject.weights)
if self.contrast.double_sided:
counts = (contrast_vect <= p_contrast_vecs).mean(0)
counts[counts ==
0] = 1.0 / p_contrast_vecs.shape[0] # can't have pval=0
counts[self.ref_to_subject.voxels_predicted ==
False] = 0 # these are areas with no predictions
p_map = counts # -np.log10(counts)
else:
#stds = p_contrast_vecs.std(0)
#p_map = np.norm.cdf(np.zeros(contrast_vect.shape),loc = contrast_vect, scale=stds)
#p_map = -np.log10(p_map)
counts = (np.zeros_like(contrast_vect) >=
p_contrast_vecs).mean(0)
counts[counts ==
0] = 1.0 / p_contrast_vecs.shape[0] # can't have pval=0
counts[self.ref_to_subject.voxels_predicted ==
False] = 0 # these are areas with no predictions
p_map = counts #-np.log10(counts)
self._permuted_contrast_pval = cortex.Volume(
p_map,
self.ref_to_subject.pycortex_surface,
self.ref_to_subject.pycortex_transform,
vmin=0,
vmax=1)
return self._permuted_contrast_pval
def predicted_mask_mni(self):
if not hasattr(self, "_predicted_mask_mni"):
tmp = cortex.Volume(self.voxels_predicted.astype("float"),
self.pycortex_surface, self.pycortex_transform)
self._predicted_mask_mni = cortex.mni.transform_to_mni(
tmp, self.func_to_mni, use_flirt=use_flirt).get_data().T
self._predicted_mask_mni = (self._predicted_mask_mni > 0) * 1.0
return self._predicted_mask_mni
def test_volumedata_copy_with_custom_mask():
mask = cortex.get_cortical_mask(subj, xfmname, "thick")
mask[16] = True
nmask = mask.sum()
data = np.random.randn(nmask)
v = cortex.Volume(data, subj, xfmname, mask=mask)
vc = v.copy(v.data)
assert np.allclose(v.data, vc.data)
def __call__(self, contrast_data):
# Create random filename
# filename = tempfile.mktemp(suffix='.png', dir=self.path, prefix='flatmap-')
if hasattr(contrast_data, 'ref_to_subject'):
prefix = contrast_data.ref_to_subject.name
else:
prefix = 'group'
if np.sum(contrast_data.data < 0) == 0:
prefix += '_pmap'
# tmp_volume = cortex.Volume(contrast_data.data, contrast_data.subject,
# contrast_data.xfmname,
# vmin = contrast_data.vmin,
# vmax = contrast_data.vmax,
# cmap = contrast_data.vmax,
# ** self.quickflat_args)
tmp_volume = contrast_data
# tmp_volume.data[contrast_data.ref_to_subject._voxels_predicted==False] = np.nan
else:
tmp_volume = cortex.Volume(contrast_data.data,
contrast_data.subject,
contrast_data.xfmname,
**self.quickflat_args)
# tmp_volume.data[contrast_data.ref_to_subject._voxels_predicted==False] = np.nan
tmp_volume.data[tmp_volume.data == 0] = np.nan
filename = '{0}_{1}_{2}_simpleFlatmap.png'.format(
prefix, contrast_data.contrast.experiment.name,
contrast_data.contrast.contrast_name)
filename = os.path.join(self.path, filename)
print filename
# Save flatmap
try:
cortex.quickflat.make_png(os.path.join(self.output_root, filename),
tmp_volume,
with_colorbar=False,
with_curvature=True,
cvmin=-2,
cvmax=2,
**self.quickflat_args)
except:
cortex.quickflat.make_png(os.path.join(self.output_root, filename),
tmp_volume,
with_colorbar=False,
with_curvature=True,
cvmin=-2,
cvmax=2,
recache=True,
**self.quickflat_args)
# Create HTML pointing to flatmap
html = "<img src='{filename}'/>".format(d=contrast_data,
filename=filename)
return self.make_output(Result(html, contrast_data))
def roi_mask_v2(self, roimask, contrast_data):
# Create random filename
prefix = 'group'
if contrast_data.isPmap:
print('This is a Pmap!')
filename = '{0}_{1}_{2}_flatPmap.png'.format(
prefix, contrast_data.contrast.experiment.name,
contrast_data.contrast.contrast_name)
else:
print('This is a not a Pmap!')
filename = '{0}_{1}_{2}_flatmap.png'.format(
prefix, contrast_data.contrast.experiment.name,
contrast_data.contrast.contrast_name)
filename = os.path.join(self.path, filename)
print filename
mask = cortex.db.get_mask('MNI', 'atlas')
# a = b
roimask = roimask * 1.0
roimask[mask == False] = np.nan
roivol = cortex.Volume(roimask, 'MNI', 'atlas', mask=mask)
# print np.sum(np.isnan(roivol.data))
# Create flatmap
#'YlGn'
fig = cortex.quickflat.make_figure(contrast_data,
with_colorbar=False,
with_curvature=True,
bgcolor='black')
# Add rois
if not contrast_data.isPmap:
add_hash_layer(fig, roivol, [255, 255, 255], [0, 8, 12])
add_hash_layer(fig, roivol, [10, 0, 0], [3, 8, 8])
# add_hash_layer(fig, roivol, [10,10,0], [2,6,2])
#add_hash_layer(fig, roivol, [0,50,0], [0,6,4])
#add_hash_layer(fig, roivol, [10,10,0], [2,6,2])
#add_hash_layer(fig, roivol, [255,255,255], [4,6,2])
# Save flatmap
dpi = 100
imsize = fig.get_axes()[0].get_images()[0].get_size()
fig.set_size_inches(np.array(imsize)[::-1] / float(dpi))
# if bgcolor is None:
fig.savefig(filename, transparent=True, dpi=dpi)
# else:
# fig.savefig(filename, facecolor=filename, transparent=False, dpi=dpi)
fig.clf()
pltclose(fig)
# Create HTML pointing to flatmap
html = "<img src='{filename}'/>".format(filename=filename)
return html
def update_show(self,nii):
data = os.path.join(data_dir,nii)
vol = cortex.Volume(data,self.pycx_id,self.xfm_name)
mos, _ = cortex.mosaic(vol.data)
# mos, _ = cortex.mosaic(vol.volume[0],show=False)
self.view.dataviews.data.data[0]._setData(0,mos)
# self.view.dataviews.data.data[0]._setData(1,mos)
# if init:
# self.view.setVminmax(np.percentile(data,75),np.percentile(data,99))
self.view.setFrame(1)
def thresholded_contrast_01(self):
if not hasattr(self, "_thresholded_contrast_01"):
thresholded_contrast_01 = self.permuted_contrast_pval.data
thresholded_contrast_01[thresholded_contrast_01 > 0] = FDR(
thresholded_contrast_01[thresholded_contrast_01 > 0],
0.01,
do_correction=False)[0]
self._thresholded_contrast_01 = cortex.Volume(
thresholded_contrast_01,
self.ref_to_subject.pycortex_surface,
self.ref_to_subject.pycortex_transform,
vmin=-0.5,
vmax=0.5)
return self._thresholded_contrast_01
def generate_pycortex_volume(image):
nifti_file = str(image.file.path)
transform_name = "trans_%s" % image.pk
temp_dir = tempfile.mkdtemp(dir=settings.PYCORTEX_DATASTORE)
try:
new_mni_dat = os.path.join(temp_dir, "mni152reg.dat")
mni_mat = os.path.join(temp_dir, "mni152reg.mat")
reference = os.path.join(os.environ['FREESURFER_HOME'], 'subjects',
'fsaverage', 'mri', 'brain.nii.gz')
shutil.copy(
os.path.join(os.environ['FREESURFER_HOME'], 'average',
'mni152.register.dat'), new_mni_dat)
#this avoids problems with white spaces in file names
tmp_link = os.path.join(temp_dir, "tmp.nii.gz")
os.symlink(nifti_file, tmp_link)
try:
subprocess.check_output([
os.path.join(os.environ['FREESURFER_HOME'], "bin",
"tkregister2"), "--mov", tmp_link, "--targ",
reference, "--reg", new_mni_dat, "--noedit", "--nofix",
"--fslregout", mni_mat
])
except CalledProcessError, e:
raise RuntimeError(
str(e.cmd) + " returned code " + str(e.returncode) +
" with output " + e.output)
x = np.loadtxt(mni_mat)
xfm = cortex.xfm.Transform.from_fsl(x, nifti_file, reference)
xfm.save("fsaverage", transform_name, 'coord')
dv = cortex.Volume(nifti_file,
"fsaverage",
transform_name,
cmap="RdBu_r",
dfilter="trilinear",
description=image.description)
# default colormap range evaluated only at runtime (Dataview.to_json())
# excludes max/min 1% : np.percentile(np.nan_to_num(self.data), 99)
use_vmax = dv.to_json()['vmax'][0]
dv.vmin = use_vmax * -1
dv.vmax = use_vmax
return dv
def debug_roi_mask(self, roimask, contrast_data):
# Create random filename
filename = tempfile.mktemp(suffix='.png',
dir=self.path,
prefix='flatmap-')
roivol = cortex.Volume(roimask, 'MNI', 'atlas')
# Save flatmap
f = cortex.quickflat.make_png(os.path.join(self.output_root, filename),
contrast_data,
with_colorbar=False,
with_curvature=True,
extra_hatch=(roivol, [0, 250, 250]),
bgcolor='black')
# Create HTML pointing to flatmap
html = "<img src='{filename}'/>".format(filename=filename)
return html
def createVolume(data, mask, surface, xfms, vmin=None, vmax=None, factor=0.95):
"""Helper function for creating a cortex volume for visualization.
Parameters
----------
data : np.ndarray
The data to visualize.
mask : np.ndarray
Mask to use to transform.
surface : TYPE
surface to use.
xfms : TYPE
transform to use.
vmin : float
Default: Min of data.
vmax : float
Default: Max of data.
factor : float
Factor of vmax to use for visualization purposes.
Default 0.95.
Returns
-------
cortex volume
"""
volData = np.zeros(mask.shape)
volData[mask > 0] = data
if vmin is None:
vmin = np.min(volData)
if vmax is None:
vmax = np.max(volData) * factor
else:
vmax = factor * vmax
return cortex.Volume(volData, surface, xfms, vmin=vmin, vmax=vmax)
def __call__(self, exp_name, subject, contrast, contrast_data):
prefix = subject.name
if np.sum(contrast_data.data < 0) == 0:
prefix += '_pmap'
volume = contrast_data
else:
volume = cortex.Volume(contrast_data.data, subject.name,
subject.transform, **self.quickflat_args)
volume.data[volume.data == 0] = np.nan
file_name = '{0}_{1}_{2}_simple-flat-map.png'.format(
prefix, exp_name, contrast.name)
file_path = os.path.join(Config.image_dir, file_name)
# Save flatmap
try:
cortex.quickflat.make_png(file_path,
volume,
with_colorbar=False,
with_curvature=True,
cvmin=-2,
cvmax=2,
**self.quickflat_args)
except:
cortex.quickflat.make_png(file_path,
volume,
with_colorbar=False,
with_curvature=True,
cvmin=-2,
cvmax=2,
recache=True,
**self.quickflat_args)
return HTMLImage('flat-map-analysis analysis', file_path)
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)
os.chdir("/auto/k1/fatma/python-packages/replication/code")
subject = "JGfs"
xfmname = "20110321JG_auto2"
volspace = (31, 100, 100)
# Get subject's cortical mask
mask = cortex.db.get_mask(subject, xfmname, "thick")
# Create random brain data
vol = np.zeros(volspace)
vol[mask] = np.random.random((vol[mask].shape))
# Create pycortex Volume
datavol = cortex.Volume(vol, subject, xfmname, cmap='RdBu_r', vmin=0, vmax=1)
# cortex.quickshow(datavol);
# Transform volume to MNI space
print "Transform volume to MNI space"
# 1. Compute transformation matrix
func_to_mni = compute_mni_transform(subject, xfmname)
# 2. Transform to functional volume to MNI space
func_in_mni = transform_to_mni(datavol, func_to_mni)
# 3. Get data
data = func_in_mni.get_data()
# Get MNI coordinates from JSON file
exp_json = read_json("experiments.json")
subject=subject,
task=task,
reg=regist_type,
preproc=preproc)
img_tc = nb.load(tc_file)
tc = img_tc.get_fdata()
# create directory
webviewer_dir = '{base_dir}/pp_data/{subject}/gauss/pycortex_outputs/webviewer/{subject}_{task}_{reg}_{preproc}_tc'.format(
base_dir=base_dir,
subject=subject,
task=task,
reg=regist_type,
preproc=preproc)
try:
os.makedirs(webviewer_dir)
except:
pass
# create volume
volume_tc = cortex.Volume(data=tc.transpose((3, 2, 1, 0)),
subject=subject,
xfmname=xfm_name,
cmap='BuBkRd',
description='BOLD')
# create webgl
print('save pycortex webviewer: time course {}'.format(task))
cortex.webgl.make_static(outpath=webviewer_dir, data=volume_tc)
transform = cortex.xfm.Transform(np.identity(4), t1w)
transform.save(pc_subject, 'identity.t1w.v2', 'magnet')
r2 = r2.get_data().T
freq = freq.get_data().T
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')
import os import tempfile import numpy as np import matplotlib.pyplot as plt import cortex subject = 'S1' ############################################################################### # create some artificial data shape = cortex.db.get_xfm(subject, 'identity').shape data = np.arange(np.product(shape)).reshape(shape) volume = cortex.Volume(data, subject=subject, xfmname='identity') ############################################################################### # Show examples of multi-panels figures params = cortex.export.params_flatmap_lateral_medial cortex.export.plot_panels(volume, **params) plt.show() params = cortex.export.params_occipital_triple_view cortex.export.plot_panels(volume, **params) plt.show() ############################################################################### # List all predefined angles
#cortex.db.get_mask('MNI', 'atlas','thin')
n_v_mni = mask_mni.sum()
errors_files = []
for subject in subjects:
start = time.time()
mask = cortex.db.get_mask(surface.format(subject), xfm.format(subject),
'thick')
nr = len(acc.item()['acc'][subject])
mni_masked[subject] = np.zeros((nr, n_v_mni))
for ir in range(nr):
tmp = np.vstack(acc.item()['acc'][subject])[ir]
vol = np.zeros(mask.shape)
vol[mask] = tmp
vol = cortex.Volume(tmp,
surface.format(subject),
xfm.format(subject),
mask=mask)
try:
mni_vol = mni.transform_to_mni(
vol, mni_transforms[subject]).get_data().T
mni_masked[subject][ir] = mni_vol[mask_mni]
except:
errors_files.append('subject {} row {}'.format(subject, ir))
if ir % 10 == 1:
print('time_left for {}, {} seconds'.format(
subject, (time.time() - start) / (ir + 1) * (nr - ir - 1)))
for subject in subjects:
np.save('bert2_uniform_mni_{}.npy'.format(subject), mni_masked[subject])
voxels and then create a cortex.Volume object. Then, you get a mapper to go between voxels and vertices for the specific subject and transform you are working with. Pass the voxel volume through the mapper and you get out a vertex mapping of that data. You can plot both of these as you normally would. """ import cortex import cortex.polyutils import numpy as np np.random.seed(1234) import matplotlib.pyplot as plt subject = 'S1' xfm = 'fullhead' # First create example voxel data for this subject and transform voxel_data = np.random.randn(31, 100, 100) voxel_vol = cortex.Volume(voxel_data, subject, xfm) # Then we have to get a mapper from voxels to vertices for this transform mapper = cortex.get_mapper(subject, xfm, 'line_nearest', recache=True) # Just pass the voxel data through the mapper to get vertex data vertex_map = mapper(voxel_vol) # You can plot both as you would normally plot Volume and Vertex data cortex.quickshow(voxel_vol) plt.show() cortex.quickshow(vertex_map) plt.show()
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 test_volumedata_copy():
v = cortex.Volume(np.random.randn(*volshape), subj, xfmname)
vc = v.copy(v.data)
assert np.allclose(v.data, vc.data)
def __mean__(self, subjects, do_perm, contrast_results):
# Prepare volumes
volumes = {}
if self.mask_pred:
for s, cr in zip(subjects, contrast_results):
mask = s.voxels_predicted
mask = cortex.Volume(mask, s.name, s.transform)
s.data[mask.data == True] = -1
if do_perm:
#FIXME which threshold?
cr.thresholded_contrast.data[mask.data == True] = -1
volumes[cr.subject] = s
if do_perm:
if not self.mask_pred:
volumes = {
con_res.subject: con_res.threshold_05
for con_res in contrast_results
}
else:
pass
else:
volumes = {
con_res.subject: con_res
for con_res in contrast_results
}
for v in volumes.values():
v.data = np.nan_to_num(v.data)
# Re-compute mask
if self.recomputed_mask:
# FIXME should it be s.predicted_mask_mni ?
# s2 = [s.predicted_mask_MNI for s in subjects]
s2 = [s.predicted_mask_mni for s in subjects]
self.nan_mask = np.mean(np.stack(s2), axis=0)
self.nan_mask = self.nan_mask >= 3 / 8.0
np.save(MNI_MASK_FILE, self.nan_mask)
mni_volumes = [
cortex.mni.transform_to_mni(volumes[s.name],
s.func_to_mni).get_data().T
for s in subjects
]
# Smooth
if self.smooth is not None:
Logger.debug("Smoothing with %f mm kernel.." % self.smooth)
atlasim = nipy.load_image(FSL_DEFAULT_TEMPLATE)
smoother = nipy.kernel_smooth.LinearFilter(atlasim.coordmap,
atlasim.shape,
self.smooth)
new_mni_volumes = []
for ml in mni_volumes:
# Create nipy-style Image from volume
ml_img = nipy.core.image.Image(ml.T, atlasim.coordmap)
# Pass it through smoother
sm_ml_img = smoother.smooth(ml_img)
# Store the result
new_mni_volumes.append(sm_ml_img.get_data().T)
mni_volumes = new_mni_volumes
# Mean values
group_mean = np.mean(np.stack(mni_volumes), axis=0)
group_mean[self.nan_mask == False] = np.nan
un_nan = np.isnan(group_mean) * self.nan_mask
group_mean[un_nan] = 0
max_v_volume = 1 if do_perm or self.do_1pct else 2
if self.do_1pct:
th = np.percentile(group_mean[group_mean != 0], 90)
group_mean = group_mean >= th
mean_volume = cortex.Volume(group_mean,
'MNI',
'atlas',
vmin=-max_v_volume,
vmax=max_v_volume)
sub_volumes = [
cortex.Volume(vol,
'MNI',
'atlas',
vmin=-np.abs(vol).max(),
vmax=np.abs(vol).max()) for vol in mni_volumes
]
for sub, vol in zip(subjects, sub_volumes):
vol.data[sub.predicted_mask_mni == False] = np.nan
return mean_volume, sub_volumes
xfm,
roi_list=None, # Default (None) gives all available ROIs in overlays.svg
gm_sampler=
'cortical-conservative', # Select only voxels mostly within cortex
split_lr=
True, # Separate left/right ROIs (this occurs anyway with index volumes)
threshold=0.9, # convert probability values to boolean mask for each ROI
return_dict=False # return index volume, not dict of masks
)
lim = np.max(np.abs(index_volume))
# Plot the mask for one ROI onto a flatmap
roi_data = cortex.Volume(
index_volume,
subject,
xfm,
vmin=-lim, # This is a probability mask, so only
vmax=lim, # so scale btw zero and one
cmap="RdBu_r", # Shades of blue for L hem, red for R hem ROIs
)
cortex.quickflat.make_figure(
roi_data,
thick=1, # select a single depth (btw white matter & pia)
sampler='nearest', # no interpolation
with_curvature=True,
with_colorbar=True,
)
print("Index keys for which ROI is which in `index_volume`:")
print(index_keys)
plt.show()
# Get the map of which voxels are inside of our ROI
roi_masks = cortex.utils.get_roi_masks(
subject,
xfm,
roi_list=[roi],
gm_sampler=
'cortical-conservative', # Select only voxels mostly within cortex
split_lr=False, # No separate left/right ROIs
threshold=None, # Leave roi mask values as probabilites / fractions
return_dict=True)
# Plot the mask for one ROI onto a flatmap
roi_data = cortex.Volume(
roi_masks[roi],
subject,
xfm,
vmin=0, # This is a probability mask, so only
vmax=1, # so scale btw zero and one
cmap="inferno", # For pretty
)
cortex.quickflat.make_figure(
roi_data,
thick=1, # select a single depth (btw white matter & pia)
sampler='nearest', # no interpolation
with_curvature=True,
with_colorbar=True,
)
plt.show()
