vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/gloo/tests/test_use_gloo.py

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+import sys
+
+import numpy as np
+from numpy.testing import assert_allclose
+import pytest
+
+from vispy.app import Canvas
+from vispy.gloo import (Texture2D, Texture3D, Program, FrameBuffer,
+                        RenderBuffer, set_viewport, clear)
+from vispy.gloo.util import draw_texture, _screenshot
+from vispy.testing import (requires_application, has_pyopengl,
+                           run_tests_if_main,
+                           assert_raises, assert_equal, IS_TRAVIS_CI)
+
+
+@requires_application()
+def test_use_textures():
+    """Test using textures and FBO"""
+    assert_raises(ValueError, Texture2D, np.zeros((2, 2, 3), np.float32),
+                  format='rgba')  # format and data size mismatch
+
+
+@requires_application()
+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:
+        c.app.process_events()
+        c.set_current()
+        if c.app.backend_name.lower() == 'pyqt5':
+            # PyQt5 on OSX for some reason sets this to 1024x768...
+            c.size = shape[::-1]
+        c.app.process_events()
+        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 c.size == shape[::-1]
+        c.set_current()
+        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 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)
+
+
+@requires_application()
+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.)
+
+
+@pytest.mark.xfail(IS_TRAVIS_CI and 'darwin' in sys.platform,
+                   reason='Travis OSX causes segmentation fault on this test for an unknown reason.')
+@requires_application()
+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.)
+
+run_tests_if_main()

vispy/gloo/tests/test_util.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+
+from vispy.gloo import util
+
+from vispy.testing import run_tests_if_main, assert_raises
+
+
+def test_check_enum():
+    from vispy.gloo import gl
+
+    # Test enums
+    assert util.check_enum(gl.GL_RGB) == 'rgb' 
+    assert util.check_enum(gl.GL_TRIANGLE_STRIP) == 'triangle_strip' 
+
+    # Test strings
+    assert util.check_enum('RGB') == 'rgb' 
+    assert util.check_enum('Triangle_STRIp') == 'triangle_strip' 
+
+    # Test wrong input
+    assert_raises(ValueError, util.check_enum, int(gl.GL_RGB))
+    assert_raises(ValueError, util.check_enum, int(gl.GL_TRIANGLE_STRIP))
+    assert_raises(ValueError, util.check_enum, [])
+
+    # Test with test
+    util.check_enum('RGB', 'test', ('rgb', 'alpha')) == 'rgb' 
+    util.check_enum(gl.GL_ALPHA, 'test', ('rgb', 'alpha')) == 'alpha' 
+    #
+    assert_raises(ValueError, util.check_enum, 'RGB', 'test', ('a', 'b'))
+    assert_raises(ValueError, util.check_enum, gl.GL_ALPHA, 'test', ('a', 'b'))
+
+    # Test PyOpenGL enums
+    try:
+        from OpenGL import GL
+    except ImportError:
+        return  # we cannot test PyOpenGL
+    #
+    assert util.check_enum(GL.GL_RGB) == 'rgb' 
+    assert util.check_enum(GL.GL_TRIANGLE_STRIP) == 'triangle_strip' 
+
+
+def test_check_identifier():
+
+    # Tests check_identifier()
+    assert util.check_identifier('foo') is None
+    assert util.check_identifier('_fooBarBla') is None
+    assert util.check_identifier('_glPosition') is None
+
+    # Wrong identifier
+    assert util.check_identifier('__').startswith('Identifier')
+    assert util.check_identifier('gl_').startswith('Identifier')
+    assert util.check_identifier('GL_').startswith('Identifier')
+    assert util.check_identifier('double').startswith('Identifier')
+
+    # Test check_variable()
+    assert util.check_variable('foo') is None
+    assert util.check_variable('a' * 30) is None
+    assert util.check_variable('a' * 32)
+
+
+run_tests_if_main()

vispy/gloo/tests/test_wrappers.py

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+import numpy as np
+from numpy.testing import assert_array_equal, assert_allclose
+
+from vispy import gloo
+from vispy.gloo import gl
+from vispy.app import Canvas
+from vispy.testing import (requires_application, run_tests_if_main,
+                           assert_true, assert_equal, assert_raises)
+from vispy.gloo import read_pixels
+from vispy.gloo.glir import GlirQueue
+from vispy.gloo import wrappers
+
+
+# Dummy queue
+dummy_glir = GlirQueue()
+dummy_glir.context = dummy_glir
+dummy_glir.glir = dummy_glir
+
+
+def install_dummy_glir():
+    wrappers.get_current_canvas = lambda x=None: dummy_glir
+    dummy_glir.clear()
+    return dummy_glir
+
+
+def reset_glir():
+    wrappers.get_current_canvas = gloo.get_current_canvas
+
+
+def teardown_module():
+    reset_glir()
+
+
+def test_wrappers_basic_glir():
+    """Test that basic gloo wrapper functions emit right GLIR command"""
+    glir = install_dummy_glir()
+
+    funcs = [('viewport', 0, 0, 10, 10),
+             ('depth_range', 0, 1),
+             ('front_face', 'ccw'),
+             ('cull_face', 'back'),
+             ('line_width', 1),
+             ('polygon_offset', 0, 0),
+             ('clear_color', ),
+             ('clear_depth', ),
+             ('clear_stencil', ),
+             ('blend_func', ),
+             ('blend_color', 'red'),
+             ('blend_equation', 'X'),
+             ('scissor', 0, 0, 10, 10),
+             ('stencil_func', ),
+             ('stencil_mask', ),
+             ('stencil_op', ),
+             ('depth_func', ),
+             ('depth_mask', 'X'),
+             ('color_mask', False, False, False, False),
+             ('sample_coverage', ),
+             ('hint', 'foo', 'bar'),
+             # not finish and flush, because that would flush the glir queue
+             ]
+
+    for func in funcs:
+        name, args = func[0], func[1:]
+        f = getattr(gloo, 'set_' + name)
+        f(*args)
+
+    cmds = glir.clear()
+    assert len(cmds) == len(funcs)
+    for i, func in enumerate(funcs):
+        cmd = cmds[i]
+        nameparts = [a.capitalize() for a in func[0].split('_')]
+        name = 'gl' + ''.join(nameparts)
+        assert cmd[0] == 'FUNC'
+        if cmd[1].endswith('Separate'):
+            assert cmd[1][:-8] == name
+        else:
+            assert cmd[1] == name
+
+    reset_glir()
+
+
+def test_wrappers_glir():
+    """Test that special wrapper functions do what they must do"""
+    glir = install_dummy_glir()
+
+    # Test clear() function
+    gloo.clear()
+    cmds = glir.clear()
+    assert len(cmds) == 1
+    assert cmds[0][0] == 'FUNC'
+    assert cmds[0][1] == 'glClear'
+    #
+    gloo.clear(True, False, False)
+    cmds = glir.clear()
+    assert len(cmds) == 1
+    assert cmds[0][0] == 'FUNC'
+    assert cmds[0][1] == 'glClear'
+    assert cmds[0][2] == gl.GL_COLOR_BUFFER_BIT
+    #
+    gloo.clear('red')
+    cmds = glir.clear()
+    assert len(cmds) == 2
+    assert cmds[0][0] == 'FUNC'
+    assert cmds[0][1] == 'glClearColor'
+    assert cmds[1][0] == 'FUNC'
+    assert cmds[1][1] == 'glClear'
+    #
+    gloo.clear('red', 4, 3)
+    cmds = glir.clear()
+    assert len(cmds) == 4
+    assert cmds[0][1] == 'glClearColor'
+    assert cmds[1][1] == 'glClearDepth'
+    assert cmds[2][1] == 'glClearStencil'
+    assert cmds[3][1] == 'glClear'
+
+    # Test set_state() function
+    gloo.set_state(foo=True, bar=False)
+    cmds = set(glir.clear())
+    assert len(cmds) == 2
+    assert ('FUNC', 'glEnable', 'foo') in cmds
+    assert ('FUNC', 'glDisable', 'bar') in cmds
+    #
+    gloo.set_state(viewport=(0, 0, 10, 10), clear_color='red')
+    cmds = sorted(glir.clear())
+    assert len(cmds) == 2
+    assert cmds[0][1] == 'glClearColor'
+    assert cmds[1][1] == 'glViewport'
+    #
+    presets = gloo.get_state_presets()
+    a_preset = list(presets.keys())[0]
+    gloo.set_state(a_preset)
+    cmds = sorted(glir.clear())
+    assert len(cmds) == len(presets[a_preset])
+
+    reset_glir()
+
+
+def assert_cmd_raises(E, fun, *args, **kwargs):
+    gloo.flush()  # no error here
+    fun(*args, **kwargs)
+    assert_raises(E, gloo.flush)
+
+
+@requires_application()
+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,))
+
+
+@requires_application()
+def test_read_pixels():
+    """Test read_pixels to ensure that the image is not flipped"""
+    # Create vertices
+    vPosition = np.array(
+        [[-1, 1, 0.0], [0, 1, 0.5],  # For drawing a square to top left
+         [-1, 0, 0.0], [0, 0, 0.5]], np.float32)
+
+    VERT_SHADER = """ // simple vertex shader
+    attribute vec3 a_position;
+    void main (void) {
+        gl_Position = vec4(a_position, 1.0);
+    }
+    """
+
+    FRAG_SHADER = """ // simple fragment shader
+    void main()
+    {
+        gl_FragColor = vec4(1,1,1,1);
+    }
+    """
+
+    with Canvas() as c:
+        c.set_current()
+        gloo.set_viewport(0, 0, *c.size)
+        gloo.set_state(depth_test=True)
+        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()
+
+        # Check that we can read the depth buffer
+        img = read_pixels(mode='depth')
+        assert_equal(img.shape[:2], c.size[::-1])
+        assert_equal(img.shape[2], 1)
+        unique_img = np.unique(img)
+        # we should have quite a few different depth values
+        assert unique_img.shape[0] > 50
+        assert unique_img.max() == 255
+        assert unique_img.min() > 0
+
+
+run_tests_if_main()