def apply_zoom(self):
width, height = self.physical_size
gloo.set_viewport(0, 0, width, height)
self.fractal['resolution'] = [width, height]
self.skeleton_bones['resolution'] = [width, height]
self.mask['resolution'] = [width, height]
def __init__(self):
app.Canvas.__init__(self, size=(512, 512), title='scaling quad',
keys='interactive')
# program with 4 vertices
program = gloo.Program(vert=vertex, frag=fragment, count=4)
# bind data
program['a_position'] = [(-1, -1), (-1, 1), (1, -1), (1, 1)]
program['color'] = [(1, 0, 0, 1),
(0, 1, 0, 1),
(0, 0, 1, 1),
(1, 1, 0, 1)]
program['scale'] = 1.0
self.program = program
# set viewport
gloo.set_viewport(0, 0, *self.physical_size)
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.clock = 0.0
self.timer.start()
# show the canvas
self.show()
def activate_zoom(self): self.width, self.height = self.size gloo.set_viewport(0, 0, *self.physical_size) vp = (0, 0, self.physical_size[0], self.physical_size[1]) interface.configure(canvas=self, viewport=vp) controller.configure(canvas=self, viewport=vp) field.set_gl_needs_update()
def test_use_framebuffer():
"""Test drawing to a framebuffer"""
shape = (100, 100)
data = np.random.rand(*shape).astype(np.float32)
orig_tex = Texture2D(data)
use_shape = shape + (3,)
fbo_tex = Texture2D(shape=use_shape, dtype=np.ubyte, format='rgb')
rbo = ColorBuffer(shape=shape)
fbo = FrameBuffer(color=fbo_tex)
with Canvas(size=(100, 100)) as c:
set_viewport((0, 0) + c.size)
with fbo:
draw_texture(orig_tex)
draw_texture(fbo_tex)
out_tex = _screenshot()[::-1, :, 0].astype(np.float32)
assert_raises(TypeError, FrameBuffer.color_buffer.fset, fbo, 1.)
assert_raises(TypeError, FrameBuffer.depth_buffer.fset, fbo, 1.)
assert_raises(TypeError, FrameBuffer.stencil_buffer.fset, fbo, 1.)
fbo.color_buffer = rbo
fbo.depth_buffer = DepthBuffer(shape)
fbo.stencil_buffer = None
print((fbo.color_buffer, fbo.depth_buffer, fbo.stencil_buffer))
clear(color='black')
with fbo:
clear(color='black')
draw_texture(orig_tex)
out_rbo = _screenshot()[:, :, 0].astype(np.float32)
assert_allclose(data * 255., out_tex, atol=1)
assert_allclose(data * 255., out_rbo, atol=1)
def on_resize(self, event):
width, height = event.size
gloo.set_viewport(0, 0, width, height)
self.projection = ortho(0, width, 0, height, -100, 100)
self.u_size = width / 512.0
self.program['u_projection'] = self.projection
self.program['u_size'] = self.u_size
def test_text():
"""Test basic text support"""
# test a simple cases
data = (np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0],
[0, 0, 1, 1, 1, 1, 1, 0, 0]]) * 255).astype(np.uint8)
expd = (np.array([[8, 5, 4, 4, 4, 4, 4, 5, 8],
[5, 2, 1, 1, 1, 1, 1, 2, 5],
[4, 1, 0, 0, 0, 0, 0, 1, 4],
[4, 1, 0, -1, -4, -1, 0, 1, 4], # XXX artifact
[4, 1, 0, -1, -4, -1, 0, 1, 4],
[4, 1, 0, -1, -4, -1, 0, 1, 4]]))
expd = 0.5 - (np.sqrt(np.abs(expd)) * np.sign(expd)) / 256. * 8
expd = np.round(256 * expd).astype(np.int)
with Canvas(size=(100, 100)):
tex = gloo.Texture2D(shape=data.shape, dtype=np.ubyte, format='rgb')
SDFRenderer().render_to_texture(data, tex, (0, 0), data.shape[::-1])
gloo.set_viewport(0, 0, *data.shape[::-1])
gloo.util.draw_texture(tex)
result = gloo.util._screenshot()[:, :, 0].astype(np.int)
print(result)
print(expd)
assert_allclose(result, expd, atol=1)
def resize(self, width, height):
gloo.set_viewport(0, 0, width, height)
data_width = self._data_lim[0][1] - self._data_lim[0][0]
data_height = self._data_lim[1][1] - self._data_lim[1][0]
data_aspect = data_width / float(data_height)
frame_aspect = width / float(height)
if frame_aspect >= data_aspect:
padding = (frame_aspect * data_height - data_width) / 2.
frame_lim = [
[self._data_lim[0][0] - padding,
self._data_lim[0][1] + padding],
[self._data_lim[1][0],
self._data_lim[1][1]]]
else:
padding = (data_width / frame_aspect - data_height) / 2.
frame_lim = [
[self._data_lim[0][0],
self._data_lim[0][1]],
[self._data_lim[1][0] - padding,
self._data_lim[1][1] + padding]]
args_ortho = frame_lim[0][::(1 if self._dir_x_right else -1)]
args_ortho += frame_lim[1][::(1 if self._dir_y_top else -1)]
args_ortho += -1000, 1000
self.projection = ortho(*args_ortho)
self.program['projection'] = self.projection
def __init__(self):
app.Canvas.__init__(self, size=(512, 512),
keys='interactive')
self.image = Program(image_vertex, image_fragment, 4)
self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
self.image['vmin'] = +0.0
self.image['vmax'] = +1.0
self.image['cmap'] = 0 # Colormap index to use
self.image['colormaps'] = colormaps
self.image['n_colormaps'] = colormaps.shape[0]
self.image['image'] = I.astype('float32')
self.image['image'].interpolation = 'linear'
set_viewport(0, 0, *self.physical_size)
self.lines = Program(lines_vertex, lines_fragment)
self.lines["position"] = np.zeros((4+4+514+514, 2), np.float32)
color = np.zeros((4+4+514+514, 4), np.float32)
color[1:1+2, 3] = 0.25
color[5:5+2, 3] = 0.25
color[9:9+512, 3] = 0.5
color[523:523+512, 3] = 0.5
self.lines["color"] = color
set_state(clear_color='white', blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.show()
def __init__(self):
app.Canvas.__init__(self, size=(1024, 1024), title='Skybox example',
keys='interactive')
self.cubeSize = 10
self.pressed = False
self.azimuth = pi / 2.0
self.elevation = pi / 2.0
self.distanceMin = 1
self.distanceMax = 50
self.distance = 30
self.sensitivity = 5.0
self.view = getView(self.azimuth, self.elevation, self.distance)
self.model = np.eye(4, dtype=np.float32)
self.projection = np.eye(4, dtype=np.float32)
self.program = gloo.Program(vertex_shader, fragment_shader, count=24)
self.program['a_position'] = faces*self.cubeSize
self.program['a_texcoord'] = faces
self.program['a_texture'] = gloo.TextureCube(texture, interpolation='linear')
self.program['u_model'] = self.model
self.program['u_view'] = self.view
gloo.set_viewport(0, 0, *self.physical_size)
self.projection = perspective(60.0, self.size[0] /
float(self.size[1]), 1.0, 100.0)
self.program['u_projection'] = self.projection
gl.glEnable(gl.GL_DEPTH_TEST)
gloo.set_clear_color('black')
self.show()
def on_draw(self, ev):
test = self.physical_size
gloo.set_viewport(800, 0, *self.physical_size)
gloo.clear(color='white', depth=True)
for mesh in self.meshes:
mesh.draw()
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(800, 600))
self.vertices, self.filled, self.outline = cube()
self.filled_buf = gloo.IndexBuffer(self.filled)
self.outline_buf = gloo.IndexBuffer(self.outline)
self.program = gloo.Program(vert, frag)
self.program.bind(gloo.VertexBuffer(self.vertices))
self.view = translate((0, 0, -5))
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] /
float(self.size[1]), 2.0, 10.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
gloo.set_clear_color('white')
gloo.set_state('opaque')
gloo.set_polygon_offset(1, 1)
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
self.show()
def on_resize(self, event):
width, height = event.size
self.width=width
self.height=height
gloo.set_viewport(0, 0, width, height)
self.projection = ortho(-self.scale/2, self.scale/2, -self.scale/2, self.scale/2, -1, 100) #perspective(1.0, width / float(height), 1.0, 10000000.0)
self.program['u_projection'] = self.projection
def on_draw(self, event):
while os.path.exists(self.filename()):
self.frame += 1
if self.frame > self.anim_frames:
vispy.app.quit()
print("{:5d}/{}".format(self.frame, self.anim_frames))
self.fbo.activate()
gloo.set_state(depth_test=False, clear_color='black')
gloo.clear(color=True)
w, h = self.fbsize
gloo.set_viewport(0, 0, w, h)
self.render['aspect'] = w / h
self.render['width'] = w
self.render['frame'] = self.frame
self.render.draw('triangle_strip')
self.context.finish()
arr = self.fbo.read().copy()
arr[:, :, 3] = 255
img = Image.fromarray(arr)
img.save(self.filename())
self.frame += 1
self.update()
def __init__(self):
app.Canvas.__init__(self, keys='interactive', size=(W, H))
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
# Set uniform and attribute
self.program['a_id'] = gloo.VertexBuffer(a_id)
self.program['a_position'] = gloo.VertexBuffer(a_position)
self.translate = 5
self.view = translate((0, 0, -self.translate), dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] /
float(self.size[1]), 1.0, 1000.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.context.set_clear_color('white')
self.context.set_state('translucent')
self.timer = app.Timer('auto', connect=self.on_timer)
self.show()
def activate_zoom(self): self.width, self.height = self.size gloo.set_viewport(0, 0, *self.physical_size) vp = (0, 0, self.physical_size[0], self.physical_size[1]) gui.configure(canvas=self, viewport=vp) cars.configure(canvas=self, viewport=vp) field.set_needs_display()
def on_draw(self, event):
gloo.clear()
gloo.set_viewport(0, 0, self.camera.width, self.camera.height)
self.program['u_light_position'] = [100., 100., 500.]
self.program['u_is_lighting'] = True
self.program['u_model'] = self.camera.model
self.program['u_normal'] = self.camera.rotation
self.program['u_view'] = self.camera.view
self.program['u_projection'] = self.camera.projection
self.program['u_is_fog'] = self.camera.is_fog
self.program['u_fog_far'] = self.camera.fog_far
self.program['u_fog_near'] = self.camera.fog_near
self.program['u_fog_color'] = self.camera.fog_color
gl.glEnable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glDepthFunc(gl.GL_LEQUAL)
gl.glCullFace(gl.GL_FRONT)
gl.glEnable(gl.GL_CULL_FACE)
self.draw_buffers(self.program)
gl.glDisable(gl.GL_BLEND)
gl.glDisable(gl.GL_DEPTH_TEST)
gl.glDisable(gl.GL_CULL_FACE)
self.console.draw()
self.last_draw = 'screen'
self.update()
def on_draw(self, event):
'''TODO:
Make a better way to skip drawing...this is a hack at best
'''
gloo.set_viewport(0, 0, *self.size)
gloo.clear(color=True, depth=True)
self.rendering_world.draw(self.view)
def test_use_framebuffer():
"""Test drawing to a framebuffer"""
shape = (100, 300) # for some reason Windows wants a tall window...
data = np.random.rand(*shape).astype(np.float32)
use_shape = shape + (3,)
with Canvas(size=shape[::-1]) as c:
orig_tex = Texture2D(data)
fbo_tex = Texture2D(use_shape, format='rgb')
rbo = RenderBuffer(shape, 'color')
fbo = FrameBuffer(color=fbo_tex)
c.context.glir.set_verbose(True)
assert_equal(c.size, shape[::-1])
set_viewport((0, 0) + c.size)
with fbo:
draw_texture(orig_tex)
draw_texture(fbo_tex)
out_tex = _screenshot()[::-1, :, 0].astype(np.float32)
assert_equal(out_tex.shape, c.size[::-1])
assert_raises(TypeError, FrameBuffer.color_buffer.fset, fbo, 1.)
assert_raises(TypeError, FrameBuffer.depth_buffer.fset, fbo, 1.)
assert_raises(TypeError, FrameBuffer.stencil_buffer.fset, fbo, 1.)
fbo.color_buffer = rbo
fbo.depth_buffer = RenderBuffer(shape)
fbo.stencil_buffer = None
print((fbo.color_buffer, fbo.depth_buffer, fbo.stencil_buffer))
clear(color='black')
with fbo:
clear(color='black')
draw_texture(orig_tex)
out_rbo = _screenshot()[:, :, 0].astype(np.float32)
assert_allclose(data * 255., out_tex, atol=1)
assert_allclose(data * 255., out_rbo, atol=1)
def __init__(self, svbrdf, mesh, camera, size):
super().__init__(size, 0, 1000, camera, show=True)
gloo.set_state(depth_test=True)
gloo.set_viewport(0, 0, *self.size)
self.lights = [
Light((20, 30, 100), 2000),
Light((20, 30, -100), 2000),
Light((0, 100, 10), 2000),
]
vertex_positions = mesh.expand_face_vertices()
vertex_normals = mesh.expand_face_normals()
vertex_tangents, vertex_bitangents = mesh.expand_tangents()
vertex_uvs = mesh.expand_face_uvs()
material = SVBRDFMaterial(svbrdf)
self.renderables = [Renderable(material, {
'a_position': vertex_positions,
'a_normal': vertex_normals,
'a_tangent': vertex_tangents,
'a_bitangent': vertex_bitangents,
'a_uv': vertex_uvs,
}, len(self.lights))]
def on_resize(self, event):
self.width, self.height = event.size
# setup the new viewport
gloo.set_viewport(0, 0, self.width, self.height)
# recompute the projection matrix
self.projection = perspective(45.0, self.width / float(self.height),
1.0, 1000.0)
self.program['u_projection'] = self.projection
def on_resize(self, event):
width, height = event.size
gloo.set_viewport(0, 0, width, height)
self.projection = perspective(45.0, width / float(height), 1.0, 1000.0)
self.program_data['u_projection'] = self.projection
self.program_axis['u_projection'] = self.projection
self.program_plane['u_projection'] = self.projection
self.update()
def on_resize(self, event):
# setup the new viewport
gloo.set_viewport(0, 0, *event.physical_size)
# recompute the projection matrix
w, h = event.size
self.projection = perspective(45.0, w / float(h),
1.0, 1000.0)
self.program['u_projection'] = self.projection
def on_draw(self, event):
gloo.clear('black')
gloo.set_viewport(0, 0, *self.size)
self.program.draw('triangle_strip')
self.program2.draw('triangle_strip')
self.program3.draw('triangle_strip')
self.text.draw(self.tr_sys)
self.steptext.draw(self.tr_sys)
def on_resize(self, event):
width, height = event.size
self.size = event.size
gloo.set_viewport(0, 0, width, height)
self.aspect = width / float(height)
self.projection = perspective(45.0, width / float(height), 2,
10.0)
self.program_quad['u_projection'] = self.projection
def on_resize(self, event):
width, height = event.size
self.size = event.size
gloo.set_viewport(0, 0, width, height)
self.aspect = width / float(height)
self.projection = perspective(self.fovy, width / float(height), 1.0,
self.zfar)
self.program['u_projection'] = self.projection
def on_resize(self, event):
print "in on resize {e}".format(e=event)
if (self.myTextDrawer):
self.myTextDrawer.onChangeDimensions(event.physical_size[1],event.physical_size[0])
self.textVerticesArr = self.myTextDrawer.computeTextsData(self.positionsToTextMap)
self.textVertices = gloo.VertexBuffer(self.textVerticesArr)
self.progText.bind(self.textVertices)
gloo.set_viewport(0, 0, *event.physical_size)
def on_resize(self, event):
"""
We create a callback function called when the window is being resized.
Updating the OpenGL viewport lets us ensure that
Vispy uses the entire canvas.
"""
gloo.set_viewport(0, 0, *event.physical_size)
ratio = event.physical_size[0] / float(event.physical_size[1])
self.program['u_projection'] = perspective(45.0, ratio, 2.0, 10.0)
def draw(self):
if self._glsl:
fragment = fragment_template % self._glsl
self._glsl = None
# Check to see if the shader will compile successfully before we
# set it. We do this here because the ShaderWatcher runs in a
# different thread and so can't access the GL context.
frag_handle = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(frag_handle, fragment)
gl.glCompileShader(frag_handle)
status = gl.glGetShaderParameter(frag_handle, gl.GL_COMPILE_STATUS)
if not status:
errors = gl.glGetShaderInfoLog(frag_handle)
errors = self.process_errors(errors)
print("Shader failed to compile:", file=sys.stderr)
print(errors, file=sys.stderr)
# Switch to error shader
self._glsl = error_shader
self.update()
else:
self.program.set_shaders(vertex, fragment)
gl.glDeleteShader(frag_handle)
if self._interactive:
self.program.draw()
if self._ffmpeg_pipe is not None:
img = _screenshot()
self.write_video_frame(img)
self._render_frame_index += 1
if self._render_frame_count is not None and self._render_frame_index >= self._render_frame_count:
app.quit()
return
self.advance_time()
else:
with self._fbo:
rs = list(self._render_size)
if self._tile_coord[0] + rs[0] > self._output_size[0]:
rs[0] = self._output_size[0] - self._tile_coord[0]
if self._tile_coord[1] + rs[1] > self._output_size[1]:
rs[1] = self._output_size[1] - self._tile_coord[1]
gloo.set_viewport(0, 0, *rs)
self.program['iOffset'] = self._tile_coord
self.program.draw()
img = _screenshot()
row = self._output_size[1] - self._tile_coord[1] - rs[1]
col = self._tile_coord[0]
self._img[row:row + rs[1], col:col + rs[0], :] = img
def test_use_uniforms():
"""Test using uniform arrays"""
VERT_SHADER = """
attribute vec2 a_pos;
varying vec2 v_pos;
void main (void)
{
v_pos = a_pos;
gl_Position = vec4(a_pos, 0., 1.);
}
"""
FRAG_SHADER = """
varying vec2 v_pos;
uniform vec3 u_color[2];
void main()
{
gl_FragColor = vec4((u_color[0] + u_color[1]) / 2., 1.);
}
"""
shape = (500, 500)
with Canvas(size=shape) as c:
c.set_current()
c.context.glir.set_verbose(True)
assert_equal(c.size, shape[::-1])
shape = (3, 3)
set_viewport((0, 0) + shape)
program = Program(VERT_SHADER, FRAG_SHADER)
program['a_pos'] = [[-1., -1.], [1., -1.], [-1., 1.], [1., 1.]]
program['u_color'] = np.ones((2, 3))
c.context.clear('k')
c.set_current()
program.draw('triangle_strip')
out = _screenshot()
assert_allclose(out[:, :, 0] / 255., np.ones(shape), atol=1. / 255.)
# now set one element
program['u_color[1]'] = np.zeros(3, np.float32)
c.context.clear('k')
program.draw('triangle_strip')
out = _screenshot()
assert_allclose(out[:, :, 0] / 255., 127.5 / 255. * np.ones(shape),
atol=1. / 255.)
# and the other
assert_raises(ValueError, program.__setitem__, 'u_color',
np.zeros(3, np.float32))
program['u_color'] = np.zeros((2, 3), np.float32)
program['u_color[0]'] = np.ones(3, np.float32)
c.context.clear((0.33,) * 3)
program.draw('triangle_strip')
out = _screenshot()
assert_allclose(out[:, :, 0] / 255., 127.5 / 255. * np.ones(shape),
atol=1. / 255.)
def __init__(self):
app.Canvas.__init__(self, keys='interactive')
ps = self.pixel_scale
# Create boids
n = 1000
self.particles = np.zeros(2 + n, [('position', 'f4', 3),
('position_1', 'f4', 3),
('position_2', 'f4', 3),
('velocity', 'f4', 3),
('color', 'f4', 4),
('size', 'f4', 1*ps)])
self.boids = self.particles[2:]
self.target = self.particles[0]
self.predator = self.particles[1]
self.boids['position'] = np.random.uniform(-0.25, +0.25, (n, 3))
self.boids['velocity'] = np.random.uniform(-0.00, +0.00, (n, 3))
self.boids['size'] = 4*ps
self.boids['color'] = 1, 1, 1, 1
self.target['size'] = 16*ps
self.target['color'][:] = 1, 1, 0, 1
self.predator['size'] = 16*ps
self.predator['color'][:] = 1, 0, 0, 1
self.target['position'][:] = 0.25, 0.0, 0
# Time
self._t = time.time()
self._pos = 0.0, 0.0
self._button = None
width, height = self.physical_size
gloo.set_viewport(0, 0, width, height)
# Create program
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
# Create vertex buffers
self.vbo_position = gloo.VertexBuffer(self.particles['position']
.copy())
self.vbo_color = gloo.VertexBuffer(self.particles['color'].copy())
self.vbo_size = gloo.VertexBuffer(self.particles['size'].copy())
# Bind vertex buffers
self.program['color'] = self.vbo_color
self.program['size'] = self.vbo_size
self.program['position'] = self.vbo_position
gloo.set_state(clear_color=(0, 0, 0, 1), blend=True,
blend_func=('src_alpha', 'one'))
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def activate_zoom(self):
self.width, self.height = self.size
gloo.set_viewport(0, 0, *self.physical_size)
self.program_v['u_screen'] = (self.width, self.height)
def activate_zoom(self):
gloo.set_viewport(0, 0, *self.physical_size)
projection = ortho(0, self.size[0], 0, self.size[1], -1, +1)
self.program['u_projection'] = projection
def activate_zoom(self):
self.width, self.height = self.size
gloo.set_viewport(0, 0, *self.physical_size)
def on_draw(self, event):
gloo.clear(color='white')
gloo.set_viewport(0, 0, *self.physical_size)
self.text.draw(self.tr_sys)
def on_draw(self, ev):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear(color='black', depth=True)
for mesh in self.meshes:
mesh.draw()
def activate_zoom(self):
gloo.set_viewport(0, 0, *self.physical_size)
projection = perspective(45.0, self.size[0] / float(self.size[1]), 2.0,
10.0)
self.program['projection'] = projection
def on_resize(self, event):
gloo.set_viewport(0, 0, *event.physical_size)
def on_resize(event):
width, height = event.size
gloo.set_viewport(0, 0, width, height)
paths['viewport'] = 0, 0, width, height
def on_draw(self, ev):
gloo.set_clear_color('black')
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.size)
self.draw_visual(self.line)
P = np.array(P)
if len(P) < 2:
return
P = np.array(P) / 20.0 + (5, -2)
p = np.zeros((len(P), 3))
p[:, :2] = P
p = unique_rows(p)
if len(p) > 1:
paths.append(p, closed=True)
if len(p) > 2:
polys.append(p, color=color)
# Create the canvas.
canvas = app.Canvas(size=(800, 800), keys='interactive')
gloo.set_viewport(0, 0, canvas.size[0], canvas.size[1])
gloo.set_state("translucent", depth_test=False)
panzoom = PanZoomTransform(canvas, aspect=1)
paths = PathCollection(mode="agg+", color="global", transform=panzoom)
polys = PolygonCollection("raw", color="local", transform=panzoom)
paths.update.connect(canvas.update)
for feature in geo["features"]:
if feature["geometry"]["type"] == 'Polygon':
path = feature["geometry"]["coordinates"]
rgba = np.random.uniform(0.5, .8, 4)
rgba[3] = 1
add(path[0], color=rgba)
elif feature["geometry"]["type"] == 'MultiPolygon':
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.physical_size)
gloo.clear('white', depth=True)
self.cube.draw()
def on_draw(self, ev):
gloo.clear(color='black', depth=True)
gloo.set_viewport(0, 0, *self.physical_size)
# Create a TransformSystem that will tell the visual how to draw
for img in self.images:
img.draw(img.tr_sys)
def __init__(self, road_vbos, other_vbos, bbox, scale):
app.Canvas.__init__(self,
keys='interactive',
fullscreen=False,
size=(800.0, 800.0),
vsync=True)
gl.glEnable(gl.GL_MULTISAMPLE)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_CULL_FACE)
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
img = misc.imread('bullseye.png')
self.bullseye = gloo.Texture2D(img)
self.bullseye.interpolation = 'linear'
self.bullseye.wrapping = 'repeat'
self.wireframe = False
self.zoom = 0
self.road_vbos = []
self.road_ibo = []
self.other_vbos = []
self.single_vbo = []
self.single_ibo = []
self.tex_coords = []
self.l_bb_center = (np.array([bbox[2], bbox[3]]) -
np.array([bbox[0], bbox[1]])) * scale / 2.0
flattened_vbo = []
for vbo_info in road_vbos:
vbo = vbo_info[0]
color = vbo_info[1]
arr_bounded = scale_to_bb(vbo, bbox, scale)
new_vbo = generate_vbo(arr_bounded)
uv_coords = generate_tex_coords(new_vbo)
for p in new_vbo:
self.road_vbos.append(p)
for p in vbo:
flattened_vbo.append(p)
self.road_ibo = generate_ibo(flattened_vbo)
point_count = 0
for vbo_info in other_vbos:
vbo = vbo_info[0]
color = vbo_info[1]
vbo = scale_to_bb(vbo, bbox, scale)
self.other_vbos.append(gloo.VertexBuffer(vbo))
start_point = point_count
# first point
self.single_ibo.append(point_count)
for i, point in enumerate(vbo):
self.single_vbo.append(point)
if i > 0:
self.single_ibo.append(point_count)
self.single_ibo.append(point_count)
point_count += 1
self.single_ibo.append(start_point)
self.single_vbo = gloo.VertexBuffer(self.single_vbo)
self.single_ibo = gloo.IndexBuffer(self.single_ibo)
self.road_vbo = gloo.VertexBuffer(self.road_vbos)
self.road_ibo = gloo.IndexBuffer(self.road_ibo)
self.translate = 5.0
self.view = translate(
(-self.l_bb_center[0], -self.l_bb_center[1], -self.translate),
dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
1.0, 1000.0)
self.program['u_projection'] = self.projection
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.theta = 0
self.phi = 0
self.context.set_clear_color('white')
self.context.set_state('translucent')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def on_draw(self, event):
gloo.clear()
gloo.set_viewport(0, 0, *self.physical_size)
self.program.draw('line_strip')
[t.draw() for t in self.names + self.quality]
def on_resize(self, event):
gloo.set_viewport(0, 0, event.physical_size[0], event.physical_size[1])
self.projection = perspective(45.0,
event.size[0] / float(event.size[1]),
2.0, 10.0)
self.program['u_projection'] = self.projection
def __init__(self, lsl_inlet, scale=500, filt=True):
app.Canvas.__init__(self,
title='EEG - Use your wheel to zoom!',
keys='interactive')
self.inlet = lsl_inlet
info = self.inlet.info()
description = info.desc()
window = 10
self.sfreq = info.nominal_srate()
n_samples = int(self.sfreq * window)
self.n_chans = info.channel_count()
ch = description.child('channels').first_child()
ch_names = [ch.child_value('label')]
for i in range(self.n_chans):
ch = ch.next_sibling()
ch_names.append(ch.child_value('label'))
# Number of cols and rows in the table.
n_rows = self.n_chans
n_cols = 1
# Number of signals.
m = n_rows * n_cols
# Number of samples per signal.
n = n_samples
# Various signal amplitudes.
amplitudes = np.zeros((m, n)).astype(np.float32)
# gamma = np.ones((m, n)).astype(np.float32)
# Generate the signals as a (m, n) array.
y = amplitudes
color = color_palette("RdBu_r", n_rows)
color = np.repeat(color, n, axis=0).astype(np.float32)
# Signal 2D index of each vertex (row and col) and x-index (sample index
# within each signal).
index = np.c_[np.repeat(np.repeat(np.arange(n_cols), n_rows), n),
np.repeat(np.tile(np.arange(n_rows), n_cols), n),
np.tile(np.arange(n), m)].astype(np.float32)
self.program = gloo.Program(VERT_SHADER, FRAG_SHADER)
self.program['a_position'] = y.reshape(-1, 1)
self.program['a_color'] = color
self.program['a_index'] = index
self.program['u_scale'] = (1., 1.)
self.program['u_size'] = (n_rows, n_cols)
self.program['u_n'] = n
# text
self.font_size = 48.
self.names = []
self.quality = []
for ii in range(self.n_chans):
text = visuals.TextVisual(ch_names[ii], bold=True, color='white')
self.names.append(text)
text = visuals.TextVisual('', bold=True, color='white')
self.quality.append(text)
self.quality_colors = color_palette("RdYlGn", 11)[::-1]
self.scale = scale
self.n_samples = n_samples
self.filt = filt
self.af = [1.0]
self.data_f = np.zeros((n_samples, self.n_chans))
self.data = np.zeros((n_samples, self.n_chans))
self.bf = create_filter(self.data_f.T,
self.sfreq,
.5,
15.,
method='fir')
zi = lfilter_zi(self.bf, self.af)
self.filt_state = np.tile(zi, (self.n_chans, 1)).transpose()
self._timer = app.Timer('auto', connect=self.on_timer, start=True)
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_state(clear_color='black',
blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.show()
def _on_resize(self, event):
gloo.set_viewport(0, 0, *self._canvas.physical_size)
def on_resize(self, event):
width, height = event.size
gloo.set_viewport(0, 0, width, height)
self.projection = perspective(25.0, width / float(height), 2.0, 100.0)
self.program['u_projection'] = self.projection
def on_resize(self, event):
width, height = event.physical_size
set_viewport(0, 0, *event.physical_size)
def apply_zoom(self):
gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1])
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
1.0, 1000.0)
self.program['u_projection'] = self.projection
def on_resize(self, event):
""" canvas resize callback """
ratio = event.physical_size[0] / float(event.physical_size[1])
self.program['u_projection'] = perspective(45.0, ratio, 2.0, 10.0)
gloo.set_viewport(0, 0, *event.physical_size)
def on_resize(self, event):
self.width, self.height = event.size
gloo.set_viewport(0, 0, self.width, self.height)
def on_draw(self, event):
gloo.clear('black')
gloo.set_viewport(0, 0, *self.physical_size)
for visual in self.visuals:
visual.draw(visual.tr_sys)
def on_draw(self, event):
gloo.set_viewport(0, 0, *self.size)
gloo.clear('white')
self.tr_sys.auto_configure()
self.cube.draw(self.tr_sys)
def activate_zoom(self):
if self._interactive:
gloo.set_viewport(0, 0, *self.physical_size)
self.program['iResolution'] = (self.physical_size[0],
self.physical_size[1], 0.0)
def on_resize(self, event):
width, height = event.size
gloo.set_viewport(0, 0, width, height)
far = SIZE * (NBLOCKS - 2)
self.projection = perspective(25.0, width / float(height), 1.0, far)
self.program['u_projection'] = self.projection
def on_resize(self, event):
gloo.set_viewport(0, 0, *event.size)
def on_resize(self, event):
width, height = event.size
gloo.set_viewport(0, 0, width, height)
def activate_zoom(self):
width, height = self.size
gloo.set_viewport(0, 0, *self.physical_size)
self.program['u_aspect_ratio'] = width / float(height)
def __init__(self):
""" initialize the canvas """
app.Canvas.__init__(self,
size=(512, 512),
title='tetrahedron',
keys='interactive')
# shader program
tet = gloo.Program(vert=vertex, frag=fragment)
# vertices
V = np.array([(0, 0, 0),
(1, 0, 0),
(1.0/2.0, np.sqrt(3.0)/2.0, 0),
(1.0/2.0, np.sqrt(3.0)/6.0, np.sqrt(2.0/3.0))],
dtype=np.float32)
# triangles specified by connecting matrix,
# it can also be initialized using itertools
I = np.array([(0, 1, 2),
(0, 3, 1),
(0, 2, 3),
(1, 3, 2)], dtype=np.uint32)
# edges, used for drawing outline
E = np.array([(0, 1), (1, 2), (2, 0), (1, 3), (2, 3), (0, 3)],
dtype=np.uint32)
# colors of vertices
C = np.array([(1, 0, 0, 1),
(0, 1, 0, 1),
(0, 0, 1, 1),
(1, 1, 0, 1)], dtype=np.float32)
# bind to data
tet['a_position'] = V
tet['a_color'] = C
self.I = gloo.IndexBuffer(I)
self.E = gloo.IndexBuffer(E)
# intialize transformation matrix
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
projection = np.eye(4, dtype=np.float32)
# set view
view = translate((0, 0, -5))
tet['u_model'] = model
tet['u_view'] = view
tet['u_projection'] = projection
# bind your program
self.program = tet
# config and set viewport
gloo.set_viewport(0, 0, *self.physical_size)
gloo.set_clear_color('white')
gloo.set_state('translucent')
gloo.set_polygon_offset(1.0, 1.0)
# bind a timer
self.timer = app.Timer('auto', self.on_timer)
self.theta = 0.0
self.phi = 0.0
self.timer.start()
# show the canvas
self.show()
