def _plt_src(name, kw_brain_obj, active_data, active_vert, sources,
kw_source_obj, kw_activation, show):
# Define a brain object and a source object :
logger.info(' Define a Brain and Source objects')
from visbrain.objects import BrainObj, SourceObj, SceneObj
brain_obj, source_obj = name + '_brain', name + '_sources'
b_obj = BrainObj(brain_obj, **kw_brain_obj)
s_obj = SourceObj(source_obj, sources, **kw_source_obj)
s_obj.visible_obj = False
# Add data to the BrainObj if needed :
if isinstance(active_data, np.ndarray):
logger.info(" Add active data between "
"[%2f, %2f]" % (active_data.min(), active_data.max()))
b_obj.add_activation(data=active_data, vertices=active_vert,
**kw_activation)
# Return either a scene or a BrainObj and SourceObj :
if show is True: # Display inside the Brain GUI
# Define a Brain instance :
from visbrain.gui import Brain
brain = Brain(brain_obj=b_obj, source_obj=s_obj)
brain._brain_template.setEnabled(False)
# By default, display colorbar if activation :
if isinstance(active_data, np.ndarray):
brain.menuDispCbar.setChecked(True)
brain._fcn_menu_disp_cbar()
brain.show()
elif show is 'scene': # return a SceneObj
logger.info(" Define a unique scene for the Brain and Source "
"objects")
sc = SceneObj()
sc.add_to_subplot(s_obj)
sc.add_to_subplot(b_obj, use_this_cam=True)
return sc
else: # return the BrainObj and SourceObj
s_obj.visible_obj = True
return b_obj, s_obj
software (https://github.com/nipy/PySurfer/). Parcellation file comes from
MNE-Python (https://github.com/mne-tools/mne-python).
"""
import numpy as np
from visbrain.objects import BrainObj, ColorbarObj, SceneObj, SourceObj
from visbrain.io import download_file, read_stc
###############################################################################
# Scene creation
###############################################################################
# The SceneObj is Matplotlib subplot like in which, you can add visbrain's
# objects. We first create the scene with a black background, a fixed size
# Scene creation
sc = SceneObj(bgcolor='black', size=(1400, 1000))
# Colorbar default arguments. See `visbrain.objects.ColorbarObj`
CBAR_STATE = dict(cbtxtsz=12, txtsz=10., width=.1, cbtxtsh=3.,
rect=(-.3, -2., 1., 4.))
KW = dict(title_size=14., zoom=1.2)
###############################################################################
# .. note::
# The BrainObj can interact with sources (SourceObj). For example, if the
# source object represent intracranial data (e.g iEEG) those sources can
# be projected on the surface of the brain. This is an important feature
# because intracranial implantations is usually subject dependant and the
# projection is a good way to plot results across subjects. To illustrate
# this feature, we provide a set of intracranial MNI coordinates.
# Download iEEG coordinates and define some random data
#
# .. warning:: To use this pipeline, we need a cortical segmentation of MRI
# data, that could be provided by Freesurfer
##############################################################################
import pickle # noqa
from ephypype.gather.gather_results import get_results # noqa
from visbrain.objects import BrainObj, ColorbarObj, SceneObj # noqa
time_series_files, label_files = get_results(main_workflow.base_dir,
main_workflow.name,
pipeline='inverse')
time_pts = 30
sc = SceneObj(size=(800, 500), bgcolor=(0, 0, 0))
lh_file = op.join(subjects_dir, 'fsaverage', 'label/lh.aparc.annot')
rh_file = op.join(subjects_dir, 'fsaverage', 'label/rh.aparc.annot')
cmap = 'bwr'
txtcolor = 'white'
for inverse_file, label_file in zip(time_series_files, label_files):
# Load files :
with open(label_file, 'rb') as f:
ar = pickle.load(f)
names, xyz, colors = ar['ROI_names'], ar['ROI_coords'], ar[
'ROI_colors'] # noqa
ts = np.squeeze(np.load(inverse_file))
cen = np.array([k.mean(0) for k in xyz])
# Get the data of the left / right hemisphere :
lh_data, rh_data = ts[::2, time_pts], ts[1::2, time_pts]
"""
Plot x3d files
==============
This example illustrate how to plot .x3d files. 6 brain templates are going to
be downloaded (total of 26.3Mo). Additional templates can be downloaded from :
https://scalablebrainatlas.incf.org
"""
from visbrain.objects import BrainObj, SceneObj
from visbrain.io import download_file
sc = SceneObj(size=(1500, 800))
###############################################################################
# Ferret brain
###############################################################################
# Hutchinson EB, Schwerin SC, Radomski KL, Sadeghi N, Jenkins J, Komlosh ME,
# Irfanoglu MO, Juliano SL, Pierpaoli C (2017) "Population based MRI and DTI
# templates of the adult ferret brain and tools for voxelwise analysis"
# Neuroimage 152:575–589. [doi 10.1016/j.neuroimage.2017.03.009]
ferret_file = download_file('ferret.x3d', astype='example_data')
b_ferret_obj = BrainObj(ferret_file, translucent=False)
sc.add_to_subplot(b_ferret_obj, title='Ferret brain (Hutchinson et al. 2017)')
###############################################################################
# Macaque brain (1)
###############################################################################
# Markov NT, Ercsey-Ravasz MM, Ribeiro Gomes AR, Lamy C, Magrou L, Vezoli J,
# Misery P, Falchier A, Quilodran R, Gariel MA, Sallet J, Gamanut R,
# Huissoud C, Clavagnier S, Giroud P, Sappey-Marinier D, Barone P, Dehay C,
# .. note:: The power pipeline in the **source space** is implemented by the
# function :func:`ephypype.pipelines.power.create_pipeline_power_src_space`
# and its Node :class:`ephypype.interfaces.mne.power.Power` compute the PSD
# by the welch function of the scipy package.
##############################################################################
from ephypype.gather import get_results # noqa
from visbrain.objects import SourceObj, SceneObj, ColorbarObj # noqa
from visbrain.utils import normalize # noqa
from nipype.utils.filemanip import split_filename # noqa
psd_files, channel_coo_files = get_results(main_workflow.base_dir,
main_workflow.name,
pipeline='power')
sc = SceneObj(size=(1800, 500), bgcolor=(.1, .1, .1))
for psd_file, channel_coo_file in zip(psd_files, channel_coo_files):
path_xyz, basename, ext = split_filename(psd_file)
arch = np.load(psd_file)
psds, freqs = arch['psds'], arch['freqs']
xyz = np.genfromtxt(channel_coo_file, dtype=float)
freq_bands = np.asarray(freq_bands)
clim = (psds.min(), psds.max())
# Find indices of frequencies :
idx_fplt = np.abs((freqs.reshape(1, 1, -1) -
freq_bands[..., np.newaxis])).argmin(2)
psdf = np.array([psds[:, k[0]:k[1]].mean(1) for k in idx_fplt])
radius = normalize(np.c_[psdf.min(1), psdf.max(1)], 5, 25).astype(float)
* RoiObj : source's activity and repartition can be projected on the
surface of region of interest. In addition, ROI objects can also be used
to get anatomical informations of sources
"""
import numpy as np
from visbrain.objects import SourceObj, SceneObj, ColorbarObj, BrainObj, RoiObj, ConnectObj
from visbrain.io import download_file
# Create the scene
CAM_STATE = dict(
azimuth=0, # azimuth angle
elevation=90, # elevation angle
scale_factor=180 # distance to the camera
)
sc = SceneObj(bgcolor='white', size=(1600, 1000))
b_obj = BrainObj('B3', translucent=False)
sc.add_to_subplot(b_obj)
sc.screenshot('plain_brain.png')
sc.preview()
###############################################################################
# .. warning::
# To be clear with the vocabulary used, the SourceObj has a different
# meaning depending on the recording type. For scalp or intracranial EEG,
# sources reflect electrode, in MEG it could be sensors or source
# reconstruction.
###############################################################################
# Download data
###############################################################################
###############################################################################
# The SceneObj is Matplotlib subplot like in which, you can add visbrain's
# objects. We first create the scene with a black background, a fixed size
# Download intracranial EEG electodes
mat = np.load(download_file('xyz_sample.npz', astype='example_data'))
xyz, subjects = mat['xyz'], mat['subjects']
n_sources = xyz.shape[0]
# Generate random data and random connectivity
data = np.random.uniform(low=-1., high=1., size=(n_sources,))
conn = np.triu(np.random.uniform(-1., 1., (n_sources, n_sources)))
conn_select = (-.005 < conn) & (conn < .005)
# Scene creation
sc = SceneObj()
###############################################################################
# Animate a single brain object
###############################################################################
# Here we set an animation for a single brain object.
b_obj_1 = BrainObj('inflated', translucent=False)
b_obj_1.animate()
sc.add_to_subplot(b_obj_1, rotate='left', title='Animate a single object')
###############################################################################
# Animate multiple objects
###############################################################################
# Here we animate multiple objects inside a subplot
# Get the path to Visbrain data and download deep sources
mat = np.load(download_file('xyz_sample.npz', astype='example_data'))
xyz, subjects = mat['xyz'], mat['subjects']
data = np.random.uniform(low=-1., high=1., size=(xyz.shape[0],))
###############################################################################
# Scene creation
###############################################################################
CAM_STATE = dict(azimuth=0, # azimuth angle
elevation=90, # elevation angle
)
CBAR_STATE = dict(cbtxtsz=12, txtsz=10., width=.1, cbtxtsh=3.,
rect=(-.3, -2., 1., 4.))
sc = SceneObj(camera_state=CAM_STATE, size=(1400, 1000))
###############################################################################
# fMRI activation
###############################################################################
file = download_file('lh.sig.nii.gz', astype='example_data')
b_obj_fmri = BrainObj('inflated', translucent=False, sulcus=True)
b_obj_fmri.add_activation(file=file, clim=(5., 20.), hide_under=5,
cmap='viridis', hemisphere='left')
sc.add_to_subplot(b_obj_fmri, row=0, col=0, row_span=2,
title='fMRI activation', rotate='top')
###############################################################################
# Region Of Interest (ROI)
###############################################################################
from tensorpac.utils import pac_signals_wavelet
from visbrain.objects import PacmapObj, SceneObj
"""Generate artificillly coupled signals :
- First coupling between 10hz phase with a 80hz amplitude
- Second coupling between 5hz phase with a 100hz amplitude
The final signal is the concatenation of both
"""
sf = 1024.
s_1 = pac_signals_wavelet(sf=sf, fpha=10., famp=80., ntrials=1, npts=5000)[0]
s_2 = pac_signals_wavelet(sf=sf, fpha=5., famp=100., ntrials=1, npts=5000)[0]
sig = np.c_[s_1, s_2]
sc = SceneObj(size=(1200, 600))
print("""
# =============================================================================
# Comodulogram
# =============================================================================
""")
pac_obj_como = PacmapObj('como', sig, sf=sf, f_pha=(2, 30, 1, .5),
f_amp=(60, 150, 10, 1), interpolation='bicubic')
sc.add_to_subplot(pac_obj_como, row=0, col=0, zoom=.9, title='Comodulogram')
print("""
# =============================================================================
# Optimal phase frequency
# =============================================================================
""")
"""
Load the xyz coordinates and corresponding subject name
"""
mat = np.load(download_file('xyz_sample.npz'))
xyz = mat['xyz']
n_sources = xyz.shape[0]
text = ['S' + str(k) for k in range(n_sources)]
"""Create a scene. By default, we fix the top view of the camera
"""
CAM_STATE = dict(azimuth=0, # azimuth angle
elevation=90, # elevation angle
scale_factor=180 # ~distance to the camera
)
CBAR_STATE = dict(cbtxtsz=12, txtsz=10., width=.5, rect=(1., -2., 1., 4.))
sc = SceneObj(camera_state=CAM_STATE, size=(1200, 1000))
"""Create the most basic source object
"""
s_obj_basic = SourceObj('Basic', xyz, text=text, text_bold=True,
text_color='yellow')
sc.add_to_subplot(s_obj_basic, row=0, col=0,
title='Default configuration with text')
"""Control the color and the symbol
"""
s_obj_col = SourceObj('S2', xyz, color='slategray', symbol='square')
sc.add_to_subplot(s_obj_col, row=0, col=1, title='Change color and symbol')
"""Mask sources that have a x coordinate between [-20, 20] and color it into
orange
def generate_img(l_file,
r_file,
activated_areas,
brain_name,
out_file,
views,
add_hemispheres,
is_estimate=False,
cmap='copper',
vmin=0.,
vmax=0.01,
save_gif=False):
"""Generate .png and .gif animation of rotating brains
"""
sc = SceneObj(size=(1000 * (len(views) // 2 +
(1 if add_hemispheres else 0)),
1000 * (len(views) > 1)),
bgcolor='black')
KW = dict(title_size=14., zoom=2.) # zoom not working
CBAR_STATE = dict(cbtxtsz=12,
txtsz=10.,
width=.1,
cbtxtsh=3.,
rect=(-.3, -2., 1., 4.))
# PLOT OBJECTS
for i, rot in enumerate(views):
# cannot use the same object
b_obj = create_brain_obj(l_file,
r_file,
activated_areas,
brain_name,
cmap=cmap,
vmin=vmin,
vmax=vmax)
sc.add_to_subplot(b_obj,
row=i // 2,
col=i % 2,
rotate=rot,
title=rot,
**KW)
# Get the colorbar of the brain object and add it to the scene
# Identical brain ==> same colorbar
if add_hemispheres:
# add left brain
b_obj = create_brain_obj(l_file,
r_file,
activated_areas,
brain_name,
hemisphere='right',
cmap=cmap,
vmin=vmin,
vmax=vmax)
sc.add_to_subplot(b_obj,
row=i // 2 + 1,
col=0,
rotate='left',
title='right half',
**KW)
b_obj = create_brain_obj(l_file,
r_file,
activated_areas,
brain_name,
hemisphere='left',
cmap=cmap,
vmin=vmin,
vmax=vmax)
sc.add_to_subplot(b_obj,
row=i // 2 + 1,
col=1,
rotate='right',
title='left half',
**KW)
if is_estimate:
# cmap needs to be set for all objects
cb_parr = ColorbarObj(b_obj,
cblabel='Data to parcellates',
**CBAR_STATE)
# not working properly and can't find a way to rotate that bar
# sc.add_to_subplot(cb_parr, row=0, col=2, row_span=i//2+1, width_max=200)
# gif and png
# sc.preview()
if save_gif:
sc.record_animation(out_file + ('_est' if is_estimate else '') +
"_areas.gif")
sc.screenshot(saveas=out_file + ('_est' if is_estimate else '') +
"_areas.png")
return sc.render()
"""
Plot x3d files
==============
This example illustrate how to plot .x3d files. 6 brain templates are going to
be downloaded (total of 26.3Mo). Additional templates can be downloaded from :
https://scalablebrainatlas.incf.org
"""
from visbrain.objects import BrainObj, SceneObj
from visbrain.io import download_file
sc = SceneObj(size=(1500, 800))
###############################################################################
# Ferret brain
###############################################################################
# Hutchinson EB, Schwerin SC, Radomski KL, Sadeghi N, Jenkins J, Komlosh ME,
# Irfanoglu MO, Juliano SL, Pierpaoli C (2017) "Population based MRI and DTI
# templates of the adult ferret brain and tools for voxelwise analysis"
# Neuroimage 152:575–589. [doi 10.1016/j.neuroimage.2017.03.009]
ferret_file = download_file('ferret.x3d', astype='example_data')
b_ferret_obj = BrainObj(ferret_file, translucent=False)
sc.add_to_subplot(b_ferret_obj, title='Ferret brain (Hutchinson et al. 2017)')
###############################################################################
# Macaque brain (1)
###############################################################################
import numpy as np
from visbrain.objects import ConnectObj, SceneObj, SourceObj, BrainObj
from visbrain.io import download_file
###############################################################################
# Download data and define the scene
###############################################################################
# First, we download a connectivity dataset consisting of the location of each
# node (104) and the connectivity strength between every node (104, 104)
# Download data
arch = np.load(download_file('phase_sync_delta.npz', astype='example_data'))
nodes, edges = arch['nodes'], arch['edges']
# Create the scene with a black background
sc = SceneObj(size=(1500, 600))
###############################################################################
# Color by connectivity strength
###############################################################################
# First, we download a connectivity dataset consisting of the location of each
# node (iEEG site) and the connectivity strength between those nodes. The first
# coloring method illustrated bellow consist in coloring connections based on
# a colormap
# Coloring method
color_by = 'strength'
# Because we don't want to plot every connections, we only keep connections
# above .7
select = edges > .7
# Define the connectivity object
data = np.random.uniform(low=-1., high=1., size=(xyz.shape[0], ))
###############################################################################
# Scene creation
###############################################################################
CAM_STATE = dict(
azimuth=0, # azimuth angle
elevation=90, # elevation angle
)
CBAR_STATE = dict(cbtxtsz=12,
txtsz=10.,
width=.1,
cbtxtsh=3.,
rect=(-.3, -2., 1., 4.))
sc = SceneObj(camera_state=CAM_STATE, size=(1400, 1000))
###############################################################################
# fMRI activation
###############################################################################
file = download_file('lh.sig.nii.gz', astype='example_data')
b_obj_fmri = BrainObj('inflated', translucent=False, sulcus=True)
b_obj_fmri.add_activation(file=file,
clim=(5., 20.),
hide_under=5,
cmap='viridis',
hemisphere='left')
sc.add_to_subplot(b_obj_fmri,
row=0,
col=0,
import numpy as np
from visbrain.objects import ConnectObj, SceneObj, SourceObj, BrainObj
from visbrain.io import download_file
###############################################################################
# Download data and define the scene
###############################################################################
# First, we download a connectivity dataset consisting of the location of each
# node (104) and the connectivity strength between every node (104, 104)
# Download data
arch = np.load(download_file('phase_sync_delta.npz', astype='example_data'))
nodes, edges = arch['nodes'], arch['edges']
# Create the scene with a black background
sc = SceneObj(size=(1500, 600))
###############################################################################
# Color by connectivity strength
###############################################################################
# First, we download a connectivity dataset consisting of the location of each
# node (iEEG site) and the connectivity strength between those nodes. The first
# coloring method illustrated bellow consist in coloring connections based on
# a colormap
# Coloring method
color_by = 'strength'
# Because we don't want to plot every connections, we only keep connections
# above .7
select = edges > .7
# Define the connectivity object
from itertools import product
import mne
from visbrain.objects import GridSignalsObj, SceneObj
from visbrain.utils import generate_eeg
###############################################################################
# Scene creation
###############################################################################
# The SceneObj is Matplotlib subplot like in which, you can add visbrain's
# objects. We first create the scene with a black background, a fixed size
# Scene creation
sc = SceneObj(bgcolor='black', size=(1400, 1000))
###############################################################################
# Generate random data
###############################################################################
# Here we generate a random 3D dataset with 5 channels and 4 trials per channel
# Note that here we geneate a 3D dataset but you can also pass a 1D or 2D
# dataset
sf = 512. # sampling frequency
n_pts = 1000 # number of time points
n_channels = 5 # number of channels
n_trials = 4 # number of trials
data_3d = generate_eeg(n_pts=n_pts, n_channels=n_channels, n_trials=n_trials,
f_max=20., smooth=200, noise=1000)[0]
channels = ['Channel %i' % (k + 1) for k in range(n_channels)]
print("""
# =============================================================================
# Default scene
# =============================================================================
""")
CAM_STATE = dict(
azimuth=0, # azimuth angle
elevation=90, # elevation angle
)
CBAR_STATE = dict(cbtxtsz=12,
txtsz=10.,
width=.1,
cbtxtsh=3.,
rect=(-.3, -2., 1., 4.))
sc = SceneObj(camera_state=CAM_STATE, bgcolor=(.1, .1, .1), size=(1400, 1000))
print("""
# =============================================================================
# Translucent inflated brain template
# =============================================================================
""")
b_obj_fs = BrainObj('inflated', translucent=True)
b_obj_fs.alpha = 0.03
sc.add_to_subplot(b_obj_fs,
row=0,
col=0,
row_span=2,
title='Translucent inflated brain template')
print("""
"""
Volume object (VolumeObj) : complete tutorial
=============================================
Illustration of the main functionalities and inputs of the volume object :
* Volume rendering methods (MIP, translucent, additive, Iso)
* Colormap choice
* Select volume levels
* Load an MRI (nii.gz) file
"""
from visbrain.objects import VolumeObj, SceneObj
from visbrain.io import download_file
# Define the scene
sc = SceneObj(size=(1000, 600))
###############################################################################
# MIP rendering
###############################################################################
# MIP rendering with an opaque fire colormap
v_obj_mip = VolumeObj('brodmann', method='mip', cmap='OpaqueFire')
sc.add_to_subplot(v_obj_mip, row=0, col=0, title='MIP rendering', zoom=.7)
###############################################################################
# Translucent rendering
###############################################################################
# Translucent rendering with a translucent fire colormap
v_obj_trans = VolumeObj('aal', method='translucent', cmap='TransFire')
# Plotting properties shared across topoplots and colorbar :
kw_top = dict(margin=15 / 100, chan_offset=(0., 0.1, 0.), chan_size=10)
kw_cbar = dict(cbtxtsz=12,
txtsz=10.,
width=.3,
txtcolor='black',
cbtxtsh=1.8,
rect=(0., -2., 1., 4.),
border=False)
###############################################################################
# Creation of the scene
###############################################################################
# Create a scene with a white background
sc = SceneObj(bgcolor='white', size=(1600, 900))
###############################################################################
# Topoplot based on channel names
###############################################################################
# First definition using channel names only
# Define some EEG channels and set one data value per channel
ch_names = ['C3', 'C4', 'Cz', 'Fz', 'Pz']
data_names = [10, 20, 30, 10, 10]
# Create the topoplot and the associated colorbar
t_obj = TopoObj('topo', data_names, channels=ch_names, **kw_top)
cb_obj = ColorbarObj(t_obj, cblabel='Colorbar label', **kw_cbar)
# Add both objects to the scene
# Add the topoplot and the colorbar to the scene :
sc.add_to_subplot(t_obj,
"""
Cross-section object
====================
Illustration and main functionalities and inputs of the cross-section object.
.. image:: ../../picture/picobjects/ex_cs_obj.png
"""
from visbrain.objects import CrossSecObj, SceneObj
from visbrain.io import download_file
sc = SceneObj()
print("""
# =============================================================================
# Brodmann area
# =============================================================================
""")
cs_brod = CrossSecObj('brodmann',
interpolation='nearest',
coords=(70., 80., 90.))
cs_brod.localize_source((-10., -15., 20.))
sc.add_to_subplot(cs_brod, row=0, col=0, title='Brodmann area')
print("""
# =============================================================================
# Nii.gz file
# =============================================================================
""")
path = download_file('GG-853-GM-0.7mm.nii.gz')
cs_cust = CrossSecObj(path, coords=(0., 0., 0.), cmap='gist_stern')
def create_scene ():
sc = SceneObj (size=(1400, 1000))
brain_objs = []
# CREATE 4 BRAIN OBJECTS EACH WITH SPECOFOC ROTATION
brain_objs = []
for rot in ["left", "right", 'side-fl', 'side-fr', 'front', 'back']:
brain_objs. append (BrainObj(name = 'inflated', hemisphere='both', translucent=False, cbtxtsz = 10., verbose = None))
sc.add_to_subplot(brain_objs[0], row=0, col=0, rotate='right', title='Right', zoom = 3.5)
sc.add_to_subplot(brain_objs[1], row=0, col=1, rotate='left', title='Left')
sc.add_to_subplot(brain_objs[2], row=1, col=0, rotate='top', title='Top')
sc.add_to_subplot(brain_objs[3], row=1, col=1, rotate='bottom', title='Bottom')
sc.add_to_subplot(brain_objs[4], row=2, col=0, rotate='front', title='Front')
sc.add_to_subplot(brain_objs[5], row=2, col=1, rotate='back', title='Back')
return sc, brain_objs
CBAR_STATE = dict(cbtxtsz=12,
clim=[0, 7],
txtsz=10.,
width=.1,
cbtxtsh=3.,
rect=(-.3, -2., 1., 4.))
KW = dict(title_size=14., zoom=1)
nii_bo_dir = '../../../data/niis/supplemental_3/networks'
fig_dir = '../../../paper/figs/source/supplemental_3/networks'
freqs = ['delta', 'theta', 'alpha', 'beta', 'lgamma', 'hgamma']
sc = SceneObj(bgcolor='white', size=(1000, 1000))
b_yeo = se.load(os.path.join(nii_bo_dir, 'yeo_bo_6mm.bo'))
data1 = b_yeo.get_data().values.ravel()
xyz1 = b_yeo.locs.values
s_obj_1 = SourceObj('iEEG', xyz1, data=data1, cmap=cmap)
s_obj_1.color_sources(data=data1)
b_obj_proj_left = BrainObj(template_brain,
hemisphere='left',
translucent=False)
b_obj_proj_left.project_sources(s_obj_1, clim=(1, 7), cmap=cmap)
sc.add_to_subplot(b_obj_proj_left,
row=0,
def add_objs_to_scene (sc, brain_objs):
sc = SceneObj (size=(1400, 1000))
sc.add_to_subplot(brain_objs[0], row=0, col=0, rotate='right', title='Right')
sc.add_to_subplot(brain_objs[1], row=0, col=1, rotate='left', title='Left')
sc.add_to_subplot(brain_objs[2], row=1, col=0, rotate='top', title='Top')
sc.add_to_subplot(brain_objs[3], row=1, col=1, rotate='bottom', title='Bottom')
sc.add_to_subplot(brain_objs[4], row=2, col=0, rotate='front', title='Front')
sc.add_to_subplot(brain_objs[5], row=2, col=1, rotate='back', title='Back')
return sc
import numpy as np
from visbrain.objects import BrainObj, ColorbarObj, SceneObj, SourceObj
from visbrain.utils import generate_eeg, convert_meshdata, vispy_array
from visbrain.config import CONFIG
from vispy.app import Timer
scene = SceneObj(bgcolor='white', size=(1400, 1000))
# Colorbar default arguments. See `visbrain.objects.ColorbarObj`
CBAR_STATE = dict(cbtxtsz=12,
txtsz=10.,
width=.1,
cbtxtsh=3.,
rect=(-.3, -2., 1., 4.))
KW = dict(title_size=14., zoom=2)
colormap = 'inferno'
# load brain model
verts = np.load('bnd4_pos1.npy')
faces = np.load('bnd4_tri1.npy')
verts *= 1000
verts, faces, normals = convert_meshdata(verts, faces, invert_normals=True)
# generate random toy data
Volume object (VolumeObj) : complete tutorial
=============================================
Illustration of the main functionalities and inputs of the volume object :
* Volume rendering methods (MIP, translucent, additive, Iso)
* Colormap choice
* Select volume levels
* Load an MRI (nii.gz) file
"""
from visbrain.objects import VolumeObj, SceneObj
from visbrain.io import download_file
# Define the scene
sc = SceneObj(size=(1000, 600))
###############################################################################
# MIP rendering
###############################################################################
# MIP rendering with an opaque fire colormap
v_obj_mip = VolumeObj('brodmann', method='mip', cmap='OpaqueFire')
sc.add_to_subplot(v_obj_mip, row=0, col=0, title='MIP rendering', zoom=.7)
###############################################################################
# Translucent rendering
###############################################################################
# Translucent rendering with a translucent fire colormap
v_obj_trans = VolumeObj('aal', method='translucent', cmap='TransFire')
###############################################################################
# Run workflow locally on 2 CPUs in parrallel
#main_workflow.run(plugin='MultiProc', plugin_args={'n_procs': 2})
###############################################################################
# plotting modules
from graphpype.utils_visbrain import visu_graph_modules # noqa
labels_file = op.join(data_path, "label_names.txt")
coords_file = op.join(data_path, "label_centroid.txt")
from visbrain.objects import SceneObj, BrainObj # noqa
sc = SceneObj(size=(1000, 1000), bgcolor=(1,1,1))
views = ["left",'top']
for i_v,view in enumerate(views):
for nf, freq_band_name in enumerate(freq_band_names):
res_path = op.join(
data_path, graph_analysis_name,
"graph_den_pipe_den_"+str(con_den).replace(".", "_"),
"_freq_band_name_"+freq_band_name+"_subject_id_sub-0003")
lol_file = op.join(res_path, "community_rada", "Z_List.lol")
net_file = op.join(res_path, "prep_rada", "Z_List.net")
b_obj = BrainObj("B1", translucent=True)
sc.add_to_subplot(b_obj, row=nf, col = i_v, use_this_cam=True,
from tensorpac.utils import pac_signals_wavelet
from visbrain.objects import PacmapObj, SceneObj
"""Generate artificillly coupled signals :
- First coupling between 10hz phase with a 80hz amplitude
- Second coupling between 5hz phase with a 100hz amplitude
The final signal is the concatenation of both
"""
sf = 1024.
s_1 = pac_signals_wavelet(sf=sf, fpha=10., famp=80., ntrials=1, npts=5000)[0]
s_2 = pac_signals_wavelet(sf=sf, fpha=5., famp=100., ntrials=1, npts=5000)[0]
sig = np.c_[s_1, s_2]
sc = SceneObj()
print("""
# =============================================================================
# Comodulogram
# =============================================================================
""")
pac_obj_como = PacmapObj('como',
sig,
sf=sf,
f_pha=(2, 30, 1, .5),
f_amp=(60, 150, 10, 1),
interpolation='bicubic')
sc.add_to_subplot(pac_obj_como, row=0, col=0, title='Comodulogram')
print("""
###############################################################################
# Finally, we are now ready to execute our workflow.
main_workflow.config['execution'] = {'remove_unnecessary_outputs': 'false'}
main_workflow.run()
# Run workflow locally on 2 CPUs
#main_workflow.run(plugin='MultiProc', plugin_args={'n_procs': 2})
################################################################################
## plotting
from graphpype.utils_visbrain import visu_graph_modules, visu_graph_modules_roles
from visbrain.objects import SceneObj, BrainObj # noqa
sc = SceneObj(size=(1000, 1000), bgcolor=(1, 1, 1))
res_path = op.join(data_path, conmat_analysis_name,
"graph_den_pipe_den_" + str(con_den).replace(".", "_"),
"_session_rest_subject_id_01")
lol_file = op.join(res_path, "community_rada", "Z_List.lol")
net_file = op.join(res_path, "prep_rada", "Z_List.net")
roles_file = op.join(res_path, "node_roles", "node_roles.txt")
views = ["left", 'top']
for i_v, view in enumerate(views):
b_obj = BrainObj("B1", translucent=True)
sc.add_to_subplot(b_obj,
# space.
# Define 5 sources
xyz = np.array([[0, .5, 0], [1, -4, 3], [10, 2, 8], [1, 7, 12], [-4, 5, 6]])
n_sources = xyz.shape[0]
# Define the time-series of those 5 sources
ts_data = generate_eeg(sf=512., n_channels=n_sources, noise=5., smooth=5)[0]
# Compute the spectrogram of the 5 time-series
pic_data = []
for k in range(n_sources):
pic_data += [spectrogram(ts_data[k, :], 512., nperseg=128, noverlap=10)[2]]
pic_data = np.asarray(pic_data)
clim = (.01 * pic_data.min(), .01 * pic_data.max())
# Scene definition
sc = SceneObj()
###############################################################################
# Basic plot
###############################################################################
# Basic plot without further customizations
# Define time-series and picture objects
ts_0 = TimeSeries3DObj('t0', ts_data, xyz, antialias=True)
pic_0 = Picture3DObj('p0', pic_data, xyz, clim=clim)
# Add those objects to the scene
sc.add_to_subplot(ts_0, row=0, col=0, zoom=.2, title='Basic 3D TS plot')
sc.add_to_subplot(pic_0, row=0, col=1, zoom=.5, title='Basic 3D pictures plot')
###############################################################################
# Subset selection
# space.
# Define 5 sources
xyz = np.array([[0, .5, 0], [1, -4, 3], [10, 2, 8], [1, 7, 12], [-4, 5, 6]])
n_sources = xyz.shape[0]
# Define the time-series of those 5 sources
ts_data = generate_eeg(sf=512., n_channels=n_sources, noise=5., smooth=5)[0]
# Compute the spectrogram of the 5 time-series
pic_data = []
for k in range(n_sources):
pic_data += [spectrogram(ts_data[k, :], 512., nperseg=128, noverlap=10)[2]]
pic_data = np.asarray(pic_data)
clim = (.01 * pic_data.min(), .01 * pic_data.max())
# Scene definition
sc = SceneObj()
###############################################################################
# Basic plot
###############################################################################
# Basic plot without further customizations
# Define time-series and picture objects
ts_0 = TimeSeries3DObj('t0', ts_data, xyz, antialias=True)
pic_0 = Picture3DObj('p0', pic_data, xyz, clim=clim)
# Add those objects to the scene
sc.add_to_subplot(ts_0, row=0, col=0, zoom=.2, title='Basic 3D TS plot')
sc.add_to_subplot(pic_0, row=0, col=1, zoom=.5, title='Basic 3D pictures plot')
###############################################################################
# Subset selection
def vis_brainSurface_by_padj(padj_parcellates,
gci_parcellates,
tt,
ptype='significant',
cmap='jet',
use_log=False,
use_1_p=False,
use_p=True):
# '''visualize the brain surface based on the FDR-adjusted GCI values or FDR-adjusted p values'''
# Define the default camera state used for each subplot
CAM_STATE = dict(
azimuth=0, # azimuth angle
elevation=90, # elevation angle
scale_factor=180 # distance to the camera
)
S_KW = dict(camera_state=CAM_STATE)
# Create the scene
CBAR_STATE = dict(cbtxtsz=12,
txtsz=13.,
width=.5,
cbtxtsh=2.,
rect=(1., -2., 1., 4.))
sc = SceneObj(bgcolor='black', size=(1300, 1000))
# n_sources = all_coord.shape[0] #sig_roi_coord.shape[0]
# data = np.random.rand(n_sources)
# 1. significant regions
b_obj_1 = BrainObj('white', translucent=False)
# parcellize brain based on desikan atlas
path_to_file1 = download_file('lh.aparc.annot', astype='example_data')
path_to_file2 = download_file('rh.aparc.annot', astype='example_data')
# dataframe type varaible inlcuding index, label, color for each brain region in DKT atlas
lh_df = b_obj_1.get_parcellates(path_to_file1)
rh_df = b_obj_1.get_parcellates(path_to_file2)
# lh_df.to_excel('output/lh.aparc.xlsx')
def select_rois(df, row=1, col=1):
select_val = list(np.array(df.iloc[row:, col]))
select_val.pop(3)
return select_val
select_roi1 = select_rois(lh_df)
select_roi2 = select_rois(rh_df)
# get log FDR-adjusted p values (optional)
# log_p_parce, l_p, s_p = get_log_pval(padj_parcellates, basis=2)
l_p = np.max(gci_parcellates)
s_p = np.min(gci_parcellates)
# print('-----#####',l_p,s_p)
if ptype == 'significant' or ptype == 'unsignificant':
def get_hemisphere_rois(lh_padj,
lh_gci,
lh_rois,
select='significant',
cal_log=True):
if select == 'significant':
lh_sig_ind = np.where(np.array(lh_padj) <= 0.05)[0]
else:
lh_sig_ind = np.where(np.array(lh_padj) > 0.05)[0]
lh_sig_rois = [lh_rois[i] for i in lh_sig_ind]
if cal_log:
log_p, _, _ = get_log_pval(lh_padj,
basis=2) # calculate "log2(padj)"
lh_sig_padj = list(np.array(log_p)[lh_sig_ind])
else:
# lh_sig_padj = list(np.array(lh_padj)[lh_sig_ind])
lh_sig_gci = list(np.array(lh_gci)[lh_sig_ind])
# max_p= np.max(np.array(lh_sig_padj))
# min_p= np.min(np.array(lh_sig_padj))
# return lh_sig_rois,lh_sig_padj,max_p,min_p
max_gci = np.max(np.array(lh_sig_gci))
min_gci = np.min(np.array(lh_sig_gci))
return lh_sig_rois, lh_sig_gci, max_gci, min_gci
# (1). set (log-padj) as values for color mapping
# select_regions_L,lh_padj,_,_ = get_hemisphere_rois(padj_parcellates[:34], gci_parcellates[:34], select_roi1, select = ptype, cal_log=use_log)
# select_regions_R,rh_padj,_,_ = get_hemisphere_rois(padj_parcellates[34:], gci_parcellates[34:], select_roi2, select = ptype, cal_log=use_log)
# clab = 'Log FDR-adjusted p value'
# b_obj_1.parcellize(path_to_file1, select= select_regions_L,data=lh_padj,cmap=cmap,clim=[s_p,l_p])
# b_obj_1.parcellize(path_to_file2, select= select_regions_R,data=rh_padj,cmap=cmap,clim=[s_p,l_p])
# cb_1 = ColorbarObj(b_obj_1, clim= [s_p,l_p], cblabel=clab, border=False, **CBAR_STATE)
# plot GCI value-4/23/2020
select_regions_L, lh_gci, _, _ = get_hemisphere_rois(
padj_parcellates[:34],
gci_parcellates[:34],
select_roi1,
select=ptype,
cal_log=use_log)
select_regions_R, rh_gci, _, _ = get_hemisphere_rois(
padj_parcellates[34:],
gci_parcellates[34:],
select_roi2,
select=ptype,
cal_log=use_log)
clab = 'GCI value'
b_obj_1.parcellize(path_to_file1, select=select_regions_L,
data=lh_gci) #clim=[s_p,l_p]
b_obj_1.parcellize(path_to_file2,
select=select_regions_R,
data=rh_gci,
cmap=cmap) #, clim=[s_p,l_p])
cb_1 = ColorbarObj(b_obj_1,
clim=[1.76, 1.80],
cblabel=clab,
border=False,
**CBAR_STATE)
elif ptype == 'together':
select_regions_L = select_roi1
select_regions_R = select_roi2
if use_log:
# (1). set (log-padj) as values for color mapping
clab = 'Log FDR-adjusted p value'
lh_padj = log_p_parce[:34]
rh_padj = log_p_parce[34:]
b_obj_1.parcellize(path_to_file1,
select=select_regions_L,
data=lh_padj,
cmap=cmap,
clim=[s_p, l_p])
b_obj_1.parcellize(path_to_file2,
select=select_regions_R,
data=rh_padj,
cmap=cmap,
clim=[s_p, l_p])
cb_1 = ColorbarObj(b_obj_1,
clim=[s_p, l_p],
cblabel=clab,
border=False,
**CBAR_STATE)
if use_1_p:
# (2). set (1-padj) as values for color mapping
clab = tt #'1-FDR-adjusted p value'
# clab = '1-FDR-adjusted p value'
padj_0 = [1 - i for i in padj_parcellates]
b_obj_1.parcellize(path_to_file1,
select=select_regions_L,
data=padj_0[:34],
cmap=cmap)
b_obj_1.parcellize(path_to_file2,
select=select_regions_R,
data=padj_0[34:],
cmap=cmap)
cb_1 = ColorbarObj(b_obj_1,
cblabel=clab,
border=False,
**CBAR_STATE) #Log FDR-adjusted p value
if use_p:
# (2). set (1-padj) as values for color mapping
print('--------use p-------')
clab = tt #'1-FDR-adjusted p value'
mx = np.array(gci_parcellates).max()
mi = np.array(gci_parcellates).min()
b_obj_1.parcellize(path_to_file1,
select=select_regions_L,
data=gci_parcellates[:34],
cmap=cmap,
clim=[mi, mx])
b_obj_1.parcellize(path_to_file2,
select=select_regions_R,
data=gci_parcellates[34:],
cmap=cmap,
clim=[mi, mx])
cb_1 = ColorbarObj(b_obj_1,
cblabel=clab,
border=False,
**CBAR_STATE) #Log FDR-adjusted p value
b_obj_1.animate(iterations=10, step=30, interval=1.2)
sc.add_to_subplot(b_obj_1, row=0, col=0, rotate='front')
sc.add_to_subplot(cb_1, row=0, col=1, width_max=90)
# sc.record_animation('output/%s_pvalue_projection.gif'%ptype, n_pic=10)
# sc.record_animation('output/pmci_degree.gif', n_pic=8)
sc.preview()
def plot_meg_connectome():
'''
Plot the MEG brain connectome for the master figure in MEG paper
'''
megdata = sio.loadmat('MEG_data_info/total_connecivtiy_coord_label.mat')
total_con = megdata['connectivity']
xyz = megdata['ROI_coords']
normal_con = total_con[:53]
smci_con = total_con[53:-28]
pmci_con = total_con[-28:]
edges = smci_con[8, :, :]
sc = SceneObj(bgcolor='black')
c_obj = ConnectObj('default',
xyz,
edges,
select=edges > .026,
line_width=3.,
dynamic=(0., 1.),
dynamic_orientation='center',
cmap='bwr',
color_by='strength')
s_obj = SourceObj('sources', xyz, color='red', radius_min=15.)
cb_obj = ColorbarObj(c_obj, cblabel='Edge strength')
sc.add_to_subplot(c_obj, title='MEG brain network')
sc.add_to_subplot(s_obj)
sc.add_to_subplot(BrainObj('B3'), use_this_cam=True)
sc.add_to_subplot(cb_obj, col=1, width_max=200)
sc.preview()
def vis_sources_by_pval(padj, all_coord, short_label):
'''
1. visualize the sources (brain regions) based on the FDR-adjusted p values
display both the source objects and the brain object
'''
# Define the default camera state used for each subplot
CAM_STATE = dict(
azimuth=0, # azimuth angle
elevation=90, # elevation angle
scale_factor=180 # distance to the camera
)
S_KW = dict(camera_state=CAM_STATE)
# Create the scene
CBAR_STATE = dict(cbtxtsz=12,
txtsz=13.,
width=.5,
cbtxtsh=2.,
rect=(1., -2., 1., 4.))
sc = SceneObj(bgcolor='black', size=(1600, 1000))
# mask = padj<=0.05 # significant regions with true label
data0, max_p, min_p = get_log_pval(padj)
b_obj = BrainObj('white', hemisphere='both', translucent=True)
b_obj.animate(iterations=10, step=30, interval=1)
s_obj = SourceObj(
's1',
all_coord, #all_coord,
# mask = mask,
# mask_color='white',
# mask_radius = 15,
color=padj * 100,
data=data0,
text=short_label,
text_size=10,
text_bold=True,
text_color='yellow',
symbol='disc',
visible=True,
radius_min=10,
radius_max=40,
alpha=0.65)
s_obj_1.set_visible_sources('left')
s_obj.color_sources(data=data0, cmap='jet', clim=(min_p, max_p))
cb_data = ColorbarObj(s_obj,
cblabel='Log FDR-adjusted p value',
border=False,
**CBAR_STATE)
sc.add_to_subplot(b_obj, row=0, col=0, rotate='front')
sc.add_to_subplot(s_obj, row=0, col=0)
sc.add_to_subplot(cb_data, row=0, col=1, width_max=90)
# recording animation and save it
sc.record_animation('output/animate_pvalue_projection.gif', n_pic=10)
sc.preview()
text = ['S' + str(k) for k in range(n_sources)]
###############################################################################
# Scene creation
###############################################################################
# As said in other tutorials, the scene is equivalent with Matplotlib subplots.
# So here, we define a scene that is going to centralize objects in subplots
# Define the default camera state used for each subplot
CAM_STATE = dict(azimuth=0, # azimuth angle
elevation=90, # elevation angle
scale_factor=180 # distance to the camera
)
S_KW = dict(camera_state=CAM_STATE)
# Create the scene
sc = SceneObj(size=(1600, 1000))
CBAR_STATE = dict(cbtxtsz=12, txtsz=10., width=.5, cbtxtsh=3.,
rect=(1., -2., 1., 4.))
###############################################################################
# Basic source object
###############################################################################
# The first example consist of only plotting the source, without any
# modifications of the inputs
# Create the source objects and add this object to the scene
s_obj_basic = SourceObj('Basic', xyz)
sc.add_to_subplot(s_obj_basic, row=0, col=0, title='Default configuration',
**S_KW)
###############################################################################
from ephypype.gather.gather_results import get_results # noqa
from ephypype.gather.gather_results import get_channel_files # noqa
from ephypype.aux_tools import _parse_string # noqa
from visbrain.objects import ConnectObj, SourceObj, SceneObj, ColorbarObj # noqa
thresh = .75
with_text = False
channel_coo_files, channel_name_files = get_channel_files(
main_workflow.base_dir, main_workflow.name)
connectivity_matrices, _ = get_results(main_workflow.base_dir,
main_workflow.name,
pipeline='connectivity')
sc = SceneObj(size=(1000, 1000), bgcolor=(.1, .1, .1))
for nf, (connect_file, channel_coo_file, channel_name_file) in \
enumerate(zip(connectivity_matrices, channel_coo_files,
channel_name_files)):
# Load files :
xyz = np.genfromtxt(channel_coo_file, dtype=float)
names = np.genfromtxt(channel_name_file, dtype=str)
connect = np.load(connect_file)
connect += connect.T
connect = np.ma.masked_array(connect, mask=connect < thresh)
names = names if with_text else None
radius = connect.sum(1)
clim = (thresh, connect.max())
# With text :
# Get the path to the ~/visbrain_data/example_data folder
vb_path = path_to_visbrain_data(folder='example_data')
# Download (x, y, z) coordinates of intracranial sources
mat = np.load(download_file('xyz_sample.npz', astype='example_data'))
xyz, subjects = mat['xyz'], mat['subjects']
data = np.random.uniform(low=-1., high=1., size=(xyz.shape[0],))
# Download the MIST parcellates
download_file('MIST_ROI.zip', unzip=True, astype='example_data')
###############################################################################
# Scene creation
###############################################################################
# First, we need to create the scene that will host objects
# Scene creation with a dark background and a custom size
sc = SceneObj(size=(1400, 1000))
# In this example, we also illustrate the use of the colorbar object. Hence, we
# centralize colorbar properties inside a dictionary
CBAR_STATE = dict(cbtxtsz=12, txtsz=10., width=.1, cbtxtsh=3.,
rect=(-.3, -2., 1., 4.))
###############################################################################
# Find the index of a region of interest
###############################################################################
# ROIs are defined with two variables : 1) a volume which contains integers
# and 2) a vector of labels which link every integer inside the volume with a
# label (for example, with the brodmann atlas, the index 4 refers to the label
# brodmann 4). Here, we illustrate how to find the index of a region of
# interest
#####################################
path = download_file('topoplot_data.npz', astype='example_data')
mat = np.load(path)
xy, data = mat['xyz'], mat['data']
channels = [str(k) for k in range(len(data))]
# Plotting properties shared across topoplots and colorbar :
kw_top = dict(margin=15 / 100, chan_offset=(0., 0.1, 0.), chan_size=10)
kw_cbar = dict(cbtxtsz=12, txtsz=10., width=.3, txtcolor='black', cbtxtsh=1.8,
rect=(0., -2., 1., 4.), border=False)
###############################################################################
# Creation of the scene
###############################################################################
# Create a scene with a white background
sc = SceneObj(bgcolor='white', size=(1600, 900))
###############################################################################
# Topoplot based on channel names
###############################################################################
# First definition using channel names only
# Define some EEG channels and set one data value per channel
ch_names = ['C3', 'C4', 'Cz', 'Fz', 'Pz']
data_names = [10, 20, 30, 10, 10]
# Create the topoplot and the associated colorbar
t_obj = TopoObj('topo', data_names, channels=ch_names, **kw_top)
cb_obj = ColorbarObj(t_obj, cblabel='Colorbar label', **kw_cbar)
# Add both objects to the scene
# Add the topoplot and the colorbar to the scene :
sc.add_to_subplot(t_obj, row=0, col=0, title='Definition using channel names',