def test_import_vispy_scene(): """ Importing vispy.gloo.gl.desktop should not import PyOpenGL. """ modnames = loaded_vispy_modules('vispy.scene', 2) more_modules = ['vispy.app', 'vispy.gloo', 'vispy.glsl', 'vispy.scene', 'vispy.color', 'vispy.io', 'vispy.geometry', 'vispy.visuals'] assert_equal(modnames, set(_min_modules + more_modules))
def test_config(): """Test vispy config methods and file downloading""" assert_raises(TypeError, config.update, data_path=dict()) assert_raises(KeyError, config.update, foo="bar") # bad key data_dir = op.join(temp_dir, "data") assert_raises(IOError, set_data_dir, data_dir) # didn't say to create orig_val = os.environ.get("_VISPY_CONFIG_TESTING", None) os.environ["_VISPY_CONFIG_TESTING"] = "true" try: assert_raises(IOError, set_data_dir, data_dir) # doesn't exist yet set_data_dir(data_dir, create=True, save=True) assert_equal(config["data_path"], data_dir) config["data_path"] = data_dir print(config) # __repr__ load_data_file("CONTRIBUTING.txt") fid = open(op.join(data_dir, "test-faked.txt"), "w") fid.close() load_data_file("test-faked.txt") # this one shouldn't download assert_raises(RuntimeError, load_data_file, "foo-nonexist.txt") save_config() finally: if orig_val is not None: os.environ["_VISPY_CONFIG_TESTING"] = orig_val else: del os.environ["_VISPY_CONFIG_TESTING"]
def test_context_properties(): """Test setting context properties""" a = use_app() if a.backend_name.lower() == 'pyglet': return # cannot set more than once on Pyglet # stereo, double buffer won't work on every sys configs = [dict(samples=4), dict(stencil_size=8), dict(samples=4, stencil_size=8)] if a.backend_name.lower() != 'glfw': # glfw *always* double-buffers configs.append(dict(double_buffer=False, samples=4)) configs.append(dict(double_buffer=False)) else: assert_raises(RuntimeError, Canvas, app=a, config=dict(double_buffer=False)) if a.backend_name.lower() == 'sdl2' and os.getenv('TRAVIS') == 'true': raise SkipTest('Travis SDL cannot set context') for config in configs: n_items = len(config) with Canvas(config=config): if 'true' in (os.getenv('TRAVIS', ''), os.getenv('APPVEYOR', '').lower()): # Travis and Appveyor cannot handle obtaining these values props = config else: props = get_gl_configuration() assert_equal(len(config), n_items) for key, val in config.items(): # XXX knownfail for windows samples, and wx (all platforms) if key == 'samples': iswx = a.backend_name.lower() == 'wx' if not (sys.platform.startswith('win') or iswx): assert_equal(val, props[key], key) assert_raises(TypeError, Canvas, config='foo') assert_raises(KeyError, Canvas, config=dict(foo=True)) assert_raises(TypeError, Canvas, config=dict(double_buffer='foo'))
def test_FunctionChain(): f1 = Function("void f1(){}") f2 = Function("void f2(){}") f3 = Function("float f3(vec3 x){}") f4 = Function("vec3 f4(vec3 y){}") f5 = Function("vec3 f5(vec4 z){}") ch = FunctionChain('chain', [f1, f2]) assert ch.name == 'chain' assert ch.args == [] assert ch.rtype == 'void' assert_in('f1', ch.compile()) assert_in('f2', ch.compile()) ch.remove(f2) assert_not_in('f2', ch.compile()) ch.append(f2) assert_in('f2', ch.compile()) ch = FunctionChain(funcs=[f5, f4, f3]) assert_equal('float', ch.rtype) assert_equal([('vec4', 'z')], ch.args) assert_in('f3', ch.compile()) assert_in('f4', ch.compile()) assert_in('f5', ch.compile()) assert_in(f3, ch.dependencies()) assert_in(f4, ch.dependencies()) assert_in(f5, ch.dependencies())
def test_use(): # Set default app to None, so we can test the use function vispy.app.use_app() default_app = vispy.app._default_app.default_app vispy.app._default_app.default_app = None app_name = default_app.backend_name.split(' ')[0] try: # With no arguments, should do nothing assert_raises(TypeError, vispy.use) assert_equal(vispy.app._default_app.default_app, None) # With only gl args, should do nothing to app vispy.use(gl='gl2') assert_equal(vispy.app._default_app.default_app, None) # Specify app (one we know works) vispy.use(app_name) assert_not_equal(vispy.app._default_app.default_app, None) # Again, but now wrong app wrong_name = 'glfw' if app_name.lower() != 'glfw' else 'pyqt4' assert_raises(RuntimeError, vispy.use, wrong_name) # And both vispy.use(app_name, 'gl2') finally: # Restore vispy.app._default_app.default_app = default_app
def test_FunctionCall(): fun = Function(transformScale) fun['scale'] = '1.0' fun2 = Function(transformZOffset) # No args assert_raises(TypeError, fun) # need 1 arg assert_raises(TypeError, fun, 1, 2) # need 1 arg call = fun('x') # Test repr exp = call.expression({fun: 'y'}) assert_equal(exp, 'y(x)') # Test sig assert len(call._args) == 1 # Test dependencies assert_in(fun, call.dependencies()) assert_in(call._args[0], call.dependencies()) # More args call = fun(fun2('foo')) # Test repr exp = call.expression({fun: 'y', fun2: 'z'}) assert_in('y(z(', exp) # Test sig assert len(call._args) == 1 call2 = call._args[0] assert len(call2._args) == 1 # Test dependencies assert_in(fun, call.dependencies()) assert_in(call._args[0], call.dependencies()) assert_in(fun2, call.dependencies()) assert_in(call2._args[0], call.dependencies())
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 test_event_order(): """Test event order""" x = list() class MyCanvas(Canvas): def on_initialize(self, event): x.append('init') def on_draw(self, event): sz = True if self.size is not None else False x.append('draw size=%s show=%s' % (sz, show)) def on_close(self, event): x.append('close') for show in (False, True): # clear our storage variable while x: x.pop() with MyCanvas(show=show) as c: c.update() c.app.process_events() print(x) assert_true(len(x) >= 3) assert_equal(x[0], 'init') assert_in('draw size=True', x[1]) assert_in('draw size=True', x[-2]) assert_equal(x[-1], 'close')
def test_serialize_command(): command = ('CREATE', 4, 'VertexBuffer') command_serialized = _serialize_command(command) assert_equal(command_serialized, list(command)) command = ('UNIFORM', 4, 'u_scale', 'vec3', (1, 2, 3)) commands_serialized_expected = ['UNIFORM', 4, 'u_scale', 'vec3', [1, 2, 3]] command_serialized = _serialize_command(command) assert_equal(command_serialized, commands_serialized_expected)
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 test_key(): """Test basic key functionality""" def bad(): return (ENTER == dict()) assert_raises(ValueError, bad) assert_true(not (ENTER == None)) # noqa assert_equal('Return', ENTER) print(ENTER.name) print(ENTER) # __repr__ assert_equal(Key('1'), 49) # ASCII code
def test_close_keys(): """Test close keys""" c = Canvas(keys='interactive') x = list() @c.events.close.connect def closer(event): x.append('done') c.events.key_press(key=keys.ESCAPE, text='', modifiers=[]) assert_equal(len(x), 1) # ensure the close event was sent c.app.process_events()
def test_create_glir_message_binary(): arr = np.zeros((3, 2)).astype(np.float32) arr2 = np.ones((4, 5)).astype(np.int16) commands = [('CREATE', 1, 'VertexBuffer'), ('UNIFORM', 2, 'u_scale', 'vec3', (1, 2, 3)), ('DATA', 3, 0, arr), ('UNIFORM', 4, 'u_pan', 'vec2', np.array([1, 2, 3])), ('DATA', 5, 20, arr2)] msg = create_glir_message(commands) assert_equal(msg['msg_type'], 'glir_commands') commands_serialized = msg['commands'] assert_equal(commands_serialized, [['CREATE', 1, 'VertexBuffer'], ['UNIFORM', 2, 'u_scale', 'vec3', [1, 2, 3]], ['DATA', 3, 0, {'buffer_index': 0, 'buffer_shape': [3, 2], 'buffer_dtype': 'float32'}], ['UNIFORM', 4, 'u_pan', 'vec2', [1, 2, 3]], ['DATA', 5, 20, {'buffer_index': 1, 'buffer_shape': [4, 5], 'buffer_dtype': 'int16'}]]) buffers_serialized = msg['buffers'] buf0 = buffers_serialized[0] assert_equal(buf0, b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00') # noqa buf1 = buffers_serialized[1] assert_equal(buf1, b'\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00\x01\x00') # noqa
def test_import_vispy_scene(): """ Importing vispy.gloo.gl.desktop should not import PyOpenGL. """ modnames = loaded_vispy_modules("vispy.scene", 2) more_modules = [ "vispy.app", "vispy.gloo", "vispy.glsl", "vispy.scene", "vispy.color", "vispy.io", "vispy.geometry", "vispy.visuals", ] assert_equal(modnames, set(_min_modules + more_modules))
def test_logging(): """Test logging context manager""" ll = logger.level with use_log_level('warning', print_msg=False): assert_equal(logger.level, logging.WARN) assert_equal(logger.level, ll) with use_log_level('debug', print_msg=False): assert_equal(logger.level, logging.DEBUG) assert_equal(logger.level, ll)
def test_wavefront(): """Test wavefront reader""" fname_mesh = load_data_file('orig/triceratops.obj.gz') fname_out = op.join(temp_dir, 'temp.obj') mesh1 = read_mesh(fname_mesh) assert_raises(IOError, read_mesh, 'foo.obj') assert_raises(ValueError, read_mesh, op.abspath(__file__)) assert_raises(ValueError, write_mesh, fname_out, *mesh1, format='foo') write_mesh(fname_out, mesh1[0], mesh1[1], mesh1[2], mesh1[3]) assert_raises(IOError, write_mesh, fname_out, *mesh1) write_mesh(fname_out, *mesh1, overwrite=True) mesh2 = read_mesh(fname_out) assert_equal(len(mesh1), len(mesh2)) for m1, m2 in zip(mesh1, mesh2): if m1 is None: assert_equal(m2, None) else: assert_allclose(m1, m2, rtol=1e-5) # test our efficient normal calculation routine assert_allclose(mesh1[2], _slow_calculate_normals(mesh1[0], mesh1[1]), rtol=1e-7, atol=1e-7)
def test_transforms(): """Test basic transforms""" xfm = np.random.randn(4, 4).astype(np.float32) # Do a series of rotations that should end up into the same orientation # again, to ensure the order of computation is all correct # i.e. if rotated would return the transposed matrix this would not work # out (the translation part would be incorrect) new_xfm = xfm.dot(rotate(180, (1, 0, 0)).dot(rotate(-90, (0, 1, 0)))) new_xfm = new_xfm.dot(rotate(90, (0, 0, 1)).dot(rotate(90, (0, 1, 0)))) new_xfm = new_xfm.dot(rotate(90, (1, 0, 0))) assert_allclose(xfm, new_xfm) new_xfm = translate((1, -1, 1)).dot(translate((-1, 1, -1))).dot(xfm) assert_allclose(xfm, new_xfm) new_xfm = scale((1, 2, 3)).dot(scale((1, 1. / 2., 1. / 3.))).dot(xfm) assert_allclose(xfm, new_xfm) # These could be more complex... xfm = ortho(-1, 1, -1, 1, -1, 1) assert_equal(xfm.shape, (4, 4)) xfm = frustum(-1, 1, -1, 1, -1, 1) assert_equal(xfm.shape, (4, 4)) xfm = perspective(1, 1, -1, 1) assert_equal(xfm.shape, (4, 4))
def test_context_config(): """ Test GLContext handling of config dict """ default_config = get_default_config() # Pass default config unchanged c = GLContext(default_config) assert_equal(c.config, default_config) # Must be deep copy c.config['double_buffer'] = False assert_not_equal(c.config, default_config) # Passing nothing should yield default config c = GLContext() assert_equal(c.config, default_config) # Must be deep copy c.config['double_buffer'] = False assert_not_equal(c.config, default_config) # This should work c = GLContext({'red_size': 4, 'double_buffer': False}) assert_equal(c.config.keys(), default_config.keys()) # Passing crap should raise assert_raises(KeyError, GLContext, {'foo': 3}) assert_raises(TypeError, GLContext, {'double_buffer': 'not_bool'})
def test_transforms(): """Test basic transforms""" xfm = np.random.randn(4, 4).astype(np.float32) for rot in [xrotate, yrotate, zrotate]: new_xfm = rot(rot(xfm, 90), -90) assert_allclose(xfm, new_xfm) new_xfm = rotate(rotate(xfm, 90, 1, 0, 0), 90, -1, 0, 0) assert_allclose(xfm, new_xfm) new_xfm = translate(translate(xfm, 1, -1), 1, -1, 1) assert_allclose(xfm, new_xfm) new_xfm = scale(scale(xfm, 1, 2, 3), 1, 1. / 2., 1. / 3.) assert_allclose(xfm, new_xfm) # These could be more complex... xfm = ortho(-1, 1, -1, 1, -1, 1) assert_equal(xfm.shape, (4, 4)) xfm = frustum(-1, 1, -1, 1, -1, 1) assert_equal(xfm.shape, (4, 4)) xfm = perspective(1, 1, -1, 1) assert_equal(xfm.shape, (4, 4))
def test_color_conversion(): """Test color conversions""" # HSV # test known values test = ColorArray() for key in hsv_dict: c = ColorArray(key) test.hsv = hsv_dict[key] assert_allclose(c.RGB, test.RGB, atol=1) test.value = 0 assert_equal(test.value, 0) assert_equal(test, ColorArray('black')) c = ColorArray('black') assert_array_equal(c.hsv.ravel(), (0, 0, 0)) rng = np.random.RandomState(0) for _ in range(50): hsv = rng.rand(3) hsv[0] *= 360 hsv[1] = hsv[1] * 0.99 + 0.01 # avoid ugly boundary effects hsv[2] = hsv[2] * 0.99 + 0.01 c.hsv = hsv assert_allclose(c.hsv.ravel(), hsv, rtol=1e-4, atol=1e-4) # Lab test = ColorArray() for key in lab_dict: c = ColorArray(key) test.lab = lab_dict[key] assert_allclose(c.rgba, test.rgba, atol=1e-4, rtol=1e-4) assert_allclose(test.lab.ravel(), lab_dict[key], atol=1e-4, rtol=1e-4) for _ in range(50): # boundaries can have ugly rounding errors in some parameters rgb = (rng.rand(3)[np.newaxis, :] * 0.9 + 0.05) c.rgb = rgb lab = c.lab c.lab = lab assert_allclose(c.lab, lab, atol=1e-4, rtol=1e-4) assert_allclose(c.rgb, rgb, atol=1e-4, rtol=1e-4)
def test_read_pixels(): """Test read_pixels to ensure that the image is not flipped""" # Create vertices vPosition = np.array([[-1, 1], [0, 1], # For drawing a square to top left [-1, 0], [0, 0]], np.float32) VERT_SHADER = """ // simple vertex shader attribute vec2 a_position; void main (void) { gl_Position = vec4(a_position, 0., 1.0); } """ FRAG_SHADER = """ // simple fragment shader void main() { gl_FragColor = vec4(1,1,1,1); } """ with Canvas() as c: gloo.set_viewport(0, 0, *c.size) c._program = gloo.Program(VERT_SHADER, FRAG_SHADER) c._program['a_position'] = gloo.VertexBuffer(vPosition) gloo.clear(color='black') c._program.draw('triangle_strip') # Check if the return of read_pixels is the same as our drawing img = read_pixels(alpha=False) assert_equal(img.shape[:2], c.size[::-1]) top_left = sum(img[0, 0]) assert_true(top_left > 0) # Should be > 0 (255*4) # Sum of the pixels in top right + bottom left + bottom right corners corners = sum(img[0, -1] + img[-1, 0] + img[-1, -1]) assert_true(corners == 0) # Should be all 0 gloo.flush() gloo.finish()
def test_wrappers(): """Test gloo wrappers""" with Canvas(): gl.use_gl('gl2 debug') gloo.clear('#112233') # make it so that there's something non-zero # check presets assert_raises(ValueError, gloo.set_state, preset='foo') for state in gloo.get_state_presets().keys(): gloo.set_state(state) assert_raises(ValueError, gloo.set_blend_color, (0., 0.)) # bad color assert_raises(TypeError, gloo.set_hint, 1, 2) # need strs # this doesn't exist in ES 2.0 namespace assert_cmd_raises(ValueError, gloo.set_hint, 'fog_hint', 'nicest') # test bad enum assert_raises(RuntimeError, gloo.set_line_width, -1) # check read_pixels x = gloo.read_pixels() assert_true(isinstance(x, np.ndarray)) assert_true(isinstance(gloo.read_pixels((0, 0, 1, 1)), np.ndarray)) assert_raises(ValueError, gloo.read_pixels, (0, 0, 1)) # bad port y = gloo.read_pixels(alpha=False, out_type=np.ubyte) assert_equal(y.shape, x.shape[:2] + (3,)) assert_array_equal(x[..., :3], y) y = gloo.read_pixels(out_type='float') assert_allclose(x/255., y) # now let's (indirectly) check our set_* functions viewport = (0, 0, 1, 1) blend_color = (0., 0., 0.) _funs = dict(viewport=viewport, # checked hint=('generate_mipmap_hint', 'nicest'), depth_range=(1., 2.), front_face='cw', # checked cull_face='front', line_width=1., polygon_offset=(1., 1.), blend_func=('zero', 'one'), blend_color=blend_color, blend_equation='func_add', scissor=(0, 0, 1, 1), stencil_func=('never', 1, 2, 'back'), stencil_mask=4, stencil_op=('zero', 'zero', 'zero', 'back'), depth_func='greater', depth_mask=True, color_mask=(True, True, True, True), sample_coverage=(0.5, True)) gloo.set_state(**_funs) gloo.clear((1., 1., 1., 1.), 0.5, 1) gloo.flush() gloo.finish() # check some results assert_array_equal(gl.glGetParameter(gl.GL_VIEWPORT), viewport) assert_equal(gl.glGetParameter(gl.GL_FRONT_FACE), gl.GL_CW) assert_equal(gl.glGetParameter(gl.GL_BLEND_COLOR), blend_color + (1,))
def test_use_texture3D(): """Test using a 3D texture""" vals = [0, 200, 100, 0, 255, 0, 100] d, h, w = len(vals), 3, 5 data = np.zeros((d, h, w), np.float32) 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 = """ uniform sampler3D u_texture; varying vec2 v_pos; uniform float i; void main() { gl_FragColor = texture3D(u_texture, vec3((v_pos.y+1.)/2., (v_pos.x+1.)/2., i)); gl_FragColor.a = 1.; } """ # populate the depth "slices" with different gray colors in the bottom left for ii, val in enumerate(vals): data[ii, :2, :3] = val / 255. with Canvas(size=(100, 100)) as c: if not has_pyopengl(): t = Texture3D(data) assert_raises(ImportError, t.glir.flush, c.context.shared.parser) return program = Program(VERT_SHADER, FRAG_SHADER) program['a_pos'] = [[-1., -1.], [1., -1.], [-1., 1.], [1., 1.]] tex = Texture3D(data, interpolation='nearest') assert_equal(tex.width, w) assert_equal(tex.height, h) assert_equal(tex.depth, d) program['u_texture'] = tex for ii, val in enumerate(vals): set_viewport(0, 0, w, h) clear(color='black') iii = (ii + 0.5) / float(d) print(ii, iii) program['i'] = iii program.draw('triangle_strip') out = _screenshot()[:, :, 0].astype(int)[::-1] expected = np.zeros_like(out) expected[:2, :3] = val assert_allclose(out, expected, atol=1./255.)
def test_fs(): """Test fullscreen support""" a = use_app() if not a.backend_module.capability['fullscreen']: return assert_raises(TypeError, Canvas, fullscreen='foo') if (a.backend_name.lower() == 'glfw' or (a.backend_name.lower() == 'sdl2' and sys.platform == 'darwin')): raise SkipTest('Backend takes over screen') with use_log_level('warning', record=True, print_msg=False) as emit_list: with Canvas(fullscreen=False) as c: assert_equal(c.fullscreen, False) c.fullscreen = True assert_equal(c.fullscreen, True) assert_equal(len(emit_list), 0) with use_log_level('warning', record=True, print_msg=False): # some backends print a warning b/c fullscreen can't be specified with Canvas(fullscreen=0) as c: assert_equal(c.fullscreen, True)
def test_debug_logging(): """Test advanced debugging logging""" with use_log_level('debug', 'Selected', True, False) as l: logger.debug('Selected foo') assert_equal(len(l), 1) assert_in('test_logging', l[0]) # can't really parse this location with use_log_level('debug', record=True, print_msg=False) as l: logger.debug('foo') assert_equal(len(l), 1) assert_in('test_logging', l[0]) with use_log_level('debug', 'foo', True, False) as l: logger.debug('bar') assert_equal(len(l), 0) with use_log_level('info', record=True, print_msg=False) as l: logger.debug('foo') logger.info('bar') assert_equal(len(l), 1) assert_not_in('unknown', l[0])
def _test_fbo(): w, h = 120, 130 # Create frame buffer hframebuf = gl.glCreateFramebuffer() gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, hframebuf) #Create render buffer (for depth) hrenderbuf = gl.glCreateRenderbuffer() gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, hrenderbuf) gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH_COMPONENT16, w, h) gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_RENDERBUFFER, hrenderbuf) # Create texture (for color) htex = gl.glCreateTexture() gl.glBindTexture(gl.GL_TEXTURE_2D, htex) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, (h, w)) gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0, gl.GL_TEXTURE_2D, htex, 0) # Check framebuffer status status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER) assert_equal(status, gl.GL_FRAMEBUFFER_COMPLETE) # Tests renderbuffer params name = gl.glGetFramebufferAttachmentParameter( gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT, gl.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) assert_equal(name, hrenderbuf) # width = gl.glGetRenderbufferParameter(gl.GL_RENDERBUFFER, gl.GL_RENDERBUFFER_WIDTH) assert_equal(width, w) # Touch copy tex functions gl.glBindTexture(gl.GL_TEXTURE_2D, htex) gl.glCopyTexSubImage2D(gl.GL_TEXTURE_2D, 0, 5, 5, 5, 5, 20, 20) gl.glCopyTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, 0, 0, 30, 30, 0) gl.check_error() # Clean up gl.glDeleteTexture(htex) gl.glDeleteRenderbuffer(hrenderbuf) gl.glDeleteFramebuffer(hframebuf) gl.check_error()
def test_color(): """Basic tests for Color class""" x = Color('white') assert_array_equal(x.rgba, [1.] * 4) assert_array_equal(x.rgb, [1.] * 3) assert_array_equal(x.RGBA, [255] * 4) assert_array_equal(x.RGB, [255] * 3) assert_equal(x.value, 1.) assert_equal(x.alpha, 1.) x.rgb = [0, 0, 1] assert_array_equal(x.hsv, [240, 1, 1]) assert_equal(x.hex, '#0000ff') x.hex = '#00000000' assert_array_equal(x.rgba, [0.]*4)
def _check_result(assert_result=True): """ Test the color of each quadrant by picking the center pixel of each quadrant and comparing it with the reference color. """ # Take screenshot x, y, w, h = gl.glGetParameter(gl.GL_VIEWPORT) data = gl.glReadPixels(x, y, w, h, gl.GL_RGB, gl.GL_UNSIGNED_BYTE) im = np.frombuffer(data, np.uint8) im.shape = h, w, 3 # Get center pixel from each quadrant pix1 = tuple(im[int(1*h/4), int(1*w/4)]) pix2 = tuple(im[int(3*h/4), int(1*w/4)]) pix3 = tuple(im[int(3*h/4), int(3*w/4)]) pix4 = tuple(im[int(1*h/4), int(3*w/4)]) #print(pix1, pix2, pix3, pix4) if assert_result: # Test their value assert_equal(pix1, (0, 0, 0)) assert_equal(pix2, (255, 0, 0)) assert_equal(pix3, (0, 255, 0)) assert_equal(pix4, (0, 0, 255))
def _test_setting_parameters(): # Set some parameters and get result clr = 1.0, 0.1, 0.2, 0.7 gl.glClearColor(*clr) assert_almost_equal(gl.glGetParameter(gl.GL_COLOR_CLEAR_VALUE), clr) # gl.glCullFace(gl.GL_FRONT) assert_equal(gl.glGetParameter(gl.GL_CULL_FACE_MODE), gl.GL_FRONT) gl.glCullFace(gl.GL_BACK) assert_equal(gl.glGetParameter(gl.GL_CULL_FACE_MODE), gl.GL_BACK) # gl.glDepthFunc(gl.GL_NOTEQUAL) assert_equal(gl.glGetParameter(gl.GL_DEPTH_FUNC), gl.GL_NOTEQUAL) # val = 0.2, 0.3 gl.glDepthRange(*val) assert_almost_equal(gl.glGetParameter(gl.GL_DEPTH_RANGE), val) gl.check_error()
def _test_enabling_disabling(): # Enabling/disabling gl.glEnable(gl.GL_DEPTH_TEST) assert_equal(gl.glIsEnabled(gl.GL_DEPTH_TEST), True) assert_equal(gl.glGetParameter(gl.GL_DEPTH_TEST), 1) gl.glDisable(gl.GL_DEPTH_TEST) assert_equal(gl.glIsEnabled(gl.GL_DEPTH_TEST), False) assert_equal(gl.glGetParameter(gl.GL_DEPTH_TEST), 0) # gl.glEnable(gl.GL_BLEND) assert_equal(gl.glIsEnabled(gl.GL_BLEND), True) assert_equal(gl.glGetParameter(gl.GL_BLEND), 1) gl.glDisable(gl.GL_BLEND) assert_equal(gl.glIsEnabled(gl.GL_BLEND), False) assert_equal(gl.glGetParameter(gl.GL_BLEND), 0) gl.check_error()
def test_import_vispy_util(): """Importing vispy.util should not pull in other vispy submodules.""" modnames = loaded_vispy_modules('vispy.util', 2) assert_equal(modnames, set(_min_modules))
def test_Variable(): # Test init fail assert_raises(TypeError, Variable) # no args assert_raises(TypeError, Variable, 3) # wrong type assert_raises(TypeError, Variable, "name", "str") # wrong type assert_raises(ValueError, Variable, 'bla bla') # need correct vtype assert_raises(ValueError, Variable, 'uniform b l a') # too many # Test init success var = Variable('uniform float bla') # Finally assert_equal(var.name, 'bla') assert_equal(var.dtype, 'float') assert_equal(var.vtype, 'uniform') assert var.value is None # test assign new value var.value = 10. assert_equal(var.dtype, 'float') # type is locked; won't change # test name-only init var = Variable('bla') # Finally assert_equal(var.name, 'bla') assert_equal(var.dtype, None) assert_equal(var.vtype, None) assert var.value is None # test assign new value var.value = 10 assert_equal(var.dtype, 'int') assert_equal(var.vtype, 'uniform') assert_equal(var.value, 10) # test init with value var = Variable('bla', (1, 2, 3)) # Also valid assert_equal(var.name, 'bla') assert_equal(var.dtype, 'vec3') assert_equal(var.vtype, 'uniform') assert_equal(var.value, (1, 2, 3)) # Test value # var = Variable('uniform float bla', data) # Also valid # assert_equal(var.value, data) # var.value = 3 # assert_equal(var.value, 3) # Test repr var = Variable('uniform float bla') assert_in('uniform float bla', var.compile()) # Test injection, definition, dependencies assert_equal(var.expression({var: 'xxx'}), 'xxx') assert_equal(var.definition({var: 'xxx'}, ('120', ''), None), 'uniform float xxx;') assert_in(var, var.dependencies()) # Renaming var = Variable('uniform float bla') assert_equal(var.name, 'bla') var.name = 'foo' assert_equal(var.name, 'foo')
def test_event_connect_order(): """Test event connection order""" def a(): return def b(): return def c(): return def d(): return def e(): return def f(): return em = EventEmitter(type='test_event') assert_raises(ValueError, em.connect, c, before=['c', 'foo']) assert_raises(ValueError, em.connect, c, position='foo') assert_raises(TypeError, em.connect, c, ref=dict()) em.connect(c, ref=True) assert_equal((c,), tuple(em.callbacks)) em.connect(c) assert_equal((c,), tuple(em.callbacks)) em.connect(d, ref=True, position='last') assert_equal((c, d), tuple(em.callbacks)) em.connect(b, ref=True) # position='first' assert_equal((b, c, d), tuple(em.callbacks)) assert_raises(RuntimeError, em.connect, a, before='c', after='d') # can't em.connect(a, ref=True, before=['c', 'd']) # first possible pos == 0 assert_equal((a, b, c, d), tuple(em.callbacks)) em.connect(f, ref=True, after=['c', 'd']) assert_equal((a, b, c, d, f), tuple(em.callbacks)) em.connect(e, ref=True, after='d', before='f') assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) em.disconnect(e) em.connect(e, ref=True, after='a', before='f', position='last') assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) em.disconnect(e) em.connect(e, ref='e', after='d', before='f', position='last') assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) em.disconnect(e) em.connect(e, after='d', before='f', position='first') # no name assert_equal(('a', 'b', 'c', 'd', None, 'f'), tuple(em.callback_refs)) em.disconnect(e) assert_raises(ValueError, em.connect, e, ref='d') # duplicate name em.connect(e, ref=True, after=[], before='f', position='last') assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) assert_equal((a, b, c, d, e, f), tuple(em.callbacks)) old_e = e def e(): return assert_raises(ValueError, em.connect, e, ref=True) # duplicate name em.connect(e) assert_equal((None, 'a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) assert_equal((e, a, b, c, d, old_e, f), tuple(em.callbacks))
def test_TextExpression(): exp = TextExpression('foo bar') assert_equal('foo bar', exp.expression(None)) assert_equal(None, exp.definition(None, ('120', ''))) assert_raises(TypeError, TextExpression, 4)
def test_function_basics(): # Test init fail assert_raises(TypeError, Function) # no args assert_raises(ValueError, Function, 3) # need string # Test init success 1 fun = Function('void main(){}') assert_equal(fun.name, 'main') assert len(fun.template_vars) == 0 # Test init success with template vars fun = Function('void main(){$foo; $bar;}') assert_equal(fun.name, 'main') assert len(fun.template_vars) == 2 assert_in('foo', fun.template_vars) assert_in('bar', fun.template_vars) # Test setting verbatim expressions assert_raises(KeyError, fun.__setitem__, 'bla', '33') # no such template fun['foo'] = '33' fun['bar'] = 'bla bla' assert_is(type(fun['foo']), TextExpression) assert_equal(fun['foo'].expression(None), '33') assert_is(type(fun['bar']), TextExpression) assert_equal(fun['bar'].expression(None), 'bla bla') # Test setting call expressions fun = Function('void main(){\n$foo;\n$bar;\n$spam(XX);\n$eggs(YY);\n}') trans = Function('float transform_scale(float x) {return x+1.0;}') assert_raises(TypeError, trans) # requires 1 arg assert_raises(TypeError, trans, '1', '2') fun['foo'] = trans('2') fun['bar'] = trans('3') fun['spam'] = trans fun['eggs'] = trans # for name in ['foo', 'bar']: assert_is(type(fun[name]), FunctionCall) assert_equal(fun[name].function, trans) assert_in(trans, fun.dependencies()) for name in ['spam', 'eggs']: assert_equal(fun[name], trans) # text = fun.compile() assert_in('\ntransform_scale(2);\n', text) assert_in('\ntransform_scale(3);\n', text) assert_in('\ntransform_scale(XX);\n', text) assert_in('\ntransform_scale(YY);\n', text) # test pre/post assignments fun = Function('void main() {some stuff;}') fun['pre'] = '__pre__' fun['post'] = '__post__' text = fun.compile() assert text == 'void main() {\n __pre__\nsome stuff;\n __post__\n}\n' # Test variable expressions fun = Function('void main(){$foo; $bar;}') fun['foo'] = Variable('uniform float bla') fun['bar'] = Variable('attribute float bla') assert_is(type(fun['foo']), Variable) assert_is(type(fun['bar']), Variable) assert_in(fun['foo'], fun.dependencies()) assert_in(fun['bar'], fun.dependencies()) # Test special variables fun = Function('void main(){$foo; $bar;}') variable = Variable('attribute vec3 v_pos') varying = Variable('varying vec3 color') # These do not work due to index assert_raises(TypeError, fun.__setitem__, 3, 3) # not a string assert_raises(KeyError, fun.__setitem__, 'xxx', 3) # unknown template var assert_raises(TypeError, fun.__setitem__, variable, 3) # only varyings # These work fun['gl_PointSize'] = '3.0' fun[varying] = variable # And getting works assert_equal(fun['gl_PointSize'].text, '3.0') assert_equal(fun[varying], variable)
def _prepare_vis(): objects = [] # --- program and shaders # Create program and shaders hprog = gl.glCreateProgram() hvert = gl.glCreateShader(gl.GL_VERTEX_SHADER) hfrag = gl.glCreateShader(gl.GL_FRAGMENT_SHADER) objects.append((gl.glDeleteProgram, hprog)) objects.append((gl.glDeleteShader, hvert)) objects.append((gl.glDeleteShader, hfrag)) # Compile source code gl.glShaderSource(hvert, VERT) gl.glShaderSource(hfrag, FRAG) gl.glCompileShader(hvert) gl.glCompileShader(hfrag) # Check assert_equal(gl.glGetShaderInfoLog(hvert), '') assert_equal(gl.glGetShaderInfoLog(hfrag), '') assert_equal(gl.glGetShaderParameter(hvert, gl.GL_COMPILE_STATUS), 1) assert_equal(gl.glGetShaderParameter(hfrag, gl.GL_COMPILE_STATUS), 1) # Attach and link gl.glAttachShader(hprog, hvert) gl.glAttachShader(hprog, hfrag) # touch glDetachShader gl.glDetachShader(hprog, hvert) gl.glAttachShader(hprog, hvert) gl.glLinkProgram(hprog) # Test that indeed these shaders are attached attached_shaders = gl.glGetAttachedShaders(hprog) assert_equal(set(attached_shaders), set([hvert, hfrag])) # Check assert_equal(gl.glGetProgramInfoLog(hprog), '') assert_equal(gl.glGetProgramParameter(hprog, gl.GL_LINK_STATUS), 1) gl.glValidateProgram(hprog) assert_equal(gl.glGetProgramParameter(hprog, gl.GL_VALIDATE_STATUS), 1) # Use it! gl.glUseProgram(hprog) # Bind one attribute gl.glBindAttribLocation(hprog, 1, 'a_2') # Check if all is ok assert_equal(gl.glGetError(), 0) # Check source vert_source = gl.glGetShaderSource(hvert) assert_true('attribute vec2 a_2;' in vert_source) # --- get information on attributes and uniforms # Count attribbutes and uniforms natt = gl.glGetProgramParameter(hprog, gl.GL_ACTIVE_ATTRIBUTES) nuni = gl.glGetProgramParameter(hprog, gl.GL_ACTIVE_UNIFORMS) assert_equal(natt, 4) assert_equal(nuni, 4 + 4 + 3 + 1) # Get names names = {} for i in range(natt): name, count, type = gl.glGetActiveAttrib(hprog, i) names[name] = type assert_equal(count, 1) for i in range(nuni): name, count, type = gl.glGetActiveUniform(hprog, i) names[name] = type assert_equal(count, 1) # Check assert_equal(names['a_1'], gl.GL_FLOAT) assert_equal(names['a_2'], gl.GL_FLOAT_VEC2) assert_equal(names['a_3'], gl.GL_FLOAT_VEC3) assert_equal(names['a_4'], gl.GL_FLOAT_VEC4) assert_equal(names['s_1'], gl.GL_SAMPLER_2D) # for i, type in enumerate( [gl.GL_FLOAT, gl.GL_FLOAT_VEC2, gl.GL_FLOAT_VEC3, gl.GL_FLOAT_VEC4]): assert_equal(names['u_f%i' % (i + 1)], type) for i, type in enumerate( [gl.GL_INT, gl.GL_INT_VEC2, gl.GL_INT_VEC3, gl.GL_INT_VEC4]): assert_equal(names['u_i%i' % (i + 1)], type) for i, type in enumerate( [gl.GL_FLOAT_MAT2, gl.GL_FLOAT_MAT3, gl.GL_FLOAT_MAT4]): assert_equal(names['u_m%i' % (i + 2)], type) # Check if all is ok assert_equal(gl.glGetError(), 0) # --- texture # Create, bind, activate htex = gl.glCreateTexture() objects.append((gl.glDeleteTexture, htex)) gl.glPixelStorei(gl.GL_UNPACK_ALIGNMENT, 1) gl.glBindTexture(gl.GL_TEXTURE_2D, htex) # Allocate data and upload # This data is luminance and not C-contiguous gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE, gl.GL_UNSIGNED_BYTE, im2) # touch gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_LUMINANCE, gl.GL_LUMINANCE, gl.GL_UNSIGNED_BYTE, im2.shape[:2]) gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_LUMINANCE, gl.GL_UNSIGNED_BYTE, im2) # Set texture parameters (use f and i to touch both) T = gl.GL_TEXTURE_2D gl.glTexParameterf(T, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR) gl.glTexParameteri(T, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) # Re-allocate data and upload gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im1.shape[:2]) gl.glTexSubImage2D(gl.GL_TEXTURE_2D, 0, 0, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, im1) # Attach! loc = gl.glGetUniformLocation(hprog, 's_1') unit = 0 gl.glActiveTexture(gl.GL_TEXTURE0 + unit) gl.glUniform1i(loc, unit) # Mipmaps (just to touch this function) gl.glGenerateMipmap(gl.GL_TEXTURE_2D) # Check min filter (touch getTextParameter) minfilt = gl.glGetTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER) assert_equal(minfilt, gl.GL_LINEAR) # Check if all is ok assert_equal(gl.glGetError(), 0) # --- buffer vec2 (contiguous VBO) # Create buffer hbuf2 = gl.glCreateBuffer() objects.append((gl.glDeleteBuffer, hbuf2)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, hbuf2) # Allocate and set data gl.glBufferData(gl.GL_ARRAY_BUFFER, buf2.nbytes, gl.GL_DYNAMIC_DRAW) gl.glBufferSubData(gl.GL_ARRAY_BUFFER, 0, buf2) # Attach! loc = gl.glGetAttribLocation(hprog, 'a_2') gl.glDisableVertexAttribArray(loc) # touch gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 2, gl.GL_FLOAT, False, 2 * 4, 0) # Check (touch glGetBufferParameter, glGetVertexAttrib and # glGetVertexAttribOffset) size = gl.glGetBufferParameter(gl.GL_ARRAY_BUFFER, gl.GL_BUFFER_SIZE) assert_equal(size, buf2.nbytes) stride = gl.glGetVertexAttrib(loc, gl.GL_VERTEX_ATTRIB_ARRAY_STRIDE) assert_equal(stride, 2 * 4) offset = gl.glGetVertexAttribOffset(loc, gl.GL_VERTEX_ATTRIB_ARRAY_POINTER) assert_equal(offset, 0) # Check if all is ok assert_equal(gl.glGetError(), 0) # --- buffer vec3 (non-contiguous VBO) # Create buffer hbuf3 = gl.glCreateBuffer() objects.append((gl.glDeleteBuffer, hbuf3)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, hbuf3) # Allocate and set data gl.glBufferData(gl.GL_ARRAY_BUFFER, buf3.nbytes, gl.GL_DYNAMIC_DRAW) gl.glBufferSubData(gl.GL_ARRAY_BUFFER, 0, buf3) # Attach! loc = gl.glGetAttribLocation(hprog, 'a_3') gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 3, gl.GL_FLOAT, False, 3 * 4, 0) # Check if all is ok assert_equal(gl.glGetError(), 0) # --- buffer vec4 (client vertex data) # Select no FBO gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0) # Attach! loc = gl.glGetAttribLocation(hprog, 'a_4') gl.glEnableVertexAttribArray(loc) gl.glVertexAttribPointer(loc, 4, gl.GL_FLOAT, False, 4 * 4, buf4) # Check if all is ok assert_equal(gl.glGetError(), 0) # --- element buffer # Create buffer global helements helements = gl.glCreateBuffer() objects.append((gl.glDeleteBuffer, helements)) gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, helements) # Allocate and set data gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, elements, gl.GL_DYNAMIC_DRAW) gl.glBufferSubData(gl.GL_ELEMENT_ARRAY_BUFFER, 0, elements) # Turn off gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, 0) # Check if all is ok assert_equal(gl.glGetError(), 0) # --- uniforms # Set integer uniforms to 0 # We set them twice just to touch both i and iv functions for i, fun1, fun2 in [(1, gl.glUniform1i, gl.glUniform1iv), (2, gl.glUniform2i, gl.glUniform2iv), (3, gl.glUniform3i, gl.glUniform3iv), (4, gl.glUniform4i, gl.glUniform4iv)]: name = 'u_i%i' % i value = [0] * i loc = gl.glGetUniformLocation(hprog, name) fun1(loc, *value) # e.g. glUniform4i fun2(loc, 1, value) # e.g. glUniform4iv # Set float uniforms to 1.0 # We set them twice just to touch both i and iv functions for i, fun1, fun2 in [(1, gl.glUniform1f, gl.glUniform1fv), (2, gl.glUniform2f, gl.glUniform2fv), (3, gl.glUniform3f, gl.glUniform3fv), (4, gl.glUniform4f, gl.glUniform4fv)]: name = 'u_f%i' % i value = [1.0] * i loc = gl.glGetUniformLocation(hprog, name) fun1(loc, *value) # e.g. glUniform4f fun2(loc, 1, value) # e.g. glUniform4fv # Set matrix uniforms m = np.eye(5, dtype='float32') loc = gl.glGetUniformLocation(hprog, 'u_m2') gl.glUniformMatrix2fv(loc, 1, False, m[:2, :2]) # loc = gl.glGetUniformLocation(hprog, 'u_m3') m = np.eye(3, dtype='float32') gl.glUniformMatrix3fv(loc, 1, False, m[:3, :3]) # loc = gl.glGetUniformLocation(hprog, 'u_m4') m = np.eye(4, dtype='float32') gl.glUniformMatrix4fv(loc, 1, False, m[:4, :4]) # Check some uniforms loc = gl.glGetUniformLocation(hprog, 'u_i1') assert_equal(gl.glGetUniform(hprog, loc), 0) loc = gl.glGetUniformLocation(hprog, 'u_i2') assert_equal(gl.glGetUniform(hprog, loc), (0, 0)) loc = gl.glGetUniformLocation(hprog, 'u_f2') assert_equal(gl.glGetUniform(hprog, loc), (1.0, 1.0)) # Check if all is ok assert_equal(gl.glGetError(), 0) # --- attributes # Constant values for attributes. We do not even use this ... loc = gl.glGetAttribLocation(hprog, 'a_1') gl.glVertexAttrib1f(loc, 1.0) loc = gl.glGetAttribLocation(hprog, 'a_2') gl.glVertexAttrib2f(loc, 1.0, 1.0) loc = gl.glGetAttribLocation(hprog, 'a_3') gl.glVertexAttrib3f(loc, 1.0, 1.0, 1.0) loc = gl.glGetAttribLocation(hprog, 'a_4') gl.glVertexAttrib4f(loc, 1.0, 1.0, 1.0, 1.0) # --- flush and finish # Not really necessary, but we want to touch the functions gl.glFlush() gl.glFinish() #print([i[1] for i in objects]) return objects
def test_event_connect_order(): """Test event connection order""" def a(): return def b(): return def c(): return def d(): return def e(): return def f(): return em = EventEmitter(type='test_event') assert_raises(ValueError, em.connect, c, before=['c', 'foo']) assert_raises(ValueError, em.connect, c, position='foo') assert_raises(TypeError, em.connect, c, ref=dict()) em.connect(c, ref=True) assert_equal((c, ), tuple(em.callbacks)) em.connect(c) assert_equal((c, ), tuple(em.callbacks)) em.connect(d, ref=True, position='last') assert_equal((c, d), tuple(em.callbacks)) em.connect(b, ref=True) # position='first' assert_equal((b, c, d), tuple(em.callbacks)) assert_raises(RuntimeError, em.connect, a, before='c', after='d') # can't em.connect(a, ref=True, before=['c', 'd']) # first possible pos == 0 assert_equal((a, b, c, d), tuple(em.callbacks)) em.connect(f, ref=True, after=['c', 'd']) assert_equal((a, b, c, d, f), tuple(em.callbacks)) em.connect(e, ref=True, after='d', before='f') assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) em.disconnect(e) em.connect(e, ref=True, after='a', before='f', position='last') assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) em.disconnect(e) em.connect(e, ref='e', after='d', before='f', position='last') assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) em.disconnect(e) em.connect(e, after='d', before='f', position='first') # no name assert_equal(('a', 'b', 'c', 'd', None, 'f'), tuple(em.callback_refs)) em.disconnect(e) assert_raises(ValueError, em.connect, e, ref='d') # duplicate name em.connect(e, ref=True, after=[], before='f', position='last') assert_equal(('a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) assert_equal((a, b, c, d, e, f), tuple(em.callbacks)) old_e = e def e(): return assert_raises(ValueError, em.connect, e, ref=True) # duplicate name em.connect(e) assert_equal((None, 'a', 'b', 'c', 'd', 'e', 'f'), tuple(em.callback_refs)) assert_equal((e, a, b, c, d, old_e, f), tuple(em.callbacks))
def test_application(): """Test application running""" app = use_app() print(app) # __repr__ without app app.create() wrong = 'glfw' if app.backend_name.lower() != 'glfw' else 'pyqt5' assert_raises(RuntimeError, use_app, wrong) app.process_events() print(app) # test __repr__ assert_raises(ValueError, Canvas, keys='foo') assert_raises(TypeError, Canvas, keys=dict(escape=1)) assert_raises(ValueError, Canvas, keys=dict(escape='foo')) # not an attr pos = [0, 0] if app.backend_module.capability['position'] else None size = (100, 100) # Use "with" statement so failures don't leave open window # (and test context manager behavior) title = 'default' with Canvas(title=title, size=size, app=app, show=True, position=pos) as canvas: context = canvas.context assert_true(canvas.create_native() is None) # should be done already assert_is(canvas.app, app) assert_true(canvas.native) assert_equal('swap_buffers', canvas.events.draw.callback_refs[-1]) canvas.measure_fps(0.001) sleep(0.002) canvas.update() app.process_events() assert_true(canvas.fps > 0) # Other methods print(canvas) # __repr__ assert_equal(canvas.title, title) canvas.title = 'you' with use_log_level('warning', record=True, print_msg=False): if app.backend_module.capability['position']: # todo: disable more tests based on capability canvas.position = pos canvas.size = size canvas.connect(on_mouse_move) assert_raises(ValueError, canvas.connect, _on_mouse_move) if sys.platform != 'darwin': # XXX knownfail, prob. needs warmup canvas.show(False) canvas.show() app.process_events() assert_raises(ValueError, canvas.connect, on_nonexist) # deprecation of "paint" with use_log_level('info', record=True, print_msg=False) as log: olderr = sys.stderr try: fid = StringIO() sys.stderr = fid @canvas.events.paint.connect def fake(event): pass finally: sys.stderr = olderr assert_equal(len(log), 1) assert_in('deprecated', log[0]) # screenshots gl.glViewport(0, 0, *size) ss = _screenshot() assert_array_equal(ss.shape, size + (4,)) assert_equal(len(canvas._backend._vispy_get_geometry()), 4) if sys.platform != 'win32': # XXX knownfail for windows assert_array_equal(canvas.size, size) assert_equal(len(canvas.position), 2) # XXX knownfail, doesn't "take" # GLOO: should have an OpenGL context already, so these should work vert = "void main (void) {gl_Position = pos;}" frag = "void main (void) {gl_FragColor = pos;}" program = Program(vert, frag) assert_raises(RuntimeError, program.glir.flush, context.shared.parser) vert = "uniform vec4 pos;\nvoid main (void) {gl_Position = pos;}" frag = "uniform vec4 pos;\nvoid main (void) {gl_FragColor = pos;}" program = Program(vert, frag) # uniform = program.uniforms[0] program['pos'] = [1, 2, 3, 4] vert = "attribute vec4 pos;\nvoid main (void) {gl_Position = pos;}" frag = "void main (void) {}" program = Program(vert, frag) # attribute = program.attributes[0] program["pos"] = [1, 2, 3, 4] # use a real program program._glir.clear() vert = ("uniform mat4 u_model;" "attribute vec2 a_position; attribute vec4 a_color;" "varying vec4 v_color;" "void main (void) {v_color = a_color;" "gl_Position = u_model * vec4(a_position, 0.0, 1.0);" "v_color = a_color;}") frag = "void main() {gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);}" n, p = 250, 50 T = np.random.uniform(0, 2 * np.pi, n) position = np.zeros((n, 2), dtype=np.float32) position[:, 0] = np.cos(T) position[:, 1] = np.sin(T) color = np.ones((n, 4), dtype=np.float32) * (1, 1, 1, 1) data = np.zeros(n * p, [('a_position', np.float32, 2), ('a_color', np.float32, 4)]) data['a_position'] = np.repeat(position, p, axis=0) data['a_color'] = np.repeat(color, p, axis=0) program = Program(vert, frag) program.bind(VertexBuffer(data)) program['u_model'] = np.eye(4, dtype=np.float32) # different codepath if no call to activate() program.draw(gl.GL_POINTS) subset = IndexBuffer(np.arange(10, dtype=np.uint32)) program.draw(gl.GL_POINTS, subset) # bad programs frag_bad = ("varying vec4 v_colors") # no semicolon program = Program(vert, frag_bad) assert_raises(RuntimeError, program.glir.flush, context.shared.parser) frag_bad = None # no fragment code. no main is not always enough assert_raises(ValueError, Program, vert, frag_bad) # Timer timer = Timer(interval=0.001, connect=on_mouse_move, iterations=2, start=True, app=app) timer.start() timer.interval = 0.002 assert_equal(timer.interval, 0.002) assert_true(timer.running) sleep(.003) assert_true(timer.elapsed >= 0.002) timer.stop() assert_true(not timer.running) assert_true(timer.native) timer.disconnect() # test that callbacks take reasonable inputs _test_callbacks(canvas) # cleanup canvas.swap_buffers() canvas.update() app.process_events() # put this in even though __exit__ will call it to make sure we don't # have problems calling it multiple times canvas.close() # done by context
def test_import_nothing(): """Not importing vispy should not import any vispy modules.""" modnames = loaded_vispy_modules('os', 2) assert_equal(modnames, set())
def test_import_vispy_gloo(): """Importing vispy.gloo should not pull in other vispy submodules.""" modnames = loaded_vispy_modules('vispy.gloo', 2) assert_equal( modnames, set(_min_modules + ['vispy.gloo', 'vispy.glsl', 'vispy.color']))
def _test_object_creation_and_deletion(): # Stuff that is originally glGenX # Note that if we test glIsTexture(x), we cannot assume x to be a # nonexisting texture; we might have created a texture in another # test and failed to clean it up. # Create/delete texture #assert_equal(gl.glIsTexture(12), False) handle = gl.glCreateTexture() gl.glBindTexture(gl.GL_TEXTURE_2D, handle) assert_equal(gl.glIsTexture(handle), True) gl.glDeleteTexture(handle) assert_equal(gl.glIsTexture(handle), False) # Create/delete buffer #assert_equal(gl.glIsBuffer(12), False) handle = gl.glCreateBuffer() gl.glBindBuffer(gl.GL_ARRAY_BUFFER, handle) assert_equal(gl.glIsBuffer(handle), True) gl.glDeleteBuffer(handle) assert_equal(gl.glIsBuffer(handle), False) # Create/delete framebuffer #assert_equal(gl.glIsFramebuffer(12), False) handle = gl.glCreateFramebuffer() gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, handle) assert_equal(gl.glIsFramebuffer(handle), True) gl.glDeleteFramebuffer(handle) assert_equal(gl.glIsFramebuffer(handle), False) # Create/delete renderbuffer #assert_equal(gl.glIsRenderbuffer(12), False) handle = gl.glCreateRenderbuffer() gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, handle) assert_equal(gl.glIsRenderbuffer(handle), True) gl.glDeleteRenderbuffer(handle) assert_equal(gl.glIsRenderbuffer(handle), False) # Stuff that is originally called glCreate # Create/delete program #assert_equal(gl.glIsProgram(12), False) handle = gl.glCreateProgram() assert_equal(gl.glIsProgram(handle), True) gl.glDeleteProgram(handle) assert_equal(gl.glIsProgram(handle), False) # Create/delete shader #assert_equal(gl.glIsShader(12), False) handle = gl.glCreateShader(gl.GL_VERTEX_SHADER) assert_equal(gl.glIsShader(handle), True) gl.glDeleteShader(handle) assert_equal(gl.glIsShader(handle), False) gl.check_error()
def test_color_interpretation(): """Test basic color interpretation API""" # test useful ways of single color init r = ColorArray('r') print(r) # test repr r2 = ColorArray(r) assert_equal(r, r2) r2.rgb = 0, 0, 0 assert_equal(r2, ColorArray('black')) assert_equal(r, ColorArray('r')) # modifying new one preserves old assert_equal(r, r.copy()) assert_equal(r, ColorArray('#ff0000')) assert_equal(r, ColorArray('#FF0000FF')) assert_equal(r, ColorArray('red')) assert_equal(r, ColorArray('red', alpha=1.0)) assert_equal(ColorArray((1, 0, 0, 0.1)), ColorArray('red', alpha=0.1)) assert_array_equal(r.rgb.ravel(), (1., 0., 0.)) assert_array_equal(r.rgba.ravel(), (1., 0., 0., 1.)) assert_array_equal(r.RGBA.ravel(), (255, 0, 0, 255)) # handling multiple colors rgb = ColorArray(list('rgb')) print(rgb) # multi repr assert_array_equal(rgb, ColorArray(np.eye(3))) # complex/annoying case rgb = ColorArray(['r', (0, 1, 0), '#0000ffff']) assert_array_equal(rgb, ColorArray(np.eye(3))) assert_raises(RuntimeError, ColorArray, ['r', np.eye(3)]) # can't nest # getting/setting properties r = ColorArray('#ffff') assert_equal(r, ColorArray('white')) r = ColorArray('#ff000000') assert_true('turquoise' in get_color_names()) # make sure our JSON loaded assert_equal(r.alpha, 0) r.alpha = 1.0 assert_equal(r, ColorArray('r')) r.alpha = 0 r.rgb = (1, 0, 0) assert_equal(r.alpha, 0) assert_equal(r.hex, ['#ff0000']) r.alpha = 1 r.hex = '00ff00' assert_equal(r, ColorArray('g')) assert_array_equal(r.rgb.ravel(), (0., 1., 0.)) r.RGB = 255, 0, 0 assert_equal(r, ColorArray('r')) assert_array_equal(r.RGB.ravel(), (255, 0, 0)) r.RGBA = 255, 0, 0, 0 assert_equal(r, ColorArray('r', alpha=0)) w = ColorArray() w.rgb = ColorArray('r').rgb + ColorArray('g').rgb + ColorArray('b').rgb assert_equal(w, ColorArray('white')) w = ColorArray('white') assert_equal(w, w.darker().lighter()) assert_equal(w, w.darker(0.1).darker(-0.1)) w2 = w.darker() assert_true(w != w2) w.darker(copy=False) assert_equal(w, w2) with use_log_level('warning', record=True, print_msg=False) as w: w = ColorArray('white') w.value = 2 assert_equal(len(w), 1) assert_equal(w, ColorArray('white')) # warnings and errors assert_raises(ValueError, ColorArray, '#ffii00') # non-hex assert_raises(ValueError, ColorArray, '#ff000') # too short assert_raises(ValueError, ColorArray, [0, 0]) # not enough vals assert_raises(ValueError, ColorArray, [2, 0, 0]) # val > 1 assert_raises(ValueError, ColorArray, [-1, 0, 0]) # val < 0 c = ColorArray([2., 0., 0.], clip=True) # val > 1 assert_true(np.all(c.rgb <= 1)) c = ColorArray([-1., 0., 0.], clip=True) # val < 0 assert_true(np.all(c.rgb >= 0)) # make sure our color dict works for key in get_color_names(): assert_true(ColorArray(key)) assert_raises(ValueError, ColorArray, 'foo') # unknown color error _color_dict = get_color_dict() assert isinstance(_color_dict, dict) assert set(_color_dict.keys()) == set(get_color_names())