def _plot_max_Value( self ):
X = self.X_hf[:, 0]
Y = self.Y_hf[:, 0]
Z = self.Z_hf[:, 0]
plot_col = getattr( self, self.plot_column )[:, 0]
scale = 1 / max( plot_col )
# if self.plot_column == 'n_tex':
# plot_col = where( plot_col < 0, 0, plot_col )
mlab.figure( figure = "SFB532Demo",
bgcolor = ( 1.0, 1.0, 1.0 ),
fgcolor = ( 0.0, 0.0, 0.0 ) )
mlab.points3d( X, Y, ( -1.0 ) * Z, plot_col,
# colormap = "gist_rainbow",
# colormap = "Reds",
colormap = "copper",
mode = "cube",
scale_factor = scale )
mlab.outline()
mlab.scalarbar( title = self.plot_column, orientation = 'vertical' )
mlab.show
def plot_XYZ():
mlab.points3d( X, Y, Z_wf,
error_Z_abs,
colormap = "YlOrBr",
mode = "cube",
scale_factor = 100. )
mlab.scalarbar( orientation = 'vertical' )
def plot_XYZ():
mlab.points3d( X, Y, Z,
error_t_rel,
# error_t_abs,
colormap = "YlOrBr",
mode = "cube",
scale_factor = 0.015 )
mlab.scalarbar( orientation = 'vertical' )
def plot_retino_image(mesh_path, name, tf=None, tex=None, curv=None, mask=None,
vmin=0, vmax=0):
"""Custom function to plot mesh in the case of retinotopic mapping
Parameters
----------
mesh_path: string, path of the mesh to plot
name: string, object identifier
tf: (4, 4) array
affine transformation that has to be applied to the mesh
tex: array of shape (mes.n_vertices),
texture to plot on the surface
curv: array of shape (mes.n_vertices),
curvature texture to plot on the surface
mask: array of shape (mes.n_vertices),
A mask for functional regions of interest
vmin, vmax: bounds for color clipping
"""
vertices, triangles = mesh_arrays(mesh_path)
af_coord = np.hstack((vertices, np.ones((vertices.shape[0], 1))))
if tf is not None:
af_coord = np.dot(af_coord, tf.T)
vertices = af_coord[:, :3]
x, y, z = vertices.T
# it is expected that the curvature takes values between 0 and 1
if curv is not None:
cmin = 2 * curv.min() - curv.max()
cmax = 2 * curv.max() - curv.min()
mlab.triangular_mesh(x, y, z, triangles, transparent=False, opacity=1.,
name=name, scalars=curv, colormap="bone",
vmin=cmin, vmax=cmax)
else:
mlab.triangular_mesh(x, y, z, triangles, transparent=False, opacity=1.,
name=name)
if tex is not None:
if mask is not None:
tex[mask == 0] = vmin - 1
func_mesh = mlab.pipeline.triangular_mesh_source(x, y, z,
triangles,
scalars=tex)
thresh = mlab.pipeline.threshold(func_mesh, low=vmin)
mlab.pipeline.surface(thresh, colormap="jet", vmin=vmin,
vmax=vmax, transparent=True,
opacity=.8)
mlab.scalarbar(thresh)
def getData(self, data_D, data_H, name):
"""
plot passed in data as a surface
"""
#plotting
fig = mlab.figure(size=(512, 512))
cl.enqueue_read_buffer(lbm.queue, data_D, data_H).wait()
# retrieve mid cell points from cell node data
Nx = lbm.X.size - 1
Ny = lbm.Y.size - 1
x = np.zeros((Nx))
y = np.zeros((Ny))
for i in range(1, lbm.X.size):
x[i - 1] = (lbm.X[i] - lbm.X[i - 1]) / 2.0 + lbm.X[i - 1]
for i in range(1, lbm.Y.size):
y[i - 1] = (lbm.Y[i] - lbm.Y[i - 1]) / 2.0 + lbm.Y[i - 1]
s = mlab.surf(x, y, data_H, warp_scale='auto', colormap="jet")
mlab.axes(s)
sb = mlab.scalarbar(s, title=name)
self.s = s
self.data_D = data_D
self.data_H = data_H
def show(self):
"""show Vm in a graph. Works for 1D projects only"""
if self.Vm.ndim == 2:
pylab.imshow(self.Vm,aspect='auto',cmap=cm.jet)
pylab.show()
elif self.Vm.ndim == 3:
s = mlab.surf(self.Vm[...,0])
raw_input("Press Enter to lauch the simulation...")
for i in range(self.Vm.shape[-1]):
s.mlab_source.scalars = self.Vm[...,i]
elif self.Vm.ndim == 4:
p = mlab.pipeline.scalar_field(self.Vm[...,0])
s = mlab.pipeline.image_plane_widget( p,
plane_orientation='x_axes',
slice_index=self.mdl.stimCoord[0],
vmin = self.Vm.min(),
vmax = self.Vm.max()
)
s2 = mlab.pipeline.image_plane_widget(p,
plane_orientation='y_axes',
slice_index=self.mdl.stimCoord[2],
vmin = self.Vm.min(),
vmax = self.Vm.max()
)
s3 = mlab.pipeline.image_plane_widget( p,
plane_orientation='z_axes',
slice_index=self.mdl.stimCoord[4],
vmin = self.Vm.min(),
vmax = self.Vm.max()
)
mlab.scalarbar(s,orientation='vertical',nb_labels=4,label_fmt='%.3f')
mlab.outline(color=(1,1,1))
raw_input("Press Enter to lauch the simulation...")
for i in range(self.Vm.shape[-1]):
p.mlab_source.scalars = self.Vm[...,i]
def add_data(self, array, min=None, max=None, colormap="blue-red"):
"""Display data from a numpy array on the surface.
Parameters
----------
array : numpy array
data array (nvtx vector)
min : float
min value in colormap (uses real min if None)
max : float
max value in colormap (uses real max if None)
colormap : str
name of Mayavi colormap to use
"""
from enthought.mayavi import mlab
self._f.scene.disable_render = True
view = mlab.view()
# Possibly remove old data
if hasattr(self, "data"):
self.data["surface"].remove()
self.data["colorbar"].remove()
if min is None:
min = array.min()
if max is None:
max = array.max()
# Set up the visualization pipeline
mesh = mlab.pipeline.triangular_mesh_source(self._geo.x,
self._geo.y,
self._geo.z,
self._geo.faces,
scalars=array)
surf = mlab.pipeline.surface(mesh, colormap=colormap,
vmin=min, vmax=max)
# Get the colorbar
bar = mlab.scalarbar(surf)
bar.scalar_bar_representation.position2 = .8, 0.09
# Fil in the data dict
self.data = dict(surface=surf, colorbar=bar)
mlab.view(*view)
self._f.scene.disable_render = False
def getData(self, data_D, data_H, name):
"""
plot passed in data as a surface
"""
#plotting
fig = mlab.figure(size=(512, 512))
mlab.view(90, 0)
cl.enqueue_read_buffer(lbm.queue, data_D, data_H).wait()
rgrid = tvtk.RectilinearGrid()
rgrid.cell_data.scalars = data_H.ravel()
rgrid.cell_data.scalars.name = 'scalars'
rgrid.dimensions = np.array((lbm.Ny + 1, lbm.Nx + 1, 1))
rgrid.x_coordinates = lbm.Y
rgrid.y_coordinates = lbm.X
rgrid.z_coordinates = np.array([0.0])
src = mlab.pipeline.add_dataset(rgrid)
s = mlab.pipeline.cell_to_point_data(src)
s = mlab.pipeline.surface(s)
sb = mlab.scalarbar(s, title=name)
#plot lines
if 1:
mlab.pipeline.surface(mlab.pipeline.extract_edges(src),
color=(0, 0, 0),
line_width=0.1,
opacity=0.05)
self.rgrid = rgrid
self.src = src
self.data_D = data_D
self.data_H = data_H
def __init__(self, scalar_data, geo, min, max, sign):
"""
"""
from enthought.mayavi import mlab
if scalar_data.min() >= 0:
sign = "pos"
elif scalar_data.max() <= 0:
sign = "neg"
self.sign = sign
# Get data with a range that will make sense for automatic thresholding
if sign == "neg":
range_data = np.abs(scalar_data[np.where(scalar_data < 0)])
elif sign == "pos":
range_data = scalar_data[np.where(scalar_data > 0)]
else:
range_data = np.abs(scalar_data)
if min is None:
try:
min = config.getfloat("overlay", "min_thresh")
except ValueError:
min_str = config.get("overlay", "min_thresh")
if min_str == "robust_min":
min = stats.scoreatpercentile(range_data, 2)
elif min_str == "actual_min":
min = range_data.min()
else:
min = 2.0
warn("The 'min_thresh' value in your config value must be "
"a float, 'robust_min', or 'actual_min', but it is %s. "
"I'm setting the overlay min to the config default of 2" % min)
if max is None:
try:
max = config.getfloat("overlay", "max_thresh")
except ValueError:
max_str = config.get("overlay", "max_thresh")
if max_str == "robust_max":
max = stats.scoreatpercentile(range_data, 98)
elif max_str == "actual_max":
max = range_data.max()
else:
max = stats.scoreatpercentile(range_data, 98)
warn("The 'max_thresh' value in your config value must be "
"a float, 'robust_min', or 'actual_min', but it is %s. "
"I'm setting the overlay min to the config default "
"of robust_max" % max)
# Clean up range_data since we don't need it and it might be big
del range_data
# Byte swap inplace; due to mayavi bug
mlab_data = scalar_data.copy()
if scalar_data.dtype.byteorder == '>':
mlab_data.byteswap(True)
if sign in ["abs", "pos"]:
pos_mesh = mlab.pipeline.triangular_mesh_source(geo.x,
geo.y,
geo.z,
geo.faces,
scalars=mlab_data)
# Figure out the correct threshold to avoid TraitErrors
# This seems like not the cleanest way to do this
pos_data = scalar_data[np.where(scalar_data > 0)]
try:
pos_max = pos_data.max()
except ValueError:
pos_max = 0
if pos_max < min:
thresh_low = pos_max
else:
thresh_low = min
pos_thresh = mlab.pipeline.threshold(pos_mesh, low=thresh_low)
pos_surf = mlab.pipeline.surface(pos_thresh, colormap="YlOrRd",
vmin=min, vmax=max)
pos_bar = mlab.scalarbar(pos_surf)
pos_bar.reverse_lut = True
self.pos = pos_surf
self.pos_bar = pos_bar
if sign in ["abs", "neg"]:
neg_mesh = mlab.pipeline.triangular_mesh_source(geo.x,
geo.y,
geo.z,
geo.faces,
scalars=mlab_data)
# Figure out the correct threshold to avoid TraitErrors
# This seems even less clean due to negative convolutedness
neg_data = scalar_data[np.where(scalar_data < 0)]
try:
neg_min = neg_data.min()
except ValueError:
neg_min = 0
if neg_min > -min:
thresh_up = neg_min
else:
thresh_up = -min
neg_thresh = mlab.pipeline.threshold(neg_mesh, up=thresh_up)
neg_surf = mlab.pipeline.surface(neg_thresh, colormap="PuBu",
vmin=-max, vmax=-min)
neg_bar = mlab.scalarbar(neg_surf)
self.neg = neg_surf
self.neg_bar = neg_bar
self.__format_colorbar()
def add_contour_overlay(self, filepath, min=None, max=None,
n_contours=7, line_width=1.5):
"""Add a topographic contour overlay.
Note: This visualization will look best when using the "low_contrast"
cortical curvature colorscheme.
Parameters
----------
filepath : str
path to the overlay file (must be readable by Nibabel, or .mgh)
min : float
threshold for overlay display
max : float
saturation point for overlay display
n_contours : int
number of contours to use in the display
line_width : float
width of contour lines
"""
from enthought.mayavi import mlab
# Read the scalar data
scalar_data = io.read_scalar_data(filepath)
#TODO find a better place for this; duplicates code in Overlay object
if min is None:
try:
min = config.getfloat("overlay", "min_thresh")
except ValueError:
min_str = config.get("overlay", "min_thresh")
if min_str == "robust_min":
min = stats.scoreatpercentile(scalar_data, 2)
elif min_str == "actual_min":
min = scalar_data.min()
else:
min = 2.0
warn("The 'min_thresh' value in your config value must be "
"a float, 'robust_min', or 'actual_min', but it is %s. "
"I'm setting the overlay min to the config default of 2" % min)
if max is None:
try:
max = config.getfloat("overlay", "max_thresh")
except ValueError:
max_str = config.get("overlay", "max_thresh")
if max_str == "robust_max":
max = stats.scoreatpercentile(scalar_data, 98)
elif max_str == "actual_max":
max = scalar_data.max()
else:
max = stats.scoreatpercentile(scalar_data, 98)
warn("The 'max_thresh' value in your config value must be "
"a float, 'robust_min', or 'actual_min', but it is %s. "
"I'm setting the overlay min to the config default "
"of robust_max" % max)
# Prep the viz
self._f.scene.disable_render = True
view = mlab.view()
# Maybe get rid of an old overlay
if hasattr(self, "contour"):
self.contour['surface'].remove()
self.contour['colorbar'].visible = False
# Deal with Mayavi bug
if scalar_data.dtype.byteorder == '>':
scalar_data.byteswap(True)
# Set up the pipeline
mesh = mlab.pipeline.triangular_mesh_source(self._geo.x, self._geo.y,
self._geo.z, self._geo.faces,
scalars=scalar_data)
thresh = mlab.pipeline.threshold(mesh, low=min)
surf = mlab.pipeline.contour_surface(thresh, contours=n_contours,
line_width=line_width)
# Set the colorbar and range correctly
bar = mlab.scalarbar(surf)
bar.data_range = min, max
bar.scalar_bar_representation.position2 = .8, 0.09
# Set up a dict attribute with pointers at important things
self.contour = dict(surface=surf, colorbar=bar)
# Show the new overlay
mlab.view(*view)
self._f.scene.disable_render = False
# Remove close connections
con_nodes = list()
con_val = list()
for i, j in zip(ii, jj):
if linalg.norm(sens_loc[i] - sens_loc[j]) > min_dist:
con_nodes.append((i, j))
con_val.append(con[i, j])
con_val = np.array(con_val)
# Show the connections as tubes between sensors
vmax = np.max(con_val)
vmin = np.min(con_val)
for val, nodes in zip(con_val, con_nodes):
x1, y1, z1 = sens_loc[nodes[0]]
x2, y2, z2 = sens_loc[nodes[1]]
mlab.plot3d([x1, x2], [y1, y2], [z1, z2], [val, val], vmin=vmin, vmax=vmax, tube_radius=0.002)
mlab.scalarbar(title="Phase Lag Index (PLI)", nb_labels=4)
# Add the sensor names for the connections shown
nodes_shown = list(set([n[0] for n in con_nodes] + [n[1] for n in con_nodes]))
for node in nodes_shown:
x, y, z = sens_loc[node]
mlab.text3d(x, y, z, raw.ch_names[picks[node]], scale=0.005, color=(0, 0, 0))
view = (-88.7, 40.8, 0.76, np.array([-3.9e-4, -8.5e-3, -1e-2]))
mlab.view(*view)
con_val = np.array(con_val)
# Show the connections as tubes between sensors
vmax = np.max(con_val)
vmin = np.min(con_val)
for val, nodes in zip(con_val, con_nodes):
x1, y1, z1 = sens_loc[nodes[0]]
x2, y2, z2 = sens_loc[nodes[1]]
points = mlab.plot3d([x1, x2], [y1, y2], [z1, z2], [val, val],
vmin=vmin,
vmax=vmax,
tube_radius=0.001,
colormap='RdBu')
points.module_manager.scalar_lut_manager.reverse_lut = True
mlab.scalarbar(title='Phase Lag Index (PLI)', nb_labels=4)
# Add the sensor names for the connections shown
nodes_shown = list(set([n[0] for n in con_nodes] + [n[1] for n in con_nodes]))
for node in nodes_shown:
x, y, z = sens_loc[node]
mlab.text3d(x,
y,
z,
raw.ch_names[picks[node]],
scale=0.005,
color=(0, 0, 0))
view = (-88.7, 40.8, 0.76, np.array([-3.9e-4, -8.5e-3, -1e-2]))
mlab.view(*view)
)
s2 = mlab.pipeline.image_plane_widget(p,
plane_orientation='y_axes',
slice_index=ymax,
vmin = -60,
vmax = 10
)
s3 = mlab.pipeline.image_plane_widget( p,
plane_orientation='z_axes',
slice_index=zmax,
vmin = -60,
vmax = 10
)
mlab.scalarbar(s,orientation='vertical',nb_labels=4,label_fmt='%.3f')
mlab.outline(color=(1,1,1))
filename = str('png/2F_%04d' % i) + '.png'
mlab.savefig(filename)
for i in range(int(tstep/round(max(t)/len(t))),len(t),int(tstep/round(max(t)/len(t)))) :
#
# The next four lines are just like MATLAB.
#
p.mlab_source.scalars = Y[...,i]
titl.text=str("Potential at time: %.0f ms."% t[i])
filename = str('png/2F_%04d' % i) + '.png'
mlab.savefig(filename)
if showbar:
pbar.update(i)
ouput_data_thickness = 'RFEM_file_export/output_data_thickness_' + n_shells_str + '_' + scalefactor_delta_h_str + '02.csv'
export_thickness_data( elem_no, X, Y, t, ouput_data_thickness )
# 4) plot midsurface and thickness in mayavi
#
print '*** plotting data - thickness***'
mlab.figure( figure = "elem_coords and thickness",
bgcolor = ( 1.0, 1.0, 1.0 ),
fgcolor = ( 0.0, 0.0, 0.0 ) )
mlab.points3d( X, Y, z_middle, t,
colormap = "YlOrBr",
mode = "cube",
scale_factor = 0.50 )
mlab.scalarbar( title = 'elem_coords and thickness', orientation = 'vertical' )
mlab.axes()
mlab.show()
#------------------------------------------------------------------
# MIDSURFACE
# get a csv file with the nodal coords of the shell elements
# in the order of the supplied csv coordinates (x,y)
# --> z_node in [m]
#------------------------------------------------------------------
print '\n'
print '*** CALCULATE MIDSURFACE *** '
# 1) read x,y coords from csv-file used to specify shell middle surface
# (NOTE: the midsurface coordinates are defined at the nodes)
tmdl.compute(tmax=10, stimCoord=stimCoord)
# mlab.contour3d(v[...,-1])
v = tmdl.Vm[..., 1:]
s = mlab.pipeline.image_plane_widget(
mlab.pipeline.scalar_field(v[..., -2]), plane_orientation="z_axes", slice_index=3, vmin=v.min(), vmax=v.max()
)
# s2 = mlab.pipeline.image_plane_widget(mlab.pipeline.scalar_field(v[...,-2]),
# plane_orientation='y_axes',
# slice_index=round(Ny*2./10)+1,
# vmin = v.min(),
# vmax = v.max()
# )
mlab.scalarbar(s, orientation="vertical", nb_labels=4, label_fmt="%.3f")
mlab.outline()
##pour animation
for i in range(v.shape[-1]):
s.mlab_source.scalars = v[..., i]
# s2.mlab_source.scalars = v[...,i]
# logY=open('save.npz','w')
# numpy.savez(logY,t=t,v=v)
# logY.close()
def sensor_connectivity_3d(raw, picks, con, idx, n_con=20, min_dist=0.05,
scale_factor=0.005, tube_radius=0.001):
""" Function to plot sensor connectivity showing strongest
connections(n_con) excluding sensors that are less than min_dist apart.
https://github.com/mne-tools/mne-python/blob/master/examples/connectivity/plot_sensor_connectivity.py
Parameters
----------
raw : Raw object
Instance of mne.io.Raw
picks : list
Picks to be included.
con : ndarray (n_channels, n_channels)
Connectivity matrix.
idx : list
List of indices of sensors of interest.
n_con : int
Number of connections of interest.
min_dist : float
Minimum distance between sensors allowed.
Note: Please modify scale factor and tube radius to appropriate sizes
if the plot looks scrambled.
"""
# Now, visualize the connectivity in 3D
try:
from enthought.mayavi import mlab
except:
from mayavi import mlab
mlab.figure(size=(600, 600), bgcolor=(0.5, 0.5, 0.5))
# Plot the sensor location
sens_loc = [raw.info['chs'][picks[i]]['loc'][:3] for i in idx]
sens_loc = np.array(sens_loc)
pts = mlab.points3d(sens_loc[:, 0], sens_loc[:, 1], sens_loc[:, 2],
color=(1, 1, 1), opacity=1, scale_factor=scale_factor)
# Get the strongest connections
threshold = np.sort(con, axis=None)[-n_con]
ii, jj = np.where(con >= threshold)
# Remove close connections
con_nodes = list()
con_val = list()
for i, j in zip(ii, jj):
if sci.linalg.norm(sens_loc[i] - sens_loc[j]) > min_dist:
con_nodes.append((i, j))
con_val.append(con[i, j])
con_val = np.array(con_val)
# Show the connections as tubes between sensors
vmax = np.max(con_val)
vmin = np.min(con_val)
for val, nodes in zip(con_val, con_nodes):
x1, y1, z1 = sens_loc[nodes[0]]
x2, y2, z2 = sens_loc[nodes[1]]
points = mlab.plot3d([x1, x2], [y1, y2], [z1, z2], [val, val],
vmin=vmin, vmax=vmax, tube_radius=tube_radius,
colormap='RdBu')
points.module_manager.scalar_lut_manager.reverse_lut = True
mlab.scalarbar(title='Phase Lag Index (PLI)', nb_labels=4)
# Add the sensor names for the connections shown
nodes_shown = list(set([n[0] for n in con_nodes] +
[n[1] for n in con_nodes]))
for node in nodes_shown:
x, y, z = sens_loc[node]
mlab.text3d(x, y, z, raw.ch_names[picks[node]], scale=0.005,
color=(0, 0, 0))
view = (-88.7, 40.8, 0.76, np.array([-3.9e-4, -8.5e-3, -1e-2]))
mlab.view(*view)
def __init__(self, subject_id, hemi, surf,
curv=True, title=None, config_opts={}):
"""Initialize a Brain object with Freesurfer-specific data.
Parameters
----------
subject_id : str
subject name in Freesurfer subjects dir
hemi : str
hemisphere id (ie 'lh' or 'rh')
surf : geometry name
freesurfer surface mesh name (ie 'white', 'inflated', etc.)
curv : boolean
if true, loads curv file and displays binary curvature
(default: True)
title : str
title for the mayavi figure
config_opts : dict
options to override visual options in config file
"""
from enthought.mayavi import mlab
# Set the identifying info
self.subject_id = subject_id
self.hemi = hemi
if self.hemi == 'lh':
self.viewdict = lh_viewdict
elif self.hemi == 'rh':
self.viewdict = rh_viewdict
self.surf = surf
# Initialize an mlab figure
bg_color_code, size = self.__get_scene_properties(config_opts)
if title is None:
title = subject_id
self._f = mlab.figure(title,
bgcolor=bg_color_code,
size=size)
mlab.clf()
self._f.scene.disable_render = True
# Initialize a Surface object as the geometry
self._geo = Surface(subject_id, hemi, surf)
# Load in the geometry and (maybe) curvature
self._geo.load_geometry()
if curv:
self._geo.load_curvature()
curv_data = self._geo.bin_curv
meshargs = dict(scalars=curv_data)
else:
curv_data = None
meshargs = dict()
# mlab pipeline mesh for geomtery
self._geo_mesh = mlab.pipeline.triangular_mesh_source(
self._geo.x, self._geo.y, self._geo.z,
self._geo.faces, **meshargs)
# mlab surface for the geometry
if curv:
colormap, vmin, vmax, reverse = self.__get_geo_colors(config_opts)
self._geo_surf = mlab.pipeline.surface(self._geo_mesh,
colormap=colormap, vmin=vmin, vmax=vmax)
if reverse:
curv_bar = mlab.scalarbar(self._geo_surf)
curv_bar.reverse_lut = True
curv_bar.visible = False
else:
self._geo_surf = mlab.pipeline.surface(self._geo_mesh,
color=(.5, .5, .5))
# Initialize the overlay and label dictionaries
self.overlays = dict()
self.labels = dict()
self.foci = dict()
# Bring up the lateral view
self.show_view(config.get("visual", "default_view"))
# Turn disable render off so that it displays
self._f.scene.disable_render = False
con_nodes.append((i, j))
con_val.append(con[i, j])
con_val = np.array(con_val)
# Show the connections as tubes between sensors
vmax = np.max(con_val)
vmin = np.min(con_val)
for val, nodes in zip(con_val, con_nodes):
x1, y1, z1 = sens_loc[nodes[0]]
x2, y2, z2 = sens_loc[nodes[1]]
points = mlab.plot3d([x1, x2], [y1, y2], [z1, z2], [val, val],
vmin=vmin, vmax=vmax, tube_radius=0.001,
colormap='RdBu')
points.module_manager.scalar_lut_manager.reverse_lut = True
mlab.scalarbar(title='Phase Lag Index (PLI)', nb_labels=4)
# Add the sensor names for the connections shown
nodes_shown = list(set([n[0] for n in con_nodes] +
[n[1] for n in con_nodes]))
for node in nodes_shown:
x, y, z = sens_loc[node]
mlab.text3d(x, y, z, raw.ch_names[picks[node]], scale=0.005,
color=(0, 0, 0))
view = (-88.7, 40.8, 0.76, np.array([-3.9e-4, -8.5e-3, -1e-2]))
mlab.view(*view)
def add_morphometry(self, measure, grayscale=False):
"""Add a morphometry overlay to the image.
Parameters
----------
measure : {'area' | 'curv' | 'jacobian_white' | 'sulc' | 'thickness'}
which measure to load
grayscale : bool
whether to load the overlay with a grayscale colormap
"""
from enthought.mayavi import mlab
# Find the source data
surf_dir = pjoin(os.environ['SUBJECTS_DIR'], self.subject_id, 'surf')
morph_file = pjoin(surf_dir, '.'.join([self.hemi, measure]))
if not os.path.exists(morph_file):
raise ValueError(
'Could not find %s in subject directory' % morph_file)
# Preset colormaps
cmap_dict = dict(area="pink",
curv="RdBu",
jacobian_white="pink",
sulc="RdBu",
thickness="pink")
self._f.scene.disable_render = True
# Maybe get rid of an old overlay
if hasattr(self, "morphometry"):
self.morphometry['surface'].remove()
self.morphometry['colorbar'].visible = False
# Save the inital view
view = mlab.view()
# Read in the morphometric data
morph_data = io.read_morph_data(morph_file)
# Get a cortex mask for robust range
self._geo.load_label("cortex")
ctx_idx = self._geo.labels["cortex"]
# Get the display range
if measure == "thickness":
min, max = 1, 4
else:
min, max = stats.describe(morph_data[ctx_idx])[1]
# Set up the Mayavi pipeline
if morph_data.dtype.byteorder == '>':
morph_data.byteswap(True) # byte swap inplace; due to mayavi bug
mesh = mlab.pipeline.triangular_mesh_source(self._geo.x,
self._geo.y,
self._geo.z,
self._geo.faces,
scalars=morph_data)
if grayscale:
colormap = "gray"
else:
colormap = cmap_dict[measure]
surf = mlab.pipeline.surface(mesh, colormap=colormap,
vmin=min, vmax=max,
name=measure)
# Get the colorbar
bar = mlab.scalarbar(surf)
bar.scalar_bar_representation.position2 = .8, 0.09
# Fil in the morphometry dict
self.morphometry = dict(surface=surf,
colorbar=bar,
measure=measure)
mlab.view(*view)
self._f.scene.disable_render = False
def sensor_connectivity_3d(raw, picks, con, idx, n_con=20, min_dist=0.05, scale_factor=0.005, tube_radius=0.001):
""" Function to plot sensor connectivity showing strongest connections(n_con)
excluding sensors that are less than min_dist apart.
https://github.com/mne-tools/mne-python/blob/master/examples/connectivity/plot_sensor_connectivity.py
Parameters
----------
raw : Raw object
Instance of mne.io.Raw
picks : list
Picks to be included.
con : ndarray (n_channels, n_channels)
Connectivity matrix.
idx : list
List of indices of sensors of interest.
n_con : int
Number of connections of interest.
min_dist : float
Minimum distance between sensors allowed.
Note: Please modify scale factor and tube radius to appropriate sizes if the plot looks scrambled.
"""
# Now, visualize the connectivity in 3D
try:
from enthought.mayavi import mlab
except:
from mayavi import mlab
mlab.figure(size=(600, 600), bgcolor=(0.5, 0.5, 0.5))
# Plot the sensor location
sens_loc = [raw.info['chs'][picks[i]]['loc'][:3] for i in idx]
sens_loc = np.array(sens_loc)
pts = mlab.points3d(sens_loc[:, 0], sens_loc[:, 1], sens_loc[:, 2],
color=(1, 1, 1), opacity=1, scale_factor=scale_factor)
# Get the strongest connections
threshold = np.sort(con, axis=None)[-n_con]
ii, jj = np.where(con >= threshold)
# Remove close connections
con_nodes = list()
con_val = list()
for i, j in zip(ii, jj):
if sci.linalg.norm(sens_loc[i] - sens_loc[j]) > min_dist:
con_nodes.append((i, j))
con_val.append(con[i, j])
con_val = np.array(con_val)
# Show the connections as tubes between sensors
vmax = np.max(con_val)
vmin = np.min(con_val)
for val, nodes in zip(con_val, con_nodes):
x1, y1, z1 = sens_loc[nodes[0]]
x2, y2, z2 = sens_loc[nodes[1]]
points = mlab.plot3d([x1, x2], [y1, y2], [z1, z2], [val, val],
vmin=vmin, vmax=vmax, tube_radius=tube_radius,
colormap='RdBu')
points.module_manager.scalar_lut_manager.reverse_lut = True
mlab.scalarbar(title='Phase Lag Index (PLI)', nb_labels=4)
# Add the sensor names for the connections shown
nodes_shown = list(set([n[0] for n in con_nodes] +
[n[1] for n in con_nodes]))
for node in nodes_shown:
x, y, z = sens_loc[node]
mlab.text3d(x, y, z, raw.ch_names[picks[node]], scale=0.005,
color=(0, 0, 0))
view = (-88.7, 40.8, 0.76, np.array([-3.9e-4, -8.5e-3, -1e-2]))
mlab.view(*view)
X = lcc_list[0].ls_table.X[:, 0]
Y = lcc_list[0].ls_table.Y[:, 0]
Z = lcc_list[0].ls_table.Z[:, 0]
plot_col = n_tex_max[:, 0]
# if n_tex is negative plot 0 instead:
#
plot_col = where( plot_col < 0, 0, plot_col )
mlab.figure( figure = "SFB532Demo",
bgcolor = ( 1.0, 1.0, 1.0 ),
fgcolor = ( 0.0, 0.0, 0.0 ) )
mlab.points3d( X, Y, ( -1.0 ) * Z, plot_col,
colormap = "YlOrBr",
mode = "cube",
scale_factor = 0.10 )
mlab.scalarbar( title = 'n_tex (all LCs)', orientation = 'vertical' )
mlab.show()
# print 'lc_arr', lct.lc_arr
# print 'lc_list[0].sr_arr.shape[0]', lct.lc_list[0].sr_arr.shape[0]
# print 'lc_arr.shape', lct.lc_arr.shape
# print 'combi_arr', lct.combi_arr
# print 'combi_arr.shape', lct.combi_arr.shape
# print 'lcc_arr', lct.lcc_arr
