def __init__(self):
app.Canvas.__init__(self,
title='Bezier lines example',
keys='interactive',
size=(400, 750))
self.lines = [
visuals.LineVisual(curves.curve4_bezier((10, 0), (50, -190),
(350, 190), (390, 0)),
color='w',
width=2,
method='agg'),
visuals.LineVisual(curves.curve4_bezier((10, 0), (190, -190),
(210, 190), (390, 0)),
color='w',
width=2,
method='agg'),
visuals.LineVisual(curves.curve3_bezier((10, 0), (30, 200),
(390, 0)),
color='w',
width=2,
method='agg')
]
# Translate each line visual downwards
for i, line in enumerate(self.lines):
x = 0
y = 200 * (i + 1)
line.transform = STTransform(translate=[x, y])
self.texts = [
visuals.TextVisual('Third order curve',
bold=True,
color='w',
font_size=14,
pos=(200, 75)),
visuals.TextVisual('Quadratic curve',
bold=True,
color='w',
font_size=14,
pos=(200, 525)),
]
for text in self.texts:
text.transform = NullTransform()
self.visuals = self.lines + self.texts
self.show()
def __init__(self, canvas, analog_data, spike_data):
super().__init__()
self.canvas = canvas
self.analog_data = analog_data
self.spike_data = mea.MEASpikeDict(spike_data)
prespikes = spike_data.copy()
prespikes.electrode = prespikes.electrode.str.split('.').str.get(0)
self.condensed_spike_data = mea.MEASpikeDict(prespikes)
self._t0 = 0
self._dt = 20
self.mouse_t = 0
self.electrode = ''
self._time_window = 20 # in milliseconds
self._scale = (5, 150)
self.extra_text = ''
self._selected_electrodes = []
self.program = gloo.Program(self.VERTEX_SHADER, self.FRAGMENT_SHADER)
self.program['u_scale'] = self._scale
self.program['a_position'] = [[0, 0, 0, 0]]
self.program['a_color'] = [[0, 0, 0, 0]]
self.program['u_width'] = 100
self.program['u_rows'] = self.canvas.layout.rows
self.program['u_columns'] = self.canvas.layout.columns
self.grid = LineCollection()
self.create_grid()
self.sample_rate = 1.0 / (self.analog_data.index[1] -
self.analog_data.index[0])
self.measuring = False
self.measure_start = (0, 0)
self.measure_line = visuals.LineVisual(np.array(((0, 0), (0, 0))),
Theme.yellow,
method='agg')
self.configure_transforms()
def __init__(self, canvas, spike_data):
self.canvas = canvas
self.program = ModularProgram(self.VERTEX_SHADER, self.FRAGMENT_SHADER)
self._t0 = 0
self._dt = 10
self.mouse_t = self.t0
self._interval = 1 / 30.0
self.electrode = ''
self.time_scale = 1 / 200
self._vert = np.zeros((120 * 6, 2), dtype=np.float32)
self._color = np.zeros(120 * 6, dtype=np.float32)
self.electrodes = []
self.spikes = spike_data
for tag, df in spike_data.groupby('electrode'):
self.electrodes.append(
FlashingSpikeElectrode(tag, df['time'].values))
self._create_vertex_data()
self.paused = True
self.program['a_position'] = self._vert
self.program['a_color'] = self._color
self.program.vert['transform'] = canvas.tr_sys.get_full_transform()
self.outline = visuals.LineVisual(color=Theme.yellow)
self.electrode_cols = [c for c in 'ABCDEFGHJKLM']
self._rescale_outline()
self.extra_text = ''
def __init__(self, canvas, spike_data):
super().__init__()
self.canvas = canvas
self.program = ModularProgram(self.VERTEX_SHADER,
self.FRAGMENT_SHADER)
self._t0 = 0
self._dt = 10
self.mouse_t = self.t0
self._interval = 1 / 30.0
self.electrode = ''
self.time_scale = 1 / 200
# Each quad is drawn as two triangles, so need 6 vertices per electrode
self._vert = np.zeros((self.canvas.layout.count * 6, 2),
dtype=np.float32)
self._color = np.zeros(self.canvas.layout.count * 6,
dtype=np.float32)
self.electrodes = []
self.spikes = spike_data.copy()
self.spikes.electrode = self.spikes.electrode.str.extract('(\w+)\.*')
for tag, df in self.spikes.groupby('electrode'):
self.electrodes.append(FlashingSpikeElectrode(tag,
df['time'].values))
self._create_vertex_data()
self.paused = True
self.program['a_position'] = self._vert
self.program['a_color'] = self._color
self.program.vert['transform'] = canvas.tr_sys.get_transform()
self.outline = visuals.LineVisual(color=Theme.yellow)
self._rescale_outline()
self.extra_text = ''
self.configure_transforms()
def __init__(self, canvas, spike_data):
super().__init__()
self.canvas = canvas
if 'conductance' not in spike_data.columns:
spike_data['conductance'] = False
self.spike_data = mea.MEASpikeDict(spike_data)
self.spike_data.sort()
self.program = gloo.Program(RasterPlotVisualization.VERTEX_SHADER,
RasterPlotVisualization.FRAGMENT_SHADER)
self._t0 = 0
self._dt = self.spike_data.max_time()
self.electrode = ''
self.program['u_pan'] = self._t0
self.program['u_y_scale'] = self._dt / 2
self.program['u_top_margin'] = 20.0 * 2.0 / canvas.size[1]
self._row_count = 120
self._display_selected = False
self.selected_electrodes = []
self.row_count = len(self.spike_data)
self._unselected_row_count = self.row_count
self._dim_conductance = False
self.resample()
self.margin = {'top': 20}
self.velocity = 0
self.tick_separtion = 50
self.tick_labels = [visuals.TextVisual('', font_size=10, color='w')
for x in range(14)]
self.tick_marks = LineCollection()
self.mouse_t = 0
self.extra_text = ''
self.measuring = False
self.measure_start = (0, 0)
self.measure_line = visuals.LineVisual(np.array(((0, 0), (100, 100))),
Theme.yellow)
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 800))
# Create several visuals demonstrating different features of Line
self.lines = [
# agg-method lines:
# per-vertex color
visuals.LineVisual(pos=pos, color=color, method='agg'),
# solid
visuals.LineVisual(pos=pos, color=(0, 0.5, 0.3, 1), method='agg'),
# wide
visuals.LineVisual(pos=pos, color=color, width=5, method='agg'),
# GL-method lines:
visuals.LineVisual(pos=pos, color=color, method='gl'),
visuals.LineVisual(pos=pos, color=(0, 0.5, 0.3, 1), method='gl'),
visuals.LineVisual(pos=pos, color=color, width=5, method='gl'),
# GL-method: "connect" not available in AGG method yet
# only connect alternate vert pairs
visuals.LineVisual(pos=pos,
color=(0, 0.5, 0.3, 1),
connect='segments',
method='gl'),
# connect specific pairs
visuals.LineVisual(pos=pos,
color=(0, 0.5, 0.3, 1),
connect=connect,
method='gl'),
]
counts = [0, 0]
for i, line in enumerate(self.lines):
# arrange lines in a grid
tidx = (line.method == 'agg')
x = 400 * tidx
y = 140 * (counts[tidx] + 1)
counts[tidx] += 1
line.transform = STTransform(translate=[x, y])
# redraw the canvas if any visuals request an update
line.events.update.connect(lambda evt: self.update())
self.texts = [
visuals.TextVisual('GL',
bold=True,
font_size=24,
color='w',
pos=(200, 40)),
visuals.TextVisual('Agg',
bold=True,
font_size=24,
color='w',
pos=(600, 40))
]
for text in self.texts:
text.transform = NullTransform()
self.visuals = self.lines + self.texts
self.show()
def __init__(self):
# Define several Line visuals that use the same position data
self.lines = [visuals.LineVisual(pos=pos)
for i in range(6)]
self.lines[0].transform = STTransform(translate=(0, 50))
# Clipping filter (requires update when window is resized)
self.lines[1].transform = STTransform(translate=(400, 50))
self.clipper = Clipper([500, 725, 200, 50])
self.lines[1].attach(self.clipper)
# Opacity filter
self.lines[2].transform = STTransform(translate=(0, 150))
self.lines[2].attach(Alpha(0.4))
# Color filter (for anaglyph stereo)
self.lines[3].transform = STTransform(translate=(400, 150))
self.lines[3].attach(ColorFilter([1, 0, 0, 1]))
# A custom filter
class Hatching(object):
def __init__(self):
self.shader = Function("""
void screen_filter() {
float f = gl_FragCoord.x * 0.4 + gl_FragCoord.y;
f = mod(f, 20);
if( f < 5.0 ) {
discard;
}
if( f < 20.0 ) {
gl_FragColor.g = gl_FragColor.g + 0.05 * (20-f);
}
}
""")
def _attach(self, visual):
visual._get_hook('frag', 'post').add(self.shader())
self.lines[4].transform = STTransform(translate=(0, 250))
self.lines[4].attach(Hatching())
# Mixing filters
self.lines[5].transform = STTransform(translate=(400, 250))
self.lines[5].attach(ColorFilter([1, 0, 0, 1]))
self.lines[5].attach(Hatching())
app.Canvas.__init__(self, keys='interactive', size=(800, 800))
for line in self.lines:
tr_sys = visuals.transforms.TransformSystem(self)
tr_sys.visual_to_document = line.transform
line.tr_sys = tr_sys
self.show(True)
def __init__(self, canvas, analog_data, spike_data):
super().__init__()
self.canvas = canvas
self.analog_data = analog_data
self.raw_data = spike_data
self.spike_data = mea.MEASpikeDict(spike_data)
self.show_spikes = False
self._dim_conductance = False
self._t0 = 0
self._dt = 20
self._y_scale = 150
self._pan = 0
self._scale = 1
self.mouse_t = 0
self.electrode = ''
self.selected_electrodes = ['h11'] # l5, m5
self.strip_program = gloo.Program(self.STRIP_VERTEX_SHADER,
self.STRIP_FRAGMENT_SHADER)
self.strip_program['u_color'] = Theme.blue
self.point_program = gloo.Program(self.POINT_VERTEX_SHADER,
self.POINT_FRAGMENT_SHADER)
self.pan = self._t0
self.scale = (2.0 / self._dt, 1 / self._y_scale)
self.velocity = 0
self.measuring = False
self.measure_start = (0, 0)
self.measure_line = visuals.LineVisual(np.array(((0, 0), (100, 100))),
Theme.yellow)
self.scale_bar = visuals.LineVisual(np.array(((10, 10), (200, 10))),
Theme.black,
width=10,
method='agg')
self.scale_label = visuals.TextVisual('', font_size=8)
self.configure_transforms()
self.extra_text = ''
self._filtered = False
self._filter_cutoff = [200, 4000]
self.all_spike_colors = []
self.propagation_spike_colors = []
self.resample()
self.background_color = Theme.background
def __init__(self):
app.Canvas.__init__(self,
title='Bezier lines example',
keys='interactive',
size=(400, 750))
self.visuals = [
visuals.TextVisual('Third order curve',
bold=True,
color='w',
font_size=14,
pos=(200, 75)),
visuals.LineVisual(np.array([[10, 10], [30, 10], [40, 40],
[90, 40]]),
color=(1, 0, 0, 1))
]
def __init__(self):
# Define several Line visuals that use the same position data
# but have different colors and transformations
colors = [color, (1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1),
(1, 1, 0, 1), (1, 1, 1, 1)]
self.lines = [visuals.LineVisual(pos=pos, color=colors[i])
for i in range(6)]
center = STTransform(translate=(400, 400))
self.lines[0].transform = center
self.lines[1].transform = (center *
STTransform(scale=(1, 0.1, 1)))
self.lines[2].transform = (center *
STTransform(translate=(200, 200, 0)) *
STTransform(scale=(0.3, 0.5, 1)))
self.lines[3].transform = (center *
STTransform(translate=(-200, -200, 0),
scale=(200, 1)) *
LogTransform(base=(10, 0, 0)) *
STTransform(translate=(1, 0, 0)))
self.lines[4].transform = AffineTransform()
self.lines[4].transform.rotate(45, (0, 0, 1))
self.lines[4].transform.scale((0.3, 0.3, 1))
self.lines[4].transform.translate((200, 200, 0))
self.lines[5].transform = (STTransform(translate=(200, 600, 0),
scale=(5, 5)) *
PolarTransform() *
LogTransform(base=(2, 0, 0)) *
STTransform(scale=(0.01, 0.1),
translate=(4, 20)))
app.Canvas.__init__(self, keys='interactive')
self.size = (800, 800)
self.show()
for line in self.lines:
tr_sys = visuals.transforms.TransformSystem(self)
tr_sys.visual_to_document = line.transform
line.tr_sys = tr_sys
def __init__(self, canvas, analog_data, spike_data):
self.canvas = canvas
self.analog_data = analog_data
self.spike_data = mea.MEASpikeDict(spike_data)
self.show_spikes = False
self._t0 = 0
self._dt = 20
self._y_scale = 150
self._pan = 0
self._scale = 1
self.mouse_t = 0
self.electrode = ''
self.electrodes = ['h11'] # l5, m5
self.strip_program = gloo.Program(self.STRIP_VERTEX_SHADER,
self.STRIP_FRAGMENT_SHADER)
self.strip_program['u_color'] = Theme.blue
self.point_program = gloo.Program(self.POINT_VERTEX_SHADER,
self.POINT_FRAGMENT_SHADER)
self.point_program['u_color'] = Theme.yellow
self.pan = self._t0
self.scale = (2.0 / self._dt, 1 / self._y_scale)
self.velocity = 0
self.measuring = False
self.measure_start = (0, 0)
self.measure_line = visuals.LineVisual(np.array(((0, 0), (100, 100))),
Theme.grid_line)
self.extra_text = ''
self._filtered = False
self._filter_cutoff = [200, 4000]
self.resample()
self.background_color = Theme.background
def __init__(self, bubble_box, **kwargs):
app.Canvas.__init__(self, keys='interactive', **kwargs)
self._bubble_box = bubble_box
new_scale = min(size_w / size_bb - 0.5
for size_w, size_bb in zip(self.size, self._bubble_box.boxsize))
new_center = np.array(self._bubble_box.boxsize)[::-1] / 2
transform = STTransform(scale=(new_scale, new_scale),
translate=new_center)
self.markers = visuals.MarkersVisual()
self.update_positions(0.0)
self.markers.transform = transform
w, h = self._bubble_box.boxsize
bbox = np.array([(0, 0), (w, 0), (w, h), (0, h), (0, 0)], np.float32)
self.box = visuals.LineVisual(pos=bbox, width=1, color='black',
method='gl')
self.box.transform = transform
self.visuals = [self.markers, self.box]
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
cells.append(row)
for j in range(N):
row.append(Line(data, offset=(-50, 0), scale=scales))
gcanvas = GridCanvas(cells,
position=(400, 300),
size=(800, 600),
title="GridCanvas")
# Visual version
vlines = []
for i in range(M):
row = []
vlines.append(row)
for j in range(N):
v = visuals.LineVisual(pos=data, color='w', method='gl')
v.transform = visuals.transforms.STTransform(translate=(-1, 0),
scale=scales)
row.append(v)
vcanvas = VisualCanvas(vlines,
position=(400, 300),
size=(800, 600),
title="VisualCanvas")
# Scenegraph version
scanvas = scene.SceneCanvas(show=True,
keys='interactive',
title="SceneCanvas")
scanvas.size = 800, 600
def __init__(self):
app.Canvas.__init__(self, title='Glyphs', keys='interactive')
self.font_size = 9.
# Create a cross eye for easy see if text anchor positions are good
l_pos = np.array([
[-1.0, 0.0],
[1.0, 0.0],
[0.0, 0.0],
[0.0, 1.0],
[0.0, -1.0],
])
self.cross_eye_line = visuals.LineVisual(pos=l_pos,
color=(1.0, 0.0, 0.0, 1),
method='gl')
big_test_string = 'This is the big test string!\n'
big_test_string += 'It includes all of the escape sequences known\n'
big_test_string += 'to man:\n\n'
big_test_string += '\t-\t\\n\n'
big_test_string += '\t-\t\\v\n'
big_test_string += '\t-\t\\t\n'
big_test_string += '\t-\tetc..\v'
big_test_string += 'So \bif \fthis \rlooks correct, somebody did a \n'
big_test_string += 'decent job and deserves a beer '
big_test_string += 'and a digital salute\a! ;)'
big_test_string += '\vThe end!'
self.string_alternatives = [
'',
'Hello (scroll/arrows to change text properties)|\a|how are u',
'Hello (scroll/arrows to change text properties)|\b|how are u',
'Hello (scroll/arrows to change text properties)|\f|how are u',
'Hello (scroll/arrows to change text properties)|\n|how are u',
'Hello (scroll/arrows to change text properties)|\r|how are u',
'Hello (scroll/arrows to change text properties)|\t|how are u',
'Hello (scroll/arrows to change text properties)|\v|how are u',
'Hello (scroll/arrows to change text properties)|\\|how are u',
'Hello (scroll/arrows to change text properties)|\'|how are u',
'Hello (scroll/arrows to change text properties)|\"|how are u',
'Hello (scroll/arrows to change text properties)|?|how are u',
big_test_string,
]
self.str_ind = 0
# anchor_x , anchor_y
self.anchor_variants = [
['top', 'left'],
['center', 'left'],
['bottom', 'left'],
['top', 'center'],
['center', 'center'],
['bottom', 'center'],
['top', 'right'],
['center', 'right'],
['bottom', 'right'],
]
self.anchor_ind = 0
self.text = visuals.TextVisual('', bold=True, pos=(0., 0.))
self.update_text()
cells.append(row)
for j in range(N):
row.append(Line(data, offset=(-50, 0), scale=(1.9 / 100, 2 / 10)))
gcanvas = GridCanvas(cells,
position=(400, 300),
size=(800, 600),
title="GridCanvas")
# Visual version
vlines = []
for i in range(M):
row = []
vlines.append(row)
for j in range(N):
v = visuals.LineVisual(pos=data, color=(1, 1, 1, 0.5), method='gl')
v.transform = visuals.transforms.STTransform(translate=(0, 200),
scale=(7, 50))
row.append(v)
vcanvas = VisualCanvas(vlines,
position=(400, 300),
size=(800, 600),
title="VisualCanvas")
# Scenegraph version
scanvas = scene.SceneCanvas(show=True,
keys='interactive',
title="SceneCanvas")
scanvas.size = 800, 600
