def __init__(self,
name,
vol=None,
hdr=None,
section=(0, 0, 0),
interpolation='bilinear',
text_size=15.,
text_color='white',
text_bold=True,
transform=None,
parent=None,
verbose=None,
preload=True,
**kw):
"""Init."""
# __________________________ VOLUME __________________________
kw['cmap'] = kw.get('cmap', 'gist_stern')
_Volume.__init__(self, name, parent, transform, verbose, **kw)
self._sagittal = 0
self._coronal = 0
self._axial = 0
# __________________________ PARENTS __________________________
self._im_node = scene.Node(name='Im_', parent=self._node)
self._loc_node = scene.Node(name='Loc_', parent=self._node)
self._loc_node.visible = False
# __________________________ TRANSFORMATION __________________________
# Define three images (Sagittal, Coronal, Axial), markers and line :
kwi = dict(parent=self._im_node,
loc_parent=self._loc_node,
_im=dict(interpolation=interpolation),
_mark=dict(size=20.),
_line=dict(width=3., color='white'))
self._im_sagit = _ImageSection('Sagit', **kwi)
self._im_coron = _ImageSection('Coron', **kwi)
self._im_axial = _ImageSection('Axial', **kwi)
# Add text (sagit, coron, axial, left, right) :
txt_pos = np.array([[-.99, -.1, 0.], [.01, -.1, 0.], [-.99, -1.99, 0.],
[.9, -.2, 0.], [0.1, .9, 0.], [.9, -1.8, 0.],
[0.9, .9, 0.]])
txt = ['Text'] * 3 + ['L'] * 2 + ['R'] * 2
self._txt = scene.visuals.Text(text=txt,
pos=txt_pos,
anchor_x='left',
color=color2vb(text_color),
font_size=text_size,
anchor_y='bottom',
bold=text_bold,
parent=self._node)
if preload:
self(name, vol, hdr)
self.set_data(section=section, **kw)
def __init__(self,
name,
parent=None,
loc_parent=None,
_im={},
_mark={},
_line={}):
"""Init."""
self.node = scene.Node(name='Node_', parent=parent)
self.loc_node = scene.Node(name='LocNode_', parent=loc_parent)
self.image = scene.visuals.Image(name='Im_' + name,
parent=self.node,
**_im)
pos = np.zeros((10, 3))
self.markers = scene.visuals.Markers(pos=pos,
name='Mark_' + name,
parent=self.loc_node,
**_mark)
self.line = scene.visuals.Line(name='Line_' + name,
connect='segments',
parent=self.loc_node,
**_line)
def __init__(self, parent=None, parent_sp=None, visible=True, cmap='gray'):
"""Init."""
CrossSectionsSplit.__init__(self, parent_sp)
self._visible_cs = visible
self._cmap_cs = cmap
#######################################################################
# TRANFORMATIONS
#######################################################################
# Translations :
self._tr_coron = vist.STTransform()
self._tr_sagit = vist.STTransform()
self._tr_axial = vist.STTransform()
# Rotations :
rot_m90x = vist.MatrixTransform(rotate(-90, [1, 0, 0]))
rot_180x = vist.MatrixTransform(rotate(180, [1, 0, 0]))
rot_90y = vist.MatrixTransform(rotate(90, [0, 1, 0]))
rot_m90y = vist.MatrixTransform(rotate(-90, [0, 1, 0]))
rot_m180y = vist.MatrixTransform(rotate(-180, [0, 1, 0]))
rot_90z = vist.MatrixTransform(rotate(90, [0, 0, 1]))
# Tranformations :
tf_sagit = [self._tr_sagit, rot_90z, rot_m90y, rot_m90x]
tf_coron = [self._tr_coron, rot_90z, rot_180x, rot_90y]
tf_axial = [self._tr_axial, rot_m180y, rot_90z]
#######################################################################
# ELEMENTS
#######################################################################
# Create a root node :
self._node_cs = scene.Node(name='Cross-Sections')
self._node_cs.parent = parent
self._node_cs.visible = visible
# Axial :
self.axial = ImageSection(parent=self._node_cs, name='Axial')
self.axial.transform = vist.ChainTransform(tf_axial)
# Coronal :
self.coron = ImageSection(parent=self._node_cs, name='Coronal')
self.coron.transform = vist.ChainTransform(tf_coron)
# Sagittal :
self.sagit = ImageSection(parent=self._node_cs, name='Sagittal')
self.sagit.transform = vist.ChainTransform(tf_sagit)
# Set GL state :
kwargs = {
'depth_test': True,
'cull_face': False,
'blend': False,
'blend_func': ('src_alpha', 'one_minus_src_alpha')
}
self.sagit.set_gl_state('translucent', **kwargs)
self.coron.set_gl_state('translucent', **kwargs)
self.axial.set_gl_state('translucent', **kwargs)
def __init__(self, parent_sp):
"""Init."""
self._vols = {}
# Create a volume root node :
self._node = scene.Node(name='Volume')
# Initialize Cross-Sections, ROI and volume :
Volume3D.__init__(self, parent=self._node)
CrossSections.__init__(self, parent=self._node, parent_sp=parent_sp)
RoiBase.__init__(self, parent=self._node)
# Load default templates and select Brodmann:
self._load_default()
self.select_volume('Brodmann')
def __init__(self, parent=None, cmap='OpaqueGrays'):
"""Init."""
# Create the node for the 3-D volume :
self._node_vol = scene.Node(name='Volume3D')
self._node_vol.parent = parent
# Colormaps :
self._cmap_vol = cmap
self._cmaps = {}
self._cmaps['TransFire'] = TransFire()
self._cmaps['OpaqueFire'] = OpaqueFire()
self._cmaps['TransGrays'] = TransGrays()
self._cmaps['OpaqueGrays'] = OpaqueGrays()
# Create 3-D volume :
vol = np.zeros((1, 1, 1), dtype=np.float32)
self.vol3d = visu.Volume(vol,
parent=self._node_vol,
threshold=0.,
cmap=self._cmaps[cmap])
pos[5000, 1] += 50
color = np.ones((N, 4), dtype=np.float32)
color[:, 0] = np.linspace(0, 1, N)
color[:, 1] = color[::-1, 0]
# Top grid cell shows plot data in a rectangular coordinate system.
l1 = scene.visuals.Line(pos=pos, color=color, antialias=False, method='gl')
b1.add(l1)
grid1 = scene.visuals.GridLines(parent=b1.scene)
# Bottom-left grid cell shows the same data with log-transformed X
grid2 = scene.visuals.GridLines(parent=b2.scene)
# Bottom-left grid cell shows the same data with log-transformed X
e2 = scene.Node(parent=b3.scene)
e2.transform = scene.transforms.LogTransform(base=(2, 0, 0))
l2 = scene.visuals.Line(pos=pos,
color=color,
antialias=False,
parent=e2,
method='gl')
grid3 = scene.visuals.GridLines(parent=e2)
# Bottom-right grid cell shows the same data again, but with a much more
# interesting transformation.
e3 = scene.Node(parent=b4.scene)
affine = scene.transforms.MatrixTransform()
affine.scale((1, 0.1))
affine.rotate(10, (0, 0, 1))
affine.translate((0, 1))
view3 = grid.add_view(row=0, col=0, col_span=2, camera='panzoom',
border_color='grey')
image = ScrollingImage((1 + fft_samples // 2, 4000), parent=view3.scene)
image.transform = scene.LogTransform((0, 10, 0))
# view3.camera.rect = (0, 0, image.size[1], np.log10(image.size[0]))
view3.camera.rect = (3493.32, 1.85943, 605.554, 1.41858)
view1 = grid.add_view(row=1, col=0, camera='panzoom', border_color='grey')
view1.camera.rect = (-0.01, -0.6, 0.02, 1.2)
gridlines = scene.GridLines(color=(1, 1, 1, 0.5), parent=view1.scene)
scope = Oscilloscope(line_size=mic.chunksize, dx=1.0/mic.rate,
parent=view1.scene)
view2 = grid.add_view(row=1, col=1, camera='panzoom', border_color='grey')
view2.camera.rect = (0.5, -0.5e6, np.log10(mic.rate/2), 5e6)
lognode = scene.Node(parent=view2.scene)
lognode.transform = scene.LogTransform((10, 0, 0))
gridlines2 = scene.GridLines(color=(1, 1, 1, 1), parent=lognode)
spectrum = Oscilloscope(line_size=1 + fft_samples // 2, n_lines=10,
dx=mic.rate/fft_samples,
trigger=None, parent=lognode)
mic.start()
window = np.hanning(fft_samples)
fft_frames = []
def __init__(self,
channels,
time,
color=(.2, .2, .2),
width=1.5,
color_detection='red',
method='gl',
camera=None,
parent=None,
fcn=None):
# Initialize PrepareData :
PrepareData.__init__(self, axis=1)
# Variables :
self._camera = camera
self._preproc_channel = -1
self.rect = []
self.width = width
self.autoamp = False
self._fcn = fcn
self.visible = np.array([True] + [False] * (len(channels) - 1))
self.consider = np.ones((len(channels), ), dtype=bool)
# Get color :
self.color = color2vb(color)
self.color_detection = color2vb(color_detection)
# Create one line per channel :
pos = np.zeros((1, 3), dtype=np.float32)
self.mesh, self.report, self.grid, self.peak = [], [], [], []
self.loc, self.node = [], []
for i, k in enumerate(channels):
# ----------------------------------------------
# Create a node parent :
node = scene.Node(name=k + 'plot')
node.parent = parent[i].wc.scene
self.node.append(node)
# ----------------------------------------------
# Create main line (for channel plot) :
mesh = scene.visuals.Line(pos,
name=k + 'plot',
color=self.color,
method=method,
parent=node)
mesh.set_gl_state('translucent')
self.mesh.append(mesh)
# ----------------------------------------------
# Create marker peaks :
mark = Markers(pos=np.zeros((1, 3), dtype=np.float32), parent=node)
mark.set_gl_state('translucent')
mark.visible = False
self.peak.append(mark)
# ----------------------------------------------
# Locations :
loc = scene.visuals.Line(pos,
name=k + 'location',
method=method,
color=(.1, .1, .1, .3),
parent=node,
connect='segments')
loc.set_gl_state('translucent')
self.loc.append(loc)
# ----------------------------------------------
# Create a grid :
grid = scene.visuals.GridLines(color=(.1, .1, .1, .5),
scale=(1., .1),
parent=parent[i].wc.scene)
grid.set_gl_state('translucent')
self.grid.append(grid)
def __init__(self, canvas, **kwargs):
"""Init."""
# Create a root node :
self._vbNode = scene.Node(name='Engram')
self._vbNode.transform = vist.STTransform(scale=[self._gl_scale] * 3)
logger.debug("Engram rescaled " + str([self._gl_scale] * 3))
PROFILER("Root node", level=1)
# ========================= SOURCES =========================
self.sources = CombineSources(kwargs.get('source_obj', None))
if self.sources.name is None:
self._obj_type_lst.model().item(4).setEnabled(False)
# Disable menu :
self.menuDispSources.setChecked(False)
self.menuTransform.setEnabled(False)
self.sources.parent = self._vbNode
PROFILER("Sources object", level=1)
# ========================= CONNECTIVITY =========================
self.connect = CombineConnect(kwargs.get('connect_obj', None))
if self.connect.name is None:
self._obj_type_lst.model().item(5).setEnabled(False)
self.menuDispConnect.setEnabled(False)
self.connect.parent = self._vbNode
PROFILER("Connect object", level=1)
# ========================= TIME-SERIES =========================
self.tseries = CombineTimeSeries(kwargs.get('time_series_obj', None))
if self.tseries.name is None:
self._obj_type_lst.model().item(6).setEnabled(False)
self.tseries.parent = self._vbNode
PROFILER("Time-series object", level=1)
# ========================= PICTURES =========================
self.pic = CombinePictures(kwargs.get('picture_obj', None))
if self.pic.name is None:
self._obj_type_lst.model().item(7).setEnabled(False)
self.pic.parent = self._vbNode
PROFILER("Pictures object", level=1)
# ========================= VECTORS =========================
self.vectors = CombineVectors(kwargs.get('vector_obj', None))
if self.vectors.name is None:
self._obj_type_lst.model().item(8).setEnabled(False)
self.vectors.parent = self._vbNode
PROFILER("Vectors object", level=1)
# ========================= VOLUME =========================
# ----------------- Volume -----------------
if kwargs.get('vol_obj', None) is None:
self.volume = VolumeObj('brodmann')
self.volume.visible_obj = False
else:
self.volume = kwargs.get('vol_obj')
if self.volume.name not in self.volume.list():
self.volume.save(tmpfile=True)
self.volume.parent = self._vbNode
PROFILER("Volume object", level=1)
# ----------------- ROI -----------------
if kwargs.get('roi_obj', None) is None:
self.roi = RoiObj('brodmann')
self.roi.visible_obj = False
else:
self.roi = kwargs.get('roi_obj')
if self.roi.name not in self.roi.list():
self.roi.save(tmpfile=True)
self.roi.parent = self._vbNode
PROFILER("ROI object", level=1)
# ----------------- Cross-sections -----------------
if kwargs.get('cross_sec_obj', None) is None:
self.cross_sec = CrossSecObj('brodmann')
else:
self.cross_sec = kwargs.get('cross_sec_obj')
if self.cross_sec.name not in self.cross_sec.list():
self.cross_sec.save(tmpfile=True)
self.cross_sec.visible_obj = False
self.cross_sec.text_size = 2.
self.cross_sec.parent = self._csView.wc.scene
self._csView.camera = self.cross_sec._get_camera()
self.cross_sec.set_shortcuts_to_canvas(self._csView)
PROFILER("Cross-sections object", level=1)
# ========================= ENGRAM =========================
if kwargs.get('engram_obj', None) is None:
self.atlas = BrainObj('B1')
else:
self.atlas = kwargs['engram_obj']
if self.atlas.name not in self.atlas.list():
self.atlas.save(tmpfile=True)
self.atlas.scale = self._gl_scale
self.atlas.parent = self._vbNode
PROFILER("Engram object", level=1)
def __init__(self,
xyz=None,
channels=None,
system='cartesian',
unit='degree',
title=None,
title_color='black',
title_size=20.,
line_color='black',
line_width=4.,
chan_size=12.,
chan_offset=(0., 0., 0.),
chan_mark_color='white',
chan_mark_symbol='disc',
chan_txt_color='black',
bgcolor='white',
cbar=True,
cb_txt_size=10.,
margin=.05,
parent=None):
"""Init."""
# ======================== VARIABLES ========================
self._bgcolor = color2vb(bgcolor)
scale = 800. # fix GL bugs for small plots
pos = np.zeros((1, 3), dtype=np.float32)
# Colors :
title_color = color2vb(title_color)
line_color = color2vb(line_color)
chan_txt_color = color2vb(chan_txt_color)
self._chan_mark_color = color2vb(chan_mark_color)
self._chan_mark_symbol = chan_mark_symbol
# Disc interpolation :
self._interp = .1
self._pix = 64
csize = int(self._pix / self._interp) if self._interp else self._pix
l = csize / 2 # noqa
# ======================== NODES ========================
# Main topoplot node :
self.node = scene.Node(name='Topoplot', parent=parent)
self.node.transform = vist.STTransform(scale=[scale] * 3)
# Headset + channels :
self.node_headfull = scene.Node(name='HeadChan', parent=self.node)
# Headset node :
self.node_head = scene.Node(name='Headset', parent=self.node_headfull)
# Channel node :
self.node_chan = scene.Node(name='Channels', parent=self.node_headfull)
self.node_chan.transform = vist.STTransform(translate=(0., 0., -10.))
# Cbar node :
self.node_cbar = scene.Node(name='Channels', parent=self.node)
# Dictionaries :
kw_line = {
'width': line_width,
'color': line_color,
'parent': self.node_head
}
# ======================== PARENT VISUALS ========================
# Main disc :
self.disc = visuals.Image(pos=pos,
name='Disc',
parent=self.node_head,
interpolation='bilinear')
# Title :
self.title = visuals.Text(text=title,
pos=(0., .6, 0.),
name='Title',
parent=self.node,
font_size=title_size,
color=title_color,
bold=True)
self.title.font_size *= 1.1
# ======================== HEAD / NOSE / EAR ========================
# ------------------ HEAD ------------------
# Head visual :
self.head = visuals.Line(pos=pos, name='Head', **kw_line)
# Head circle :
theta = np.arange(0, 2 * np.pi, 0.001)
head = np.full((len(theta), 3), -1., dtype=np.float32)
head[:, 0] = l * (1. + np.cos(theta))
head[:, 1] = l * (1. + np.sin(theta))
self.head.set_data(pos=head)
# ------------------ NOSE ------------------
# Nose visual :
self.nose = visuals.Line(pos=pos, name='Nose', **kw_line)
# Nose data :
wn, hn = csize * 50. / 512., csize * 30. / 512.
nose = np.array([[l - wn, 2 * l - wn, 2.], [l, 2 * l + hn, 2.],
[l, 2 * l + hn, 2.], [l + wn, 2 * l - wn, 2.]])
self.nose.set_data(pos=nose, connect='segments')
# ------------------ EAR ------------------
we, he = csize * 10. / 512., csize * 30. / 512.
ye = l + he * np.sin(theta)
# Ear left data :
self.earL = visuals.Line(pos=pos, name='EarLeft', **kw_line)
# Ear left visual :
ear_l = np.full((len(theta), 3), 3., dtype=np.float32)
ear_l[:, 0] = 2 * l + we * np.cos(theta)
ear_l[:, 1] = ye
self.earL.set_data(pos=ear_l)
# Ear right visual :
self.earR = visuals.Line(pos=pos, name='EarRight', **kw_line)
# Ear right data :
ear_r = np.full((len(theta), 3), 3., dtype=np.float32)
ear_r[:, 0] = 0. + we * np.cos(theta)
ear_r[:, 1] = ye
self.earR.set_data(pos=ear_r)
# ================== CHANNELS ==================
# Channel's markers :
self.chanMarkers = visuals.Markers(pos=pos,
name='ChanMarkers',
parent=self.node_chan)
# Channel's text :
self.chanText = visuals.Text(pos=pos,
name='ChanText',
parent=self.node_chan,
anchor_x='center',
color=chan_txt_color,
font_size=chan_size)
# ================== CAMERA ==================
self.rect = ((-scale / 2) * (1 + margin), (-scale / 2) * (1 + margin),
scale * (1. + cbar * .3 + margin),
scale * (1.11 + margin))
# ================== CBAR ==================
if cbar:
self.cbar = CbarVisual(cbtxtsz=1.2 * cb_txt_size,
txtsz=cb_txt_size,
txtcolor=title_color,
cbtxtsh=2.,
parent=self.node_cbar)
self.node_cbar.transform = vist.STTransform(scale=(.6, .4, 1.),
translate=(.6, 0., 0.))
# ================== COORDINATES ==================
auto = self._get_channel_coordinates(xyz, channels, system, unit)
if auto:
eucl = np.sqrt(self._xyz[:, 0]**2 + self._xyz[:, 1]**2).max()
self.node_head.transform = vpnormalize(head, dist=2 * eucl)
# Rescale between (-1:1, -1:1) = circle :
circle = vist.STTransform(scale=(.5 / eucl, .5 / eucl, 1.))
self.node_headfull.transform = circle
# Text translation :
tr = np.array([0., .8, 0.]) + np.array(chan_offset)
else:
# Get coordinates of references along the x and y-axis :
ref_x, ref_y = self._get_ref_coordinates()
# Recenter the topoplot :
t = vist.ChainTransform()
t.prepend(vprecenter(head))
# Rescale (-ref_x:ref_x, -ref_y:ref_y) (ref_x != ref_y => ellipse)
coef_x = 2 * ref_x / head[:, 0].max()
coef_y = 2 * ref_y / head[:, 1].max()
t.prepend(vist.STTransform(scale=(coef_x, coef_y, 1.)))
self.node_head.transform = t
# Rescale between (-1:1, -1:1) = circle :
circle = vist.STTransform(scale=(.5 / ref_x, .5 / ref_y, 1.))
self.node_headfull.transform = circle
# Text translation :
tr = np.array([0., .04, 0.]) + np.array(chan_offset)
self.chanText.transform = vist.STTransform(translate=tr)
# ================== GRID INTERPOLATION ==================
# Interpolation vectors :
x = y = np.arange(0, self._pix, 1)
xnew = ynew = np.arange(0, self._pix, self._interp)
# Grid interpolation function :
def _grid_interpolation(grid):
f = interp2d(x, y, grid, kind='linear')
return f(xnew, ynew)
self._grid_interpolation = _grid_interpolation
def oscilloscope():
# Copyright (c) Vispy Development Team. All Rights Reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
"""
An oscilloscope, spectrum analyzer, and spectrogram.
This demo uses pyaudio to record data from the microphone. If pyaudio is not
available, then a signal will be generated instead.
"""
import threading
import atexit
import numpy as np
from vispy import app, scene, gloo, visuals
from vispy.util.filter import gaussian_filter
try:
import pyaudio
class MicrophoneRecorder(object):
def __init__(self, rate=44100, chunksize=1024):
self.rate = rate
self.chunksize = chunksize
self.p = pyaudio.PyAudio()
self.stream = self.p.open(format=pyaudio.paInt16,
channels=1,
rate=self.rate,
input=True,
frames_per_buffer=self.chunksize,
stream_callback=self.new_frame)
self.lock = threading.Lock()
self.stop = False
self.frames = []
atexit.register(self.close)
def new_frame(self, data, frame_count, time_info, status):
data = np.fromstring(data, 'int16')
with self.lock:
self.frames.append(data)
if self.stop:
return None, pyaudio.paComplete
return None, pyaudio.paContinue
def get_frames(self):
with self.lock:
frames = self.frames
self.frames = []
return frames
def start(self):
self.stream.start_stream()
def close(self):
with self.lock:
self.stop = True
self.stream.close()
self.p.terminate()
except ImportError:
class MicrophoneRecorder(object):
def __init__(self):
self.chunksize = 1024
self.rate = rate = 44100
t = np.linspace(0, 10, rate * 10)
self.data = (np.sin(t * 10.) * 0.3).astype('float32')
self.data += np.sin((t + 0.3) * 20.) * 0.15
self.data += gaussian_filter(
np.random.normal(size=self.data.shape) * 0.2, (0.4, 8))
self.data += gaussian_filter(
np.random.normal(size=self.data.shape) * 0.005, (0, 1))
self.data += np.sin(t * 1760 * np.pi) # 880 Hz
self.data = (self.data * 2**10 - 2**9).astype('int16')
self.ptr = 0
def get_frames(self):
if self.ptr + 1024 > len(self.data):
end = 1024 - (len(self.data) - self.ptr)
frame = np.concatenate(
(self.data[self.ptr:], self.data[:end]))
else:
frame = self.data[self.ptr:self.ptr + 1024]
self.ptr = (self.ptr + 1024) % (len(self.data) - 1024)
return [frame]
def start(self):
pass
class Oscilloscope(scene.ScrollingLines):
"""A set of lines that are temporally aligned on a trigger.
Data is added in chunks to the oscilloscope, and each new chunk creates a
new line to draw. Older lines are slowly faded out until they are removed.
Parameters
----------
n_lines : int
The maximum number of lines to draw.
line_size : int
The number of samples in each line.
dx : float
The x spacing between adjacent samples in a line.
color : tuple
The base color to use when drawing lines. Older lines are faded by
decreasing their alpha value.
trigger : tuple
A set of parameters (level, height, width) that determine how triggers
are detected.
parent : Node
An optional parent scenegraph node.
"""
def __init__(self,
n_lines=100,
line_size=1024,
dx=1e-4,
color=(20, 255, 50),
trigger=(0, 0.002, 1e-4),
parent=None):
self._trigger = trigger # trigger_level, trigger_height, trigger_width
# lateral positioning for trigger
self.pos_offset = np.zeros((n_lines, 3), dtype=np.float32)
# color array to fade out older plots
self.color = np.empty((n_lines, 4), dtype=np.ubyte)
self.color[:, :3] = [list(color)]
self.color[:, 3] = 0
self._dim_speed = 0.01**(1 / n_lines)
self.frames = [] # running list of recently received frames
self.plot_ptr = 0
scene.ScrollingLines.__init__(self,
n_lines=n_lines,
line_size=line_size,
dx=dx,
color=self.color,
pos_offset=self.pos_offset,
parent=parent)
self.set_gl_state('additive', line_width=2)
def new_frame(self, data):
self.frames.append(data)
# see if we can discard older frames
while len(self.frames) > 10:
self.frames.pop(0)
if self._trigger is None:
dx = 0
else:
# search for next trigger
th = int(self._trigger[1]) # trigger window height
tw = int(self._trigger[2] / self._dx) # trigger window width
thresh = self._trigger[0]
trig = np.argwhere((data[tw:] > thresh + th)
& (data[:-tw] < thresh - th))
if len(trig) > 0:
m = np.argmin(np.abs(trig - len(data) / 2))
i = trig[m, 0]
y1 = data[i]
y2 = data[min(i + tw * 2, len(data) - 1)]
s = y2 / (y2 - y1)
i = i + tw * 2 * (1 - s)
dx = i * self._dx
else:
# default trigger at center of trace
# (optionally we could skip plotting instead, or place this
# after the most recent trace)
dx = self._dx * len(data) / 2.
# if a trigger was found, add new data to the plot
self.plot(data, -dx)
def plot(self, data, dx=0):
self.set_data(self.plot_ptr, data)
np.multiply(self.color[..., 3],
0.98,
out=self.color[..., 3],
casting='unsafe')
self.color[self.plot_ptr, 3] = 50
self.set_color(self.color)
self.pos_offset[self.plot_ptr] = (dx, 0, 0)
self.set_pos_offset(self.pos_offset)
self.plot_ptr = (self.plot_ptr + 1) % self._data_shape[0]
rolling_tex = """
float rolling_texture(vec2 pos) {
if( pos.x < 0 || pos.x > 1 || pos.y < 0 || pos.y > 1 ) {
return 0.0f;
}
vec2 uv = vec2(mod(pos.x+$shift, 1), pos.y);
return texture2D($texture, uv).r;
}
"""
cmap = """
vec4 colormap(float x) {
x = x - 1e4;
return vec4(x/5e6, x/2e5, x/1e4, 1);
}
"""
class ScrollingImage(scene.Image):
def __init__(self, shape, parent):
self._shape = shape
self._color_fn = visuals.shaders.Function(rolling_tex)
self._ctex = gloo.Texture2D(np.zeros(shape + (1, ),
dtype='float32'),
format='luminance',
internalformat='r32f')
self._color_fn['texture'] = self._ctex
self._color_fn['shift'] = 0
self.ptr = 0
scene.Image.__init__(self, method='impostor', parent=parent)
# self.set_gl_state('additive', cull_face=False)
self.shared_program.frag['get_data'] = self._color_fn
cfun = visuals.shaders.Function(cmap)
self.shared_program.frag['color_transform'] = cfun
@property
def size(self):
return self._shape
def roll(self, data):
data = data.reshape(data.shape[0], 1, 1)
self._ctex[:, self.ptr] = data
self._color_fn['shift'] = (self.ptr + 1) / self._shape[1]
self.ptr = (self.ptr + 1) % self._shape[1]
self.update()
def _prepare_draw(self, view):
if self._need_vertex_update:
self._build_vertex_data()
if view._need_method_update:
self._update_method(view)
global fft_frames, scope, spectrum, mic
mic = MicrophoneRecorder()
n_fft_frames = 8
fft_samples = mic.chunksize * n_fft_frames
win = scene.SceneCanvas(keys='interactive', show=True, fullscreen=True)
grid = win.central_widget.add_grid()
view3 = grid.add_view(row=0,
col=0,
col_span=2,
camera='panzoom',
border_color='grey')
image = ScrollingImage((1 + fft_samples // 2, 4000), parent=view3.scene)
image.transform = scene.LogTransform((0, 10, 0))
# view3.camera.rect = (0, 0, image.size[1], np.log10(image.size[0]))
view3.camera.rect = (3493.32, 1.85943, 605.554, 1.41858)
view1 = grid.add_view(row=1, col=0, camera='panzoom', border_color='grey')
view1.camera.rect = (-0.01, -0.6, 0.02, 1.2)
gridlines = scene.GridLines(color=(1, 1, 1, 0.5), parent=view1.scene)
scope = Oscilloscope(line_size=mic.chunksize,
dx=1.0 / mic.rate,
parent=view1.scene)
view2 = grid.add_view(row=1, col=1, camera='panzoom', border_color='grey')
view2.camera.rect = (0.5, -0.5e6, np.log10(mic.rate / 2), 5e6)
lognode = scene.Node(parent=view2.scene)
lognode.transform = scene.LogTransform((10, 0, 0))
gridlines2 = scene.GridLines(color=(1, 1, 1, 1), parent=lognode)
spectrum = Oscilloscope(line_size=1 + fft_samples // 2,
n_lines=10,
dx=mic.rate / fft_samples,
trigger=None,
parent=lognode)
mic.start()
window = np.hanning(fft_samples)
fft_frames = []
def update(ev):
global fft_frames, scope, spectrum, mic
data = mic.get_frames()
for frame in data:
# import scipy.ndimage as ndi
# frame -= ndi.gaussian_filter(frame, 50)
# frame -= frame.mean()
scope.new_frame(frame)
fft_frames.append(frame)
if len(fft_frames) >= n_fft_frames:
cframes = np.concatenate(fft_frames) * window
fft = np.abs(np.fft.rfft(cframes)).astype('float32')
fft_frames.pop(0)
spectrum.new_frame(fft)
image.roll(fft)
timer = app.Timer(interval='auto', connect=update)
timer.start()
app.run()
"""
import sys
from vispy import scene
from vispy.visuals.transforms import STTransform
canvas = scene.SceneCanvas(keys='interactive',
bgcolor='white',
size=(800, 600),
show=True)
view = canvas.central_widget.add_view()
view.camera = 'arcball'
spheres = scene.Node(parent=view.scene)
for x in range(100):
scene.visuals.Cube(size=1,
parent=spheres,
edge_color='#ff00ff',
color='#ff0000')
'''
index = 0
for x in range(10):
for y in range(10):
for z in range(10):
if(y%2==0):
if x%2==0:
spheres[index]= STTransform(translate=[x, z, y])
#newlist[index,0] = ((x*10)+z+(y*100));
else:
def __init__(self,
name,
vol=None,
hdr=None,
coords=None,
contrast=0.,
interpolation='nearest',
text_size=13.,
text_color='white',
text_bold=True,
transform=None,
parent=None,
verbose=None,
preload=True,
**kw):
"""Init."""
# __________________________ VOLUME __________________________
_Volume.__init__(self, name, parent, transform, verbose, **kw)
self._rect = (-1.5, -1., 3., 2.)
self._sagittal = 0
self._coronal = 0
self._axial = 0
self._latest_xyz = 0.
# __________________________ PARENTS __________________________
self._im_node = scene.Node(name='Images', parent=self._node)
self._sagit_node = scene.Node(name='Sagittal', parent=self._im_node)
self._coron_node = scene.Node(name='Coronal', parent=self._im_node)
self._axial_node = scene.Node(name='Axial', parent=self._im_node)
# __________________________ MASK __________________________
kw = dict(interpolation=interpolation)
parents = [self._sagit_node, self._coron_node, self._axial_node]
self._bgd = _Mask('Background',
parent=parents,
visible=True,
deep_test=False,
**kw)
self._act = _Mask('Activations', parent=parents, deep_test=False, **kw)
self._sources = _Mask('Sources', parent=parents, **kw)
# __________________________ LOCATION __________________________
_center = dict(pos=np.zeros((6, 3)), size=20.)
_cross = dict(connect='segments', width=2., color='white')
self._center = [0] * 3
self._cross = [0] * 3
for i, k in enumerate(parents):
_n = k.name[0:5]
self._center[i] = scene.visuals.Markers(name='Center_%s' % _n,
parent=k,
**_center)
self._cross[i] = scene.visuals.Line(name='Cross_%s' % _n,
parent=k,
**_cross)
self._center[i].visible = False
self._cross[i].visible = False
# __________________________ TEXT __________________________
self._txt_format = '%s = %.2f'
# Add text (sagit, coron, axial, left, right) :
txt_pos = np.array([
[.05, -.1, 0.],
[.05, -.2, 0.],
[.05, -.3, 0.],
[.05, -.4, 0.],
[.05, -.5, 0.],
[-.1, -.1, 0.],
[0.1, .9, 0.], # L
[-.1, -.9, 0.],
[0.9, .9, 0.]
]) # R
txt = [''] * 5 + ['L'] * 2 + ['R'] * 2
self._txt = scene.visuals.Text(text=txt,
pos=txt_pos,
anchor_x='left',
color=color2vb(text_color),
font_size=text_size,
anchor_y='bottom',
bold=text_bold,
parent=self._node)
if preload:
self(name, vol, hdr)
self.cut_coords(coords)
self.contrast = contrast
self._on_key_pressed()
self._update()
# Set file name :
self._set_text(0, 'File = ' + self._name)
def __init__(self, canvas, parent_sp, progressbar, **kwargs):
"""Init."""
# ---------- Initialize base ----------
# Get progress bar :
self.progressbar = progressbar
# Initialize visbrain objects :
self.atlas = AtlasBase(**kwargs)
self.volume = VolumeBase(parent_sp=parent_sp)
self.sources = SourcesBase(**kwargs)
self.connect = ConnectBase(_xyz=self.sources.xyz,
c_xyz=self.sources.xyz,
**kwargs)
self.tseries = TimeSeriesBase(ts_xyz=self.sources.xyz, **kwargs)
self.pic = PicBase(pic_xyz=self.sources.xyz, **kwargs)
# Add projections :
Projections.__init__(self, **kwargs)
self._tobj['brain'] = self.atlas
# ---------- Panel management ----------
# Some GUI panels are systematically deactivate if there's no
# corresponding object.
# Sources panel:
if self.sources.name is 'NoneSources':
# Disable menu :
self.menuDispSources.setChecked(False)
self.menuDispSources.setEnabled(False)
self.menuTransform.setEnabled(False)
# Disable source/connect/cbar tabs :
toggle_enable_tab(self.QuickSettings, 'Sources', False)
toggle_enable_tab(self.QuickSettings, 'Connect', False)
toggle_enable_tab(self.QuickSettings, 'Cbar', False)
# Disable transparency on sources :
self.o_Sources.setEnabled(False)
self.o_Sources.setChecked(False)
# Text panel:
if self.sources.stextmesh.name == 'NoneText':
self.o_Text.setEnabled(False)
self.o_Text.setChecked(False)
self.grpText.setEnabled(False)
# Time-series panel :
if self.tseries.mesh.name == 'NoneTimeSeries':
self.grpTs.setEnabled(False)
# Pictures panel :
if self.pic.mesh.name == 'NonePic':
self.grpPic.setEnabled(False)
# Connectivity panel:
if self.connect.name == 'NoneConnect':
# Disable menu :
self.menuDispConnect.setEnabled(False)
self.menuDispConnect.setChecked(False)
# Disable Connect tab :
toggle_enable_tab(self.QuickSettings, 'Connect', False)
self.o_Connect.setEnabled(False)
self.o_Connect.setChecked(False)
elif self.connect.colval is not None:
self.cmapConnect.setEnabled(False)
self.o_Connect.setEnabled(False)
self._lw = kwargs.get('c_linewidth', 4.)
# ---------- Put everything in a root node ----------
# Here, each object is put in a root node so that each transformation
# can be applied to all elements.
# Create a root node :
self._vbNode = scene.Node(name='visbrain')
# Make this root node the parent of others Brain objects :
self.volume.parent = self._vbNode
self.sources.mesh.parent = self._vbNode
self.connect.mesh.parent = self._vbNode
self.sources.stextmesh.parent = self._vbNode
self.tseries.mesh.parent = self._vbNode
self.pic.mesh.parent = self._vbNode
self.atlas.mesh.parent = self._vbNode
# Add XYZ axis (debugging : x=red, y=green, z=blue)
# scene.visuals.XYZAxis(parent=self._vbNode)
# Add a rescale / translate transformation to the Node :
self._vbNode.transform = self.atlas.mesh._btransform
