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()