def plot_overlays_diff_group_window(condition,method,modality,hemi,window,azimuth,elevation):
subject_id, surface = 'fsaverage', 'inflated'
hemi = hemi
brain = Brain(subject_id, hemi, surface, size=(600, 600))
stc_fname = ('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/mne_python/BrainMaps/IcaCorr_Normalized'
+ modality + '_' + condition[0] + '-' + condition[1] + '_pick_oriNone_' + method
+ '_ico-5-fwd-fsaverage.stc-'+ hemi +'.stc')
stcl_fname = ('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/mne_python/BrainMaps/IcaCorr_Normalized'
+ modality + '_' + condition[0] + '-' + condition[1] + '_pick_oriNone_' + method
+ '_ico-5-fwd-fsaverage.stc-lh.stc')
stcr_fname = ('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/mne_python/BrainMaps/IcaCorr_Normalized'
+ modality + '_' + condition[0] + '-' + condition[1] + '_pick_oriNone_' + method
+ '_ico-5-fwd-fsaverage.stc-rh.stc')
stcl = read_stc(stcl_fname)
stcr = read_stc(stcr_fname)
datal = stcl['data']
datar = stcr['data']
stc = read_stc(stc_fname)
data = stc['data']
vertices = stc['vertices']
time = np.linspace(stc['tmin'], stc['tmin'] + data.shape[1] * stc['tstep'],
data.shape[1])
winstart = np.where(time < window[0])[0][-1]
winend = np.where(time >= window[1])[0][0]
meanval = np.mean(data[:,winstart:winend],1)
meanvalr = np.mean(datar[:,winstart:winend],1)
meanvall = np.mean(datal[:,winstart:winend],1)
maxval = np.max([np.max(meanvalr),np.max(meanvall)])
minval = np.min([np.min(meanvalr),np.min(meanvall)])
fmin = -np.max(np.abs([maxval,minval]))*0.8
fmax = np.max(np.abs([maxval,minval]))*0.8
colormap = mne.viz.mne_analyze_colormap(limits=[fmin, fmin/3, fmin/3.1, fmax/3.1, fmax/3, fmax], format='mayavi')
#colormap = 'jet'
time_label = lambda t: 'time=%0.2f ms' % (0)
brain.add_data(meanval, colormap=colormap, vertices=vertices,
smoothing_steps=15, time=time, time_label=time_label,
hemi=hemi)
brain.scale_data_colormap(fmin=fmin, fmid=0, fmax=fmax, transparent=False)
brain.show_view(dict(azimuth=azimuth,elevation=elevation, distance=None))
# mayavi.mlab.view(azimuth=0, elevation=None, distance=None, focalpoint=None,
# roll=None, reset_roll=True, figure=None)
PlotDir = []
PlotDir = ('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/GROUP/mne_python/Plots/IcaCorr_Window_'
+ condition[0] + '-' + condition[1] + str(window[0]) + '-' + str(window[1]))
if not os.path.exists(PlotDir):
os.makedirs(PlotDir)
brain.save_image(PlotDir + '/IcaCorr_' + modality + '_' + method + '_'
+ '_Normalized' + condition[0] + '-' + condition[1] + '_'
+ str(window[0]) + '-' + str(window[1])
+ hemi + '_'+ str(azimuth)+ '_ico-5-fwd-fsaverage-'+'.png')
def test_brains():
"""Test plotting of Brain with different arguments
"""
# testing backend breaks when passing in a figure, so we use 'auto' here
# (shouldn't affect usability, but it makes testing more annoying)
mlab.options.backend = 'auto'
surfs = ['inflated', 'white']
hemis = ['lh', 'rh']
curvs = [True, False]
titles = [None, 'Hello']
cortices = ["low_contrast", ("Reds", 0, 1, False)]
sizes = [500, (400, 300)]
backgrounds = ["white", "blue"]
foregrounds = ["black", "white"]
figs = [None, mlab.figure()]
subj_dirs = [None, subj_dir]
for surf, hemi, curv, title, cort, s, bg, fg, fig, sd \
in zip(surfs, hemis, curvs, titles, cortices, sizes,
backgrounds, foregrounds, figs, subj_dirs):
brain = Brain(subject_id, hemi, surf, curv, title, cort, s, bg, fg,
fig, sd)
brain.close()
assert_raises(ValueError,
Brain,
subject_id,
'lh',
'inflated',
subjects_dir='')
def test_text():
"""Test plotting of text
"""
mlab.options.backend = 'test'
brain = Brain(*std_args)
brain.add_text(0.1, 0.1, 'Hello', 'blah')
brain.close()
def plot_single_roi(roi):
fsaverage = "fsaverage"
hemi = "lh"
surf = "inflated"
t, p, str_names, labels = get_data()
df = pd.DataFrame({'labs': str_names, 't': 0})
df.loc[df.labs == roi, 't'] = -4
data = df.t.values
data = data[labels]
brain = Brain(fsaverage,
hemi,
surf,
background="white",
views=['lateral', 'ventral', 'medial', 'frontal'])
brain.add_data(data, -10, 11, thresh=None, colormap="RdBu_r", alpha=1)
f = brain.save_montage(None,
[['lateral', 'parietal'], ['medial', 'frontal']],
border_size=0,
colorbar=None)
fig, a = plt.subplots()
im = plt.imshow(f, cmap='RdBu_r')
a.set(xticks=[], yticks=[])
sns.despine(bottom=True, left=True)
cbar = fig.colorbar(im,
ticks=[f.min(), (f.min() + 255) / 2, 255],
orientation='horizontal',
drawedges=False)
cbar.ax.set_xticklabels(['-10', '0', '10'])
a.set_title(roi)
return f, data
def plot_one_brain(dsignal,
signal,
lc,
cmap,
ex_sub='S04',
classifier='SCVlin',
epoch='response',
measure='auc',
views=[['par', 'fro'], ['lat', 'med']]):
from surfer import Brain
print('Creating Brain')
brain = Brain(ex_sub, 'lh', 'inflated', views=['lat'], background='w')
# subjects_dir='/Users/nwilming/u/freesurfer_subjects/')
print('Created Brain')
ms = dsignal.mean()
if (signal == 'CONF_signed') and (measure == 'accuracy'):
plot_labels_on_brain(brain, lc, ms, cmap)
if (signal == 'SSD'):
plot_labels_on_brain(brain, lc, ms, cmap)
else:
plot_labels_on_brain(brain, lc, ms, cmap)
brain.save_montage(
'/Users/nwilming/Desktop/%s_montage_%s_%s_%s.png' %
(signal, measure, classifier, epoch), views)
return brain
def brain_plot(r_name, viewtimes, brain):
views = {'rh': ['medial', 'parietal'], 'lh': ['parietal', 'medial']}
if type(brain) is str:
hemi = brain
brain = Brain('fsaverage',
hemi,
'inflated',
cortex='low_contrast',
subjects_dir=sv.subjects_dir,
background='w',
foreground='k')
else:
hemi = brain.geo.keys()[0]
sv.show_labels_as_data(src_df_masked.loc[r_name], show_measure, brain,
**colorinfo)
filepat = os.path.join(
figdir, filepat_base + '_{}_{}_%02d.png'.format(hemi, r_name))
brain.save_image_sequence([times.get_loc(t) for t in viewtimes],
filepat,
montage=views[hemi])
return brain
def test_brains():
"""Test plotting of Brain with different arguments."""
# testing backend breaks when passing in a figure, so we use 'auto' here
# (shouldn't affect usability, but it makes testing more annoying)
mlab.options.backend = 'auto'
surfs = ['inflated', 'white', 'white', 'white', 'white', 'white', 'white']
hemis = ['lh', 'rh', 'both', 'both', 'rh', 'both', 'both']
titles = [None, 'Hello', 'Good bye!', 'lut test',
'dict test', 'None test', 'RGB test']
cortices = ["low_contrast", ("Reds", 0, 1, False), 'hotpink',
['yellow', 'blue'], dict(colormap='Greys'),
None, (0.5, 0.5, 0.5)]
sizes = [500, (400, 300), (300, 300), (300, 400), 500, 400, 300]
backgrounds = ["white", "blue", "black", "0.75",
(0.2, 0.2, 0.2), "black", "0.75"]
foregrounds = ["black", "white", "0.75", "red",
(0.2, 0.2, 0.2), "blue", "black"]
figs = [None, mlab.figure(), None, None, mlab.figure(), None, None]
subj_dirs = [None, subj_dir, subj_dir, subj_dir,
subj_dir, subj_dir, subj_dir]
alphas = [1.0, 0.5, 0.25, 0.7, 0.5, 0.25, 0.7]
for surf, hemi, title, cort, s, bg, fg, fig, sd, alpha \
in zip(surfs, hemis, titles, cortices, sizes,
backgrounds, foregrounds, figs, subj_dirs, alphas):
brain = Brain(subject_id, hemi, surf, title=title, cortex=cort,
alpha=alpha, size=s, background=bg, foreground=fg,
figure=fig, subjects_dir=sd)
brain.close()
assert_raises(ValueError, Brain, subject_id, 'lh', 'inflated',
subjects_dir='')
def test_offscreen():
"""Test offscreen rendering
"""
mlab.options.backend = 'auto'
brain = Brain(*std_args, offscreen=True)
shot = brain.screenshot()
assert_array_equal(shot.shape, (800, 800, 3))
def test_morphometry():
"""Test plotting of morphometry."""
_set_backend()
brain = Brain(*std_args)
brain.add_morphometry("curv")
brain.add_morphometry("sulc", grayscale=True)
brain.add_morphometry("thickness")
brain.close()
def test_offscreen():
"""Test offscreen rendering."""
_set_backend()
brain = Brain(*std_args, offscreen=True)
shot = brain.screenshot()
assert_array_less((400, 400, 2), shot.shape)
assert_array_less(shot.shape, (801, 801, 4))
brain.close()
def test_morphometry():
"""Test plotting of morphometry."""
mlab.options.backend = 'test'
brain = Brain(*std_args)
brain.add_morphometry("curv")
brain.add_morphometry("sulc", grayscale=True)
brain.add_morphometry("thickness")
brain.close()
def test_data_limits():
"""Test handling of data limits."""
_set_backend()
brain = Brain(*std_args)
surf_data = np.zeros(163842)
pytest.raises(ValueError, brain.add_data, surf_data, 0, 0)
brain.add_data(surf_data, 0, 1)
brain.close()
def test_offscreen():
"""Test offscreen rendering
"""
mlab.options.backend = 'auto'
brain = Brain(*std_args, offscreen=True)
shot = brain.screenshot()
assert_array_equal(shot.shape, (800, 800, 3))
brain.close()
def test_offscreen():
"""Test offscreen rendering."""
_set_backend()
brain = Brain(*std_args, offscreen=True)
shot = brain.screenshot()
assert_array_less((400, 400, 2), shot.shape)
assert_array_less(shot.shape, (801, 801, 4))
brain.close()
def main(subid, overlay):
_, fname = os.path.split(overlay)
hemi = fname[:2]
brain = Brain(subid, hemi, "pial",
config_opts=dict(cortex="low_contrast"))
brain.add_overlay(overlay, min=0.4, max=4, sign="pos")
brain.show_view('m')
def test_data():
"""Test plotting of data
"""
mlab.options.backend = 'test'
brain = Brain(*std_args)
mri_file = pjoin(data_dir, 'resting_corr.nii.gz')
reg_file = pjoin(data_dir, 'register.dat')
surf_data = io.project_volume_data(mri_file, "lh", reg_file)
brain.add_data(surf_data, -.7, .7, colormap="jet", alpha=.7)
def make_brain(subject_id,image_path):
from surfer import Brain
hemi = 'lh'
surface = 'inflated'
brain = Brain(subject_id, hemi, surface)
brain.add_overlay(image_path,min=thr)
outpath = os.path.join(os.getcwd(),os.path.split(image_path)[1]+'_surf.png')
brain.save_montage(outpath)
return outpath
def add_cluster(clustermap, hemi, fsaverage):
brain = Brain(fsaverage,
hemi,
surface,
config_opts=dict(background="lightslategray",
cortex="high_contrast"))
brain.add_data(clustermap, colormap='spectral', alpha=.8)
brain.data['colorbar'].number_of_colors = int(clustermap.max()) + 1
brain.data['colorbar'].number_of_labels = int(clustermap.max(
)) + 1 ##because -1 denotes masked regions, cluster labels start at 1
def test_annot():
"""Test plotting of annot
"""
mlab.options.backend = 'test'
annots = ['aparc', 'aparc.a2005s']
borders = [True, False]
alphas = [1, 0.5]
brain = Brain(*std_args)
for a, b, p in zip(annots, borders, alphas):
brain.add_annotation(a, b, p)
def get_hemi_data(subject, hemi, source, surf_name="pial", name=None, sign="abs", min=None, max=None):
brain = Brain(subject, hemi, surf_name, curv=False)
hemi = brain._check_hemi(hemi)
# load data here
scalar_data, name = brain._read_scalar_data(source, hemi, name=name)
min, max = brain._get_display_range(scalar_data, min, max, sign)
if sign not in ["abs", "pos", "neg"]:
raise ValueError("Overlay sign must be 'abs', 'pos', or 'neg'")
old = viz.OverlayData(scalar_data, brain.geo[hemi], min, max, sign)
return old.mlab_data, brain
def test_brain_separate():
"""Test that Brain does not reuse existing figures by default."""
_set_backend('auto')
brain = Brain(*std_args)
assert brain.brain_matrix.size == 1
brain_2 = Brain(*std_args)
assert brain_2.brain_matrix.size == 1
assert brain._figures[0][0] is not brain_2._figures[0][0]
brain_3 = Brain(*std_args, figure=brain._figures[0][0])
assert brain._figures[0][0] is brain_3._figures[0][0]
def contrast_loop(subj, contrasts, stat_temp, mask_temp, png_temp, args,
z_thresh, sign):
"""Iterate over contrasts and make surface images."""
for contrast in contrasts:
# Calculate where the overlay should saturate
z_max = calculate_sat_point(stat_temp, contrast, sign, subj)
panels = []
for hemi in ["lh", "rh"]:
# Initialize the brain object
b_subj = subj if args.regspace == "epi" else "fsaverage"
try:
b = Brain(b_subj, hemi, args.geometry, background="white")
except TypeError:
# PySurfer <= v0.5
b = Brain(b_subj,
hemi,
args.geometry,
config_opts={"background": "white"})
# Plot the mask
mask_file = mask_temp.format(contrast=contrast,
hemi=hemi,
subj=subj)
add_mask_overlay(b, mask_file)
# Plot the overlay
stat_file = stat_temp.format(contrast=contrast,
hemi=hemi,
subj=subj)
add_stat_overlay(b,
stat_file,
z_thresh,
z_max,
sign,
sig_to_z=args.regspace == "fsaverage")
# Take screenshots
for view in ["lat", "med", "ven"]:
b.show_view(view, distance="auto")
sleep(.1)
panels.append(crop(b.screenshot()))
b.close()
# Make a single figure with all the panels
f = multi_panel_brain_figure(panels)
kwargs = {}
if sign in ["pos", "abs"]:
kwargs["pos_cmap"] = "Reds_r"
if sign in ["neg", "abs"]:
kwargs["neg_cmap"] = "Blues"
add_colorbars(f, z_thresh, z_max, **kwargs)
# Save the figure in both hemisphere outputs
for hemi in ["lh", "rh"]:
png_file = png_temp.format(hemi=hemi, contrast=contrast, subj=subj)
f.savefig(png_file, bbox_inches="tight")
plt.close(f)
def surface_images(out_dir, subj):
"""Plot the white, pial, and inflated surfaces to look for defects."""
for surf in ["white", "pial", "inflated"]:
panels = []
for hemi in ["lh", "rh"]:
try:
b = Brain(subj, hemi, surf, curv=False, background="white")
except TypeError:
# PySurfer <= 0.5
b = Brain(subj,
hemi,
surf,
curv=False,
config_opts=dict(background="white"))
for view in ["lat", "med", "ven"]:
b.show_view(view, distance="auto")
panels.append(crop(b.screenshot()))
b.close()
# Make and save a figure
f = multi_panel_brain_figure(panels)
fname = op.join(out_dir, "{}_surface.png".format(surf))
f.savefig(fname, bbox_inches="tight")
plt.close(f)
def make_brain_figures(srcdf, measure, cinfo, filepat_base, top=5):
views = {'rh': ['medial', 'lateral'],
'lh': ['lateral', 'medial']}
toplabels = {}
for hemi in ['lh', 'rh']:
brain = Brain('fsaverage', hemi, 'inflated', cortex='low_contrast',
subjects_dir=sv.subjects_dir, background='w',
foreground='k')
sv.show_labels_as_data(srcdf, measure, brain,
time_label=None, parc=parc, **cinfo)
if top:
ind = srcdf.index.get_level_values('label').map(
lambda x: x.startswith(hemi[0].upper()))
topl = srcdf[ind].abs().sort_values(
measure, ascending=False).head(top)
topl = (
topl[(topl[measure] != 0)
& topl[measure].notna()]
.index.droplevel('time'))
toplabels[hemi] = topl
alllabels = mne.read_labels_from_annot(
'fsaverage', parc=parc, hemi=hemi)
brain.remove_labels()
for label in alllabels:
if label.name in topl:
brain.add_label(label, borders=1, hemi=hemi, alpha=0.8,
color='k')
# increase font size of colorbar - this only works by increasing the
# colorbar itself and setting the ratio of colorbar to text
brain.data['colorbar'].scalar_bar.bar_ratio = 0.35
brain.data['colorbar'].scalar_bar_representation.position = [0.075, 0.01]
brain.data['colorbar'].scalar_bar_representation.position2 = [0.85, 0.12]
filepat = os.path.join(figdir, filepat_base + '_{}.png'.format(hemi))
brain.save_montage(filepat, views[hemi], colorbar=0)
brain.close()
infiles = [
os.path.join(figdir, filepat_base + '_{}.png'.format(hemi))
for hemi in ['lh', 'rh']]
outfile = os.path.join(figdir, filepat_base + '.png')
os.system("montage -tile 2x1 -geometry +0+0 {} {}".format(
' '.join(infiles), outfile))
return toplabels
def curvature_normalization(data_dir, subj, close=True):
"""Normalize the curvature map and plot contour over fsaverage."""
surf_dir = op.join(data_dir, subj, "surf")
snap_dir = op.join(data_dir, subj, "snapshots")
for hemi in ["lh", "rh"]:
cmd = ["mri_surf2surf",
"--srcsubject", subj,
"--trgsubject", "fsaverage",
"--hemi", hemi,
"--sval", op.join(surf_dir, "%s.curv" % hemi),
"--tval", op.join(surf_dir, "%s.curv.fsaverage.mgz" % hemi)]
sub.check_output(cmd)
b = Brain("fsaverage", hemi, "inflated",
config_opts=dict(background="white",
width=700, height=500))
curv = nib.load(op.join(surf_dir, "%s.curv.fsaverage.mgz" % hemi))
curv = (curv.get_data() > 0).squeeze()
b.add_contour_overlay(curv, min=0, max=1.5, n_contours=2, line_width=4)
b.contour["colorbar"].visible = False
for view in ["lat", "med"]:
b.show_view(view)
mlab.view(distance=330)
png = op.join(snap_dir, "%s.surf_warp_%s.png" % (hemi, view))
b.save_image(png)
if close:
b.close()
def plot_group(hub,num_nodes,hemi='lh'):
from surfer import Brain, io
brain = Brain("fsaverage", "%s" %(hemi), "pial",config_opts=dict(background="white"))
if hub == 'pc' or hub =='wmd':
image = io.project_volume_data('/home/despo/mb3152/random_nodes/%s/group_%s.nii'%(num_nodes,hub),hemi, subject_id="fsaverage", projsum = 'max', smooth_fwhm = 20)
brain.add_data(image,colormap = "Reds", colorbar= True)
else:
pc_image = io.project_volume_data('/home/despo/mb3152/random_nodes/%s/group_pc.nii'%(num_nodes),hemi, subject_id="fsaverage", projsum = 'max', smooth_fwhm = 20)
wmd_image = io.project_volume_data('/home/despo/mb3152/random_nodes/%s/group_wmd.nii'%(num_nodes),hemi, subject_id="fsaverage", projsum = 'max', smooth_fwhm = 20)
wmd_thresh = np.nanmean(wmd_image[wmd_image>0])
pc_thresh = np.nanmean(pc_image[pc_image >0])
#find connetor hub activity
connector_hub_image = pc_image.copy()
connector_hub_image[pc_image < pc_thresh] = 0.
connector_hub_image[wmd_image < wmd_thresh] = 0.
#find sattelite connector activty
satellite_image = pc_image.copy()
satellite_image[pc_image < pc_thresh] = 0.
satellite_image[wmd_image > wmd_thresh] = 0.
# find provincial hub activity
provincial_hub_image = wmd_image.copy()
provincial_hub_image[pc_image > pc_thresh] = 0.
provincial_hub_image[wmd_image < wmd_thresh] = 0.
node_image = pc_image.copy()
node_image[provincial_hub_image > 0] = 0
node_image[connector_hub_image > 0] = 0
node_image[satellite_image > 0] = 0
node_image[node_image > 0] = 1
# brain.add_data(node_image,thresh= 0, max = 2, colormap = 'gray',hemi=hemi,smoothing_steps = 0)
brain.add_data(connector_hub_image,thresh= np.nanmin(pc_image),max=pc_thresh + np.std(pc_image), colormap = 'Reds',hemi=hemi,smoothing_steps = 0)
brain.add_data(satellite_image,thresh= np.nanmin(pc_image),max=pc_thresh + np.std(pc_image),colormap = 'autumn',hemi=hemi,smoothing_steps = 0)
brain.add_data(provincial_hub_image,thresh=np.nanmin(wmd_image),max=wmd_thresh +np.std(wmd_image),colormap = 'Blues',hemi=hemi,smoothing_steps = 0)
def test_annot():
"""Test plotting of annot."""
mlab.options.backend = 'test'
annots = ['aparc', 'aparc.a2005s']
borders = [True, False, 2]
alphas = [1, 0.5]
brain = Brain(*std_args)
for a, b, p in zip(annots, borders, alphas):
brain.add_annotation(a, b, p)
assert_raises(ValueError, brain.add_annotation, 'aparc', borders=-1)
brain.close()
def test_contour():
"""Test plotting of contour overlay
"""
mlab.options.backend = 'test'
brain = Brain(*std_args)
overlay_file = pjoin(data_dir, "lh.sig.nii.gz")
brain.add_contour_overlay(overlay_file)
brain.add_contour_overlay(overlay_file, max=20, n_contours=9,
line_width=2)
brain.contour['surface'].actor.property.line_width = 1
brain.contour['surface'].contour.number_of_contours = 10
def test_animate(tmpdir):
"""Test animation."""
_set_backend('auto')
brain = Brain(*std_args, size=100)
brain.add_morphometry('curv')
tmp_name = str(tmpdir.join('test.avi'))
brain.animate(["m"] * 3, n_steps=2)
brain.animate(['l', 'l'], n_steps=2, fname=tmp_name)
# can't rotate in axial plane
pytest.raises(ValueError, brain.animate, ['l', 'd'])
brain.close()
def test_animate():
"""Test animation."""
_set_backend('auto')
brain = Brain(*std_args, size=100)
brain.add_morphometry('curv')
tmp_name = mktemp() + '.avi'
brain.animate(["m"] * 3, n_steps=2)
brain.animate(['l', 'l'], n_steps=2, fname=tmp_name)
# can't rotate in axial plane
assert_raises(ValueError, brain.animate, ['l', 'd'])
brain.close()
def test_data():
"""Test plotting of data."""
_set_backend()
brain = Brain(*std_args)
mri_file = pjoin(data_dir, 'resting_corr.nii.gz')
reg_file = pjoin(data_dir, 'register.dat')
surf_data = io.project_volume_data(mri_file, "lh", reg_file)
brain.add_data(surf_data, -.7, .7, colormap="jet", alpha=.7)
brain.set_surf('white')
brain.add_data([], vertices=np.array([], int))
brain.close()
def test_morphometry():
"""Test plotting of morphometry."""
mlab.options.backend = 'test'
brain = Brain(*std_args)
brain.add_morphometry("curv")
brain.add_morphometry("sulc", grayscale=True)
brain.add_morphometry("thickness")
brain.close()
def test_morphometry():
"""Test plotting of morphometry."""
_set_backend()
brain = Brain(*std_args)
brain.add_morphometry("curv")
brain.add_morphometry("sulc", grayscale=True)
brain.add_morphometry("thickness")
brain.close()
def get_hemi_data(subject, hemi, source, surf_name="pial", name=None, sign="abs", min=None, max=None):
brain = Brain(subject, hemi, surf_name, curv=False, offscreen=True)
print("Brain {} verts: {}".format(hemi, brain.geo[hemi].coords.shape[0]))
hemi = brain._check_hemi(hemi)
# load data here
scalar_data, name = brain._read_scalar_data(source, hemi, name=name)
print("fMRI constrast map vertices: {}".format(len(scalar_data)))
min, max = brain._get_display_range(scalar_data, min, max, sign)
if sign not in ["abs", "pos", "neg"]:
raise ValueError("Overlay sign must be 'abs', 'pos', or 'neg'")
old = viz.OverlayData(scalar_data, brain.geo[hemi], min, max, sign)
return old, brain
def test_animate():
"""Test animation
"""
mlab.options.backend = 'auto'
brain = Brain(*std_args, config_opts=small_brain)
brain.add_morphometry('curv')
tmp_name = mktemp() + '.avi'
brain.animate(["m"] * 3, n_steps=2)
brain.animate(['l', 'l'], n_steps=2, fname=tmp_name)
# can't rotate in axial plane
assert_raises(ValueError, brain.animate, ['l', 'd'])
brain.close()
def visualise_surface(zstat,
hemi,
surface='inflated',
min_val=None,
max_val=None,
thr_val=0,
cmap='autumn'):
'''
VERY helpfully taken from the Pysurfer example gallery
http://pysurfer.github.io/examples/plot_fmri_activation_volume.html
Parameters
----------
zstat : pysurfer surface
Surface projection of result_file to fsaverage
brain
prefix : save
hemi : {'lh', 'rh'}
string indicating left or right hemisphere
surface : {'inflated', 'pial', 'white'}
string indicating surface view
min_val : minimum value to be shown
(default is to calculate it from the data)
max_val : maximum value to be shown
(default is to calculate it from the data)
thr_val : threshold value
zero everything below this number
(default is 0)
cmap : matplotlib colormap
(default is autumn)
Returns
----------
brain : current pysurfer visualization window
'''
"""
Bring up the visualization window.
"""
brain = Brain("fsaverage",
hemi,
surface,
config_opts={'background': 'white'})
"""
Add zstat as an overlay
"""
brain.add_data(zstat,
min=min_val,
max=max_val,
thresh=thr_val,
colormap=cmap,
colorbar=True)
return brain
def get_hemi_data(subject, hemi, source, surf_name='pial', name=None, sign="abs", min=None, max=None):
brain = Brain(subject, hemi, surf_name, curv=False, offscreen=True)
print('Brain {} verts: {}'.format(hemi, brain.geo[hemi].coords.shape[0]))
hemi = brain._check_hemi(hemi)
# load data here
scalar_data, name = brain._read_scalar_data(source, hemi, name=name)
print('fMRI constrast map vertices: {}'.format(len(scalar_data)))
min, max = brain._get_display_range(scalar_data, min, max, sign)
if sign not in ["abs", "pos", "neg"]:
raise ValueError("Overlay sign must be 'abs', 'pos', or 'neg'")
old = viz.OverlayData(scalar_data, brain.geo[hemi], min, max, sign)
return old, brain
def corr_image(resting_image,fwhm):
"""This function makes correlation image on brain surface"""
import numpy as np
import nibabel as nb
import matplotlib.pyplot as plt
from surfer import Brain, Surface
import os
img = nb.load(resting_image)
corrmat = np.corrcoef(np.squeeze(img.get_data()))
corrmat[np.isnan(corrmat)] = 0
corrmat_npz = os.path.abspath('corrmat.npz')
np.savez(corrmat_npz,corrmat=corrmat)
br = Brain('fsaverage5', 'lh', 'smoothwm')
#br.add_overlay(corrmat[0,:], min=0.2, name=0, visible=True)
lh_aparc_annot_file = os.path.join(os.environ["FREESURFER_HOME"],'/subjects/label/lh.aparc.annot')
values = nb.freesurfer.read_annot(lh_aparc_annot_file)
#br.add_overlay(np.mean(corrmat[values[0]==5,:], axis=0), min=0.8, name='mean', visible=True)
data = img.get_data()
data = np.squeeze(img.get_data())
#
precuneus_signal = np.mean(data[values[0]==np.nonzero(np.array(values[2])=='precuneus')[0][0],:], axis=0)
precuneus = np.corrcoef(precuneus_signal, data)
#precuneus.shape
#br.add_overlay(precuneus[0,1:], min=0.3, sign='pos', name='mean', visible=True)
br.add_overlay(precuneus[0,1:], min=0.2, name='mean')#, visible=True)
#br.add_overlay(precuneus[0,1:], min=0.2, name='mean')#, visible=True)
plt.hist(precuneus[0,1:], 128)
plt.savefig(os.path.abspath("histogram.png"))
plt.close()
corr_image = os.path.abspath("corr_image%s.png"%fwhm)
br.save_montage(corr_image)
ims = br.save_imageset(prefix=os.path.abspath('fwhm_%s'%str(fwhm)),views=['medial','lateral','caudal','rostral','dorsal','ventral'])
br.close()
print ims
#precuneus[np.isnan(precuneus)] = 0
#plt.hist(precuneus[0,1:])
roitable = [['Region','Mean Correlation']]
for i, roi in enumerate(np.unique(values[2])):
roitable.append([roi,np.mean(precuneus[values[0]==np.nonzero(np.array(values[2])==roi)[0][0]])])
#images = [corr_fimage]+ims+[os.path.abspath("histogram.png"), roitable]
roitable=[roitable]
histogram = os.path.abspath("histogram.png")
return corr_image, ims, roitable, histogram, corrmat_npz
def test_image():
"""Test image saving
"""
mlab.options.backend = 'auto'
brain = Brain(*std_args, config_opts=small_brain)
tmp_name = mktemp() + '.png'
brain.save_image(tmp_name)
brain.save_imageset(tmp_name, ['med', 'lat'], 'jpg')
brain.save_montage(tmp_name, ['l', 'v', 'm'], orientation='v')
brain.screenshot()
def visMontage(pathToSurface, overlay, outputPath, hemi, type='white'):
brain = Brain(pathToSurface, hemi, type)
brain.add_overlay(overlay, -5, 3)
brain.save_montage(outputPath, ['l', 'm'], orientation='v')
brain.close()
return outputPath
def plot_ctx():
# Visualize the left or right hemisphere activation map per run with Yeo 2011 overlay of functional connectivity maps
# State path to statistical mask files generated by freesurfer processes
path = "/home/lauri/Documents/temp/"
statpath = os.listdir(path)
statfile = []
hemispheres = ['lh','rh']
# Creates a function to grab all cortical statistical files
for h in hemispheres:
for s in statpath:
if s.startswith(h) and s.endswith("gz"):
statfile.append(s)
print('Making images for:')
statfile.sort()
print(statfile)
# Create the image using pysurfer with backend function initialized
for h in hemispheres:
for f in statfile:
sig = os.path.join(path,f)
sub = "fsaverage"
hemi = h
surf = "inflated"
view_types = ['lat','med']
brain = Brain(sub, hemi, surf, cortex=None, background="midnightblue", views=view_types)
overlay_file = sig
brain.add_overlay(sig, min=1, max=3, name="ovrlay")
# To change colour of activations: note replace pos or neg: brain.overlays["ovrlay"].neg_bar.lut_mode = "winter"
subjects_dir = os.environ["SUBJECTS_DIR"]
annot_path = os.path.join(subjects_dir, sub, "label", "lh.Yeo2011_7Networks_N1000.annot")
brain.add_annotation(annot_path, hemi=h, borders=False, alpha=.33)
brain.save_image(os.path.join(path,f + ".jpeg"))
def plot_y_pred_true_parcels(subject_name,
labels_pred,
labels_true,
colors={
'pred': 'y',
'true': 'b',
'overlap': 'g'
}):
# fig_name = (subject_name + '_' + str(len(parcels_subject)) + '_' +
# str(n_parcels_max))
# TODO: make the switch automatic depending on who/where it runs
data_path = 'mne_data/MNE-sample-data' # Maja
# mne_dir = mne.get_config('MNE_DATASETS_SAMPLE_PATH') # Alex
# data_path = mne_dir + '/MNE-sample-data'
subjects_dir = os.path.join(data_path, 'subjects')
hemi = 'both'
brain = Brain(subject_name,
hemi,
'inflated',
subjects_dir=subjects_dir,
cortex='low_contrast',
background='white')
for parcel in labels_pred:
brain.add_label(parcel, alpha=1, color=colors['pred'])
for parcel in labels_true:
brain.add_label(parcel, alpha=1, color=colors['true'])
for parcel in set(labels_pred) & set(labels_true):
brain.add_label(parcel, alpha=1, color=colors['overlap'])
import pdb
pdb.set_trace()
def plot_distance(subject, data_dir, parcels, parcel_name='1-lh'):
print('displaying brain of subject {}, distances from label {}'.format(
subject, parcel_name))
data_path = 'mne_data/MNE-sample-data' # Maja
subjects_dir = os.path.join(data_path, 'subjects')
hemi = 'both'
brain = Brain(subject,
hemi,
'inflated',
subjects_dir=subjects_dir,
cortex='low_contrast',
background='white')
dist_path_lh = os.path.join(data_dir, subject + '_dist_matrix_lh.csv')
dist_matrix_lh = pd.read_csv(dist_path_lh, index_col=0)
dist_matrix_lh_norm = dist_matrix_lh.divide(dist_matrix_lh.max().max())
if 'lh' in parcel_name:
hemi = 'lh'
elif 'rh' in parcel_name:
hemi = 'rh'
for parcel in parcels:
if parcel_name == parcel.name:
brain.add_label(parcel, alpha=1, color='blue')
elif hemi in parcel.name:
dist = dist_matrix_lh_norm.loc[parcel_name][parcel.name]
brain.add_label(parcel, alpha=1, color=str(1 - dist))
import pdb
pdb.set_trace()
cm = parcel.center_of_mass(subject, subjects_dir=subjects_dir)
brain.add_foci(cm, coords_as_verts=True, hemi='lh', color='blue')
def montage_plot(parameter, in_dir, task, fdr_correct=True, hemi='lh', input_hemisphere='', annot=None):
'''
Make plots for parameter on the cortical surface using pysurf module
- Arguments:
a) parameter
b) output directory
c) task (inference or instructed)
d) FDR correction (boolean)
'''
out_dir = join(in_dir, 'pysurf_plots')
slu.mkdir_p(out_dir)
fsaverage = "fsaverage"
surf = "inflated"
t_data, p_data, str_names, labels = get_data(task, in_dir, input_hemisphere, hemi)
if fdr_correct is True:
data = fdr_filter(t_data, p_data, parameter)
else:
data = t_data[parameter].values
data = data[labels]
brain = Brain(fsaverage, hemi, surf,
background="white", title=parameter + task)
brain.add_data(data, -10, 10, thresh=None, colormap="RdBu_r", alpha=.8)
if annot is not None:
brain.add_annotation(annot, color='white', alpha=1)
brain.save_imageset(join(out_dir, parameter + '_' + task + input_hemisphere),
['lateral', 'medial', 'par'], colorbar=None)
def test_animate():
"""Test animation."""
_set_backend('auto')
brain = Brain(*std_args, size=100)
brain.add_morphometry('curv')
tmp_name = mktemp() + '.avi'
brain.animate(["m"] * 3, n_steps=2)
brain.animate(['l', 'l'], n_steps=2, fname=tmp_name)
# can't rotate in axial plane
assert_raises(ValueError, brain.animate, ['l', 'd'])
brain.close()
def test_data():
"""Test plotting of data."""
_set_backend()
brain = Brain(*std_args)
mri_file = pjoin(data_dir, 'resting_corr.nii.gz')
reg_file = pjoin(data_dir, 'register.dat')
surf_data = io.project_volume_data(mri_file, "lh", reg_file)
brain.add_data(surf_data, -.7, .7, colormap="jet", alpha=.7)
brain.set_surf('white')
brain.add_data([], vertices=np.array([], int))
brain.close()
def test_animate(tmpdir):
"""Test animation."""
_set_backend('auto')
brain = Brain(*std_args, size=100)
brain.add_morphometry('curv')
tmp_name = str(tmpdir.join('test.avi'))
brain.animate(["m"] * 3, n_steps=2)
brain.animate(['l', 'l'], n_steps=2, fname=tmp_name)
# can't rotate in axial plane
pytest.raises(ValueError, brain.animate, ['l', 'd'])
brain.close()
def load_fmri(subject, input_file, hemi='both'):
brain = Brain(subject, hemi, "pial", curv=False)
brain.toggle_toolbars(True)
if hemi == 'both':
for hemi in ['rh', 'lh']:
brain.add_overlay(input_file.format(hemi), hemi=hemi)
else:
brain.add_overlay(input_file.format(hemi), hemi=hemi)
def montage_plot(parameter, fdr_correct=True):
fsaverage = "fsaverage"
hemi = "lh"
surf = "inflated"
t_data, p_data, str_names, labels = get_data()
if fdr_correct is True:
data = fdr_filter(t_data, p_data, parameter)
else:
data = t_data[parameter].values
data = data[labels]
brain = Brain(fsaverage, hemi, surf, background="white")
brain.add_data(data, -10, 10, thresh=None, colormap="RdBu_r", alpha=.8)
montage = brain.save_montage(
None, [['lateral', 'parietal'], ['medial', 'frontal']],
border_size=0,
colorbar=None)
fig, a = plt.subplots(figsize=(24, 24))
im = plt.imshow(montage, cmap='RdBu_r')
a.set(xticks=[], yticks=[])
sns.despine(bottom=True, left=True)
cbar = fig.colorbar(im,
ticks=[montage.min(), (montage.min() + 255) / 2, 255],
orientation='horizontal',
drawedges=False)
cbar.ax.set_xticklabels(['-10', '0', '10'])
plt.rcParams['pdf.fonttype'] = 3
plt.rcParams['ps.fonttype'] = 3
sns.set(style='ticks',
font_scale=1,
rc={
'axes.labelsize': 6,
'axes.titlesize': 40,
'xtick.labelsize': 40,
'ytick.labelsize': 5,
'legend.fontsize': 250,
'axes.linewidth': 0.25,
'xtick.major.width': 0.25,
'ytick.major.width': 0.25,
'ytick.major.width': 0.25,
'ytick.major.width': 0.25,
'ytick.major.pad': 2.0,
'ytick.minor.pad': 2.0,
'xtick.major.pad': 2.0,
'xtick.minor.pad': 2.0,
'axes.labelpad': 4.0,
})
a.set_title(parameter)
return fig
def curvature_normalization(data_dir, subj):
"""Normalize the curvature map and plot contour over fsaverage."""
surf_dir = op.join(data_dir, subj, "surf")
snap_dir = op.join(data_dir, subj, "snapshots")
panels = []
for hemi in ["lh", "rh"]:
# Load the curv values and apply registration to fsaverage
curv_fname = op.join(surf_dir, "{}.curv".format(hemi))
curv_vals = nib.freesurfer.read_morph_data(curv_fname)
subj_curv_vals = apply_surface_warp(data_dir, subj,
hemi, curv_vals)
subj_curv_binary = (subj_curv_vals > 0)
# Load the template curvature
norm_fname = op.join(data_dir, "fsaverage", "surf",
"{}.curv".format(hemi))
norm_curv_vals = nib.freesurfer.read_morph_data(norm_fname)
norm_curv_binary = (norm_curv_vals > 0)
# Compute the curvature overlap image
curv_overlap = np.zeros_like(norm_curv_binary, np.int)
curv_overlap[norm_curv_binary & subj_curv_binary] = 1
curv_overlap[norm_curv_binary ^ subj_curv_binary] = 2
# Mask out the medial wall
cortex_fname = op.join(data_dir, "fsaverage", "label",
"{}.cortex.label".format(hemi))
cortex = nib.freesurfer.read_label(cortex_fname)
medial_wall = ~np.in1d(np.arange(curv_overlap.size), cortex)
curv_overlap[medial_wall] = 1
# Plot the curvature overlap image
try:
b = Brain("fsaverage", hemi, "inflated", background="white")
except TypeError:
# PySurfer <= 0.5
b = Brain("fsaverage", hemi, "inflated",
config_opts=dict(background="white"))
b.add_data(curv_overlap, min=0, max=2,
colormap=[".9", ".45", "indianred"], colorbar=False)
for view in ["lat", "med", "ven"]:
b.show_view(view, distance="auto")
panels.append(crop(b.screenshot()))
b.close()
# Make and save a figure
f = multi_panel_brain_figure(panels)
fname = op.join(snap_dir, "surface_registration.png")
f.savefig(fname, bbox_inches="tight")
plt.close(f)
def test_animate():
"""Test animation
"""
mlab.options.backend = 'auto'
brain = Brain(*std_args, config_opts=small_brain)
brain.add_morphometry('curv')
tmp_name = mktemp() + '.avi'
brain.animate(["m"] * 3, n_steps=2)
brain.animate(['l', 'l'], n_steps=2, fname=tmp_name)
# can't rotate in axial plane
assert_raises(ValueError, brain.animate, ['l', 'd'])
brain.close()
def display_matrices(filenames, target, hemi, surface):
from mayavi import mlab
from surfer import Brain
print '\n'.join(filenames)
for name in filenames:
try:
corrmat = sio.loadmat(name)['corrmat']
except:
try:
corrmat = np.load(name)['corrmat']
except:
try:
corrmat = np.load(name)['arr_0']
except:
try:
corrmat = np.load(name)['avgcorr']
except:
h5file = openFile(name, 'r')
corrmat = h5file.root.corrmat
corrmats.append(corrmat)
for idx, name in enumerate(filenames):
path, name = os.path.split(name)
br = Brain(target, hemi, surface, title=name + '-%d' % idx)
brains.append(br)
for brain in brains[:-1]:
mlab.sync_camera(br._f, brain._f)
mlab.sync_camera(brain._f, br._f)
br._f.on_mouse_pick(picker_callback)
mlab.show()
def translate_electrodes_onto_the_brain_surface(subject_name, subjects_dir,
elec_sorted):
#find brain surface points
brain = Brain(subject_id=subject_name,
subjects_dir=subjects_dir,
surf='pial',
hemi='lh',
offscreen=True)
surf = brain.geo['lh']
src = np.array([surf.x, surf.y, surf.z]).T
#use ConvexHull to chek if a point is inside the brain or not
elec_up = np.zeros([64, 3])
hull = ConvexHull(src)
for i, e in enumerate(elec_sorted):
a = 1
n = deepcopy(e)
while a == 1:
new_hull = ConvexHull(np.concatenate((hull.points, [e])))
if np.array_equal(new_hull.vertices, hull.vertices):
a = 1
e += n * 0.01
else:
a = 0
elec_up[i] = e
return elec_up
def corr_image(resting_image,fwhm):
"""This function makes correlation image on brain surface"""
import numpy as np
import nibabel as nb
import matplotlib.pyplot as plt
from surfer import Brain, Surface
import os
img = nb.load(resting_image)
corrmat = np.corrcoef(np.squeeze(img.get_data()))
corrmat[np.isnan(corrmat)] = 0
corrmat_npz = os.path.abspath('corrmat.npz')
np.savez(corrmat_npz,corrmat=corrmat)
br = Brain('fsaverage5', 'lh', 'smoothwm')
#br.add_overlay(corrmat[0,:], min=0.2, name=0, visible=True)
lh_aparc_annot_file = os.path.join(os.environ["FREESURFER_HOME"],'/subjects/label/lh.aparc.annot')
values = nb.freesurfer.read_annot(lh_aparc_annot_file)
#br.add_overlay(np.mean(corrmat[values[0]==5,:], axis=0), min=0.8, name='mean', visible=True)
data = img.get_data()
data = np.squeeze(img.get_data())
#
precuneus_signal = np.mean(data[values[0]==np.nonzero(np.array(values[2])=='precuneus')[0][0],:], axis=0)
precuneus = np.corrcoef(precuneus_signal, data)
#precuneus.shape
#br.add_overlay(precuneus[0,1:], min=0.3, sign='pos', name='mean', visible=True)
br.add_overlay(precuneus[0,1:], min=0.2, name='mean')#, visible=True)
#br.add_overlay(precuneus[0,1:], min=0.2, name='mean')#, visible=True)
plt.hist(precuneus[0,1:], 128)
plt.savefig(os.path.abspath("histogram.png"))
plt.close()
corr_image = os.path.abspath("corr_image%s.png"%fwhm)
br.save_montage(corr_image)
ims = br.save_imageset(prefix=os.path.abspath('fwhm_%s'%str(fwhm)),views=['medial','lateral','caudal','rostral','dorsal','ventral'])
br.close()
print ims
#precuneus[np.isnan(precuneus)] = 0
#plt.hist(precuneus[0,1:])
roitable = [['Region','Mean Correlation']]
for i, roi in enumerate(np.unique(values[2])):
roitable.append([roi,np.mean(precuneus[values[0]==np.nonzero(np.array(values[2])==roi)[0][0]])])
#images = [corr_fimage]+ims+[os.path.abspath("histogram.png"), roitable]
roitable=[roitable]
histogram = os.path.abspath("histogram.png")
return corr_image, ims, roitable, histogram, corrmat_npz
def make_pysurfer_images_lh_rh(folder,suffix='cope1',hemi='lh',threshold=0.9499,coords=(),surface='inflated',fwhm=0,filename='',saveFolder=[],vmax=5.0,bsize=5):
from surfer import Brain, io
TFCEposImg,posImg,TFCEnegImg,negImg=getFileNamesfromFolder(folder,suffix)
pos=image.math_img("np.multiply(img1,img2)",
img1=image.threshold_img(TFCEposImg,threshold=threshold),img2=posImg)
neg=image.math_img("np.multiply(img1,img2)",
img1=image.threshold_img(TFCEnegImg,threshold=threshold),img2=negImg)
fw=image.math_img("img1-img2",img1=pos,img2=neg)
if fwhm==0:
smin=np.min(np.abs(fw.get_data()[fw.get_data()!=0]))
else:
smin=2
mri_file = "%s/thresholded_posneg.nii.gz" % folder
fw.to_filename(mri_file)
"""Bring up the visualization"""
brain = Brain("fsaverage",hemi,surface, offscreen=True , background="white")
"""Project the volume file and return as an array"""
reg_file = os.path.join("/opt/freesurfer","average/mni152.register.dat")
surf_data = io.project_volume_data(mri_file, hemi, reg_file,smooth_fwhm=fwhm)
# surf_data_rh = io.project_volume_data(mri_file, "rh", reg_file,smooth_fwhm=fwhm)
"""
You can pass this array to the add_overlay method for a typical activation
overlay (with thresholding, etc.).
"""
brain.add_overlay(surf_data, min=smin, max=vmax, name="activation", hemi=hemi)
# brain.overlays["activation"]
# brain.add_overlay(surf_data_rh, min=smin, max=5, name="ang_corr_rh", hemi='rh')
if len(coords)>0:
if coords[0]>0:
hemi2='rh'
else:
hemi2='lh'
brain.add_foci(coords, map_surface="pial", color="gold",hemi=hemi2)
if len(saveFolder)>0:
folder=saveFolder
image_out=brain.save_montage('%s/%s-%s.png' % (folder,hemi,filename),order=['l','m'],orientation='h',border_size=bsize,colorbar=None)
else:
image_out=brain.save_image('%s/surfaceplot.jpg' % folder)
brain.close()
return image_out
def test_foci():
"""Test plotting of foci
"""
mlab.options.backend = 'test'
brain = Brain(*std_args)
coords = [[-36, 18, -3],
[-43, 25, 24],
[-48, 26, -2]]
brain.add_foci(coords, map_surface="white", color="gold")
annot_path = pjoin(subj_dir, subject_id, 'label', 'lh.aparc.a2009s.annot')
ids, ctab, names = nib.freesurfer.read_annot(annot_path)
verts = np.arange(0, len(ids))
coords = np.random.permutation(verts[ids == 74])[:10]
scale_factor = 0.7
brain.add_foci(coords, coords_as_verts=True,
scale_factor=scale_factor, color="#A52A2A")
def plot_surface(vtx_data, subject_id, subjects_dir, hemi, surface, output_dir, prefix, l, u, cmap, center, thresh):
# Open up a brain in pysurfer
brain = Brain(
subject_id,
hemi,
surface,
subjects_dir=subjects_dir,
config_opts=dict(background="white", height=665, width=800),
)
if center:
# Make sure the colorbar is centered
if l ** 2 < u ** 2:
l = u * -1
else:
u = l * -1
# Create an empty brain if the values are all below threshold
if np.max(vtx_data) < thresh:
# Add your data to the brain
brain.add_data(vtx_data * 0, l, u, thresh=thresh, colormap=cmap, alpha=0.0)
# Otherwise, add the data appropriately!
else:
# Add your data to the brain
brain.add_data(vtx_data, l, u, thresh=thresh, colormap=cmap, alpha=0.8)
# Save the images for medial and lateral
# putting a color bar on all of them
brain.save_imageset(prefix=os.path.join(output_dir, prefix), views=views_list, colorbar=range(len(views_list)))
def plot_parcel(num_nodes=600,numbers=[1],hemi='lh'):
from surfer import Brain, io
for n in numbers:
brain = Brain("fsaverage", "%s" %(hemi), "pial",config_opts=dict(background="white"))
image = io.project_volume_data('/home/despo/mb3152/random_nodes/%s/parcel_%s.nii'%(num_nodes,n),hemi, subject_id="fsaverage", projsum = 'max', smooth_fwhm = 0)
brain.add_data(image,thresh=1,colormap = "spectral")
brain.save_imageset('/home/despo/mb3152/random_nodes/%s/parcel_%s' %(num_nodes,n),['med','lat'],'jpg',colorbar= None)
brain.close()
def inflated_surfaces(out_dir, subj, close=True):
"""Native inflated surfaces with cortical label."""
for hemi in ["lh", "rh"]:
b = Brain(subj, hemi, "inflated", curv=False,
config_opts=dict(background="white",
width=800, height=500))
b.add_label("cortex", color="#6B6B6B")
for view in ["lat", "med"]:
b.show_view(view)
mlab.view(distance=400)
png = op.join(out_dir, "%s.surface_%s.png" % (hemi, view))
b.save_image(png)
if close:
b.close()
