def _test_multiple_canvases(backend): """Helper for testing multiple canvases from the same application""" n_check = 3 a = Application(backend) with Canvas(app=a, size=_win_size, title=backend + ' same_0') as c0: with Canvas(app=a, size=_win_size, title=backend + ' same_1') as c1: ct = [0, 0] @c0.events.paint.connect def paint0(event): ct[0] += 1 c0.update() @c1.events.paint.connect # noqa, analysis:ignore def paint1(event): ct[1] += 1 c1.update() c0.show() # ensure visible c1.show() c0.update() # force first paint c1.update() timeout = time() + 2.0 while (ct[0] < n_check or ct[1] < n_check) and time() < timeout: a.process_events() print((ct, n_check)) assert_true(n_check <= ct[0] <= n_check + 1) assert_true(n_check <= ct[1] <= n_check + 1) # check timer global timer_ran timer_ran = False def on_timer(_): global timer_ran timer_ran = True timeout = time() + 2.0 Timer(0.1, app=a, connect=on_timer, iterations=1, start=True) while not timer_ran and time() < timeout: a.process_events() assert_true(timer_ran)
def __init__(self, connect=None, start=True, app=None): self.events = EmitterGroup(source=self, start=Event, stop=Event, midiIn=Event) if app is None: self._app = use_app(call_reuse=False) elif isinstance(app, Application): self._app = app elif isinstance(app, string_types): self._app = Application(app) else: raise ValueError('Invalid value for app %r' % app) self._running = False if connect is not None: self.connect(connect) if start: self.start()
def test_rfb_canvas(): app = Application("jupyter_rfb") canvas = MyCanvas(app=app) canvas_backend = canvas.native assert isinstance(canvas_backend, _jupyter_rfb.CanvasBackend) # Check that resize works assert "42" not in canvas_backend.css_width canvas.size = 42, 42 assert canvas_backend.css_width == "42px" # Manually mimic what a browser would do, but round to 50 canvas_backend.handle_event({"event_type": "resize", "width": 50, "height": 50, "pixel_ratio": 2.0}) assert canvas.size == (50, 50) assert canvas.physical_size == (100, 100) # Mimic a draw frame = canvas_backend.get_frame() assert frame.shape[:2] == (100, 100) assert np.all(frame[:, :, 0] == 0) assert np.all(frame[:, :, 1] == 255) # Pretend that the user resized in the browser canvas_backend.handle_event({"event_type": "resize", "width": 60, "height": 60, "pixel_ratio": 1.0}) assert canvas.size == (60, 60) assert canvas.physical_size == (60, 60) # Mimic another draw frame = canvas_backend.get_frame() assert frame.shape[:2] == (60, 60) assert np.all(frame[:, :, 0] == 0) assert np.all(frame[:, :, 1] == 255) # Test mouse event events = [] canvas.events.mouse_press.connect(lambda e: events.append(e)) canvas_backend.handle_event({"event_type": "pointer_down", "x": 11, "y": 12, "button": 1, "modifiers": []}) assert len(events) == 1 assert tuple(events[0].pos) == (11, 12)
async def viewer(receive_channel, shape): display_shape = (512, 512) # init app app = Application() app.create() # init viewer canvas = scene.SceneCanvas(app=app, keys="interactive") canvas.size = display_shape # create view and image view = canvas.central_widget.add_view() # lock view view.camera = scene.PanZoomCamera(aspect=1, interactive=False) view.camera.flip = (0, 1, 0) image = scene.visuals.Image(np.empty(display_shape, np.uint8), parent=view.scene, cmap="grays") view.camera.set_range(margin=0) canvas.show() async with receive_channel: async for frame in receive_channel: # logger.debug(f".... average {frame.mean():.2f}") # resize frame = transform.resize(frame, display_shape) # rescale intensity to 8-bit frame = exposure.rescale_intensity(frame, out_range=np.uint8) # change dtype frame = frame.astype(np.uint8) image.set_data(frame) canvas.update() app.process_events()
def _test_application(backend): """Test application running""" app = Application() assert_raises(ValueError, app.use, "foo") app.use(backend) wrong = "Glut" if app.backend_name != "Glut" else "Pyglet" assert_raises(RuntimeError, app.use, wrong) app.process_events() if backend is not None: # "in" b/c "qt" in "PySide (qt)" assert_in(backend, app.backend_name) print(app) # test __repr__ # Canvas pos = [0, 0] size = (100, 100) # Use "with" statement so failures don't leave open window # (and test context manager behavior) title = "default" if backend is None else backend with Canvas(title=title, size=size, app=app, show=True, position=pos) as canvas: assert_is(canvas.app, app) assert_true(canvas.native) assert_equal("swap_buffers", canvas.events.paint.callback_refs[-1]) print(canvas) # __repr__ assert_array_equal(canvas.size, size) assert_equal(canvas.title, title) canvas.title = "you" 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) # screenshots gl.glViewport(0, 0, *size) ss = _screenshot() assert_array_equal(ss.shape, size + (3,)) assert_equal(len(canvas._backend._vispy_get_geometry()), 4) assert_array_equal(canvas.size, size) assert_equal(len(canvas.position), 2) # XXX knawnfail, doesn't "take" # GLOO: should have an OpenGL context already, so these should work vert = VertexShader("void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) assert_raises(RuntimeError, program.activate) vert = VertexShader("uniform vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("uniform vec4 pos;" "void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) # uniform = program.uniforms[0] program["pos"] = [1, 2, 3, 4] program.activate() # should print # uniform.upload(program) program.detach(vert) program.detach(frag) assert_raises(RuntimeError, program.detach, vert) assert_raises(RuntimeError, program.detach, frag) vert = VertexShader("attribute vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {}") program = Program(vert, frag) # attribute = program.attributes[0] program["pos"] = [1, 2, 3, 4] program.activate() # attribute.upload(program) # cannot get element count # assert_raises(RuntimeError, program.draw, 'POINTS') # use a real program 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, 1);}" 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.activate) frag_bad = None # no fragment code. no main is not always enough program = Program(vert, frag_bad) assert_raises(ValueError, program.activate) # 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) 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()
def _test_application(backend): """Test application running""" app = Application() assert_raises(ValueError, app.use, 'foo') app.use(backend) wrong = 'Glut' if app.backend_name != 'Glut' else 'Pyglet' assert_raises(RuntimeError, app.use, wrong) app.process_events() if backend is not None: # "in" b/c "qt" in "PySide (qt)" assert_true(backend in app.backend_name) print(app) # test __repr__ # Canvas pos = [0, 0, 1, 1] # Use "with" statement so failures don't leave open window # (and test context manager behavior) with Canvas(title='me', app=app, show=True, position=pos) as canvas: assert_true(canvas.app is app) assert_true(canvas.native) print(canvas.size >= (1, 1)) canvas.resize(90, 90) canvas.move(1, 1) assert_equal(canvas.title, 'me') canvas.title = 'you' canvas.position = (0, 0) canvas.size = (100, 100) canvas.connect(on_mouse_move) assert_raises(ValueError, canvas.connect, _on_mouse_move) canvas.show() assert_raises(ValueError, canvas.connect, on_nonexist) # screenshots ss = _screenshot() assert_array_equal(ss.shape[2], 3) # XXX other dimensions not correct? # XXX it would be good to do real checks, but sometimes the # repositionings don't "take" (i.e., lead to random errors) assert_equal(len(canvas._backend._vispy_get_geometry()), 4) assert_equal(len(canvas.size), 2) assert_equal(len(canvas.position), 2) # GLOO: should have an OpenGL context already, so these should work vert = VertexShader("void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) assert_raises(ShaderError, program.activate) vert = VertexShader("uniform vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("uniform vec4 pos;" "void main (void) {gl_FragColor = pos;}") program = Program(vert, frag) uniform = program.uniforms[0] uniform.set_data([1, 2, 3, 4]) program.activate() # should print uniform.upload(program) program.detach(vert, frag) assert_raises(ShaderError, program.detach, vert) assert_raises(ShaderError, program.detach, frag) vert = VertexShader("attribute vec4 pos;" "void main (void) {gl_Position = pos;}") frag = FragmentShader("void main (void) {}") program = Program(vert, frag) attribute = program.attributes[0] attribute.set_data([1, 2, 3, 4]) program.activate() attribute.upload(program) # cannot get element count assert_raises(ProgramError, program.draw, 'POINTS') # use a real program 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, 1);}" 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.set_vars(VertexBuffer(data)) program['u_model'] = np.eye(4, dtype=np.float32) program.draw('POINTS') # different codepath if no call to activate() subset = ElementBuffer(np.arange(10, dtype=np.uint32)) program.draw('POINTS', subset=subset) # bad programs frag_bad = ("varying vec4 v_colors") # no semicolon program = Program(vert, frag_bad) assert_raises(ShaderError, program.activate) frag_bad = None # no fragment code. no main is not always enough program = Program(vert, frag_bad) assert_raises(ProgramError, program.activate) # 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) 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() # put this in even though __exit__ will call it to make sure we don't # have problems calling it multiple times canvas.close() app.quit() app.quit() # make sure it doesn't break if a user does something silly
def test_show_entity(): """Test showing an entity""" # Create a figure app = Application() fig = scene.CanvasWithScene(app=app) app.create() fig.size = 1, 1 fig.show() camcontainer = scene.PixelCamera(fig.viewbox) camera = scene.ThreeDCamera(camcontainer) camera._fov = 90 fig.viewbox.camera = camera pointscontainer = scene.Entity(fig.viewbox) scene.PointsEntity(pointscontainer, 1000) app.process_events() app.process_events() # for good measure # Now do first-person camcontainer = scene.PixelCamera(fig.viewbox) camera = scene.FirstPersonCamera(camcontainer) camera.update_angles() fig.viewbox.camera = camera pointscontainer = scene.Entity(fig.viewbox) scene.PointsEntity(pointscontainer, 1000) app.process_events() app.process_events() # for good measure # Now do 2D camcontainer = scene.PixelCamera(fig.viewbox) camera = scene.TwoDCamera(camcontainer) camera.xlim = -100, 500 camera.ylim = -100, 500 fig.viewbox.camera = camera pointscontainer = scene.Entity(fig.viewbox) scene.PointsEntity(pointscontainer, 1000) transforms.translate(camcontainer.transform, 50, 50) transforms.rotate(camcontainer.transform, 10, 0, 0, 1) app.process_events() app.process_events() # for good measure fig.close() app.quit()
"""Module with helper functions for plotting """ from vispy.app import Application from PyQt5.QtWidgets import QApplication app = Application('pyqt5') from vispy.scene import SceneCanvas, TurntableCamera from vispy.visuals import Visual from vispy.scene.visuals import create_visual_node from vispy.geometry import create_sphere, MeshData from numpy import array, clip, float32, r_ from vispy.gloo import VertexBuffer from vispy.io.image import _make_png from vispy.gloo.wrappers import read_pixels COLORMAP = 'coolwarm' class Viz(SceneCanvas): _view = None def __init__(self): super().__init__(keys='interactive', show=True, bgcolor='white') self._view = self.central_widget.add_view() def _add_mesh(self, mesh): self._view.add(mesh) def _repr_png_(self): """This is used by ipython to plot inline.