vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/gloo/tests/test_buffer.py

@@ -0,0 +1,558 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+import unittest
+import numpy as np
+
+from vispy.testing import run_tests_if_main
+from vispy.gloo.buffer import (Buffer, DataBuffer, DataBufferView, 
+                               VertexBuffer, IndexBuffer)
+
+
+# -----------------------------------------------------------------------------
+class BufferTest(unittest.TestCase):
+
+    # Default init
+    # ------------
+    def test_init_default(self):
+        """Test buffer init"""
+        # No data
+        B = Buffer()
+        assert B.nbytes == 0
+        glir_cmd = B._glir.clear()[-1]
+        assert glir_cmd[0] == 'CREATE'
+
+        # With data
+        data = np.zeros(100)
+        B = Buffer(data=data)
+        assert B.nbytes == data.nbytes
+        glir_cmd = B._glir.clear()[-1]
+        assert glir_cmd[0] == 'DATA'
+
+        # With nbytes
+        B = Buffer(nbytes=100)
+        assert B.nbytes == 100
+        glir_cmd = B._glir.clear()[-1]
+        assert glir_cmd[0] == 'SIZE'
+
+        # Wrong data
+        self.assertRaises(ValueError, Buffer, data, 4)
+        self.assertRaises(ValueError, Buffer, data, data.nbytes)
+
+    # Check setting the whole buffer clear pending operations
+    # -------------------------------------------------------
+    def test_set_whole_data(self):
+        data = np.zeros(100)
+        B = Buffer(data=data)
+        B._glir.clear()
+        B.set_data(data=data)
+        glir_cmds = B._glir.clear()
+        assert len(glir_cmds) == 2
+        assert glir_cmds[0][0] == 'SIZE'
+        assert glir_cmds[1][0] == 'DATA'
+
+        # And sub data
+        B.set_subdata(data[:50], 20)
+        glir_cmds = B._glir.clear()
+        assert len(glir_cmds) == 1
+        assert glir_cmds[0][0] == 'DATA'
+        assert glir_cmds[0][2] == 20  # offset
+
+        # And sub data
+        B.set_subdata(data)
+        glir_cmds = B._glir.clear()
+        assert glir_cmds[-1][0] == 'DATA'
+
+        # Wrong ways to set subdata
+        self.assertRaises(ValueError, B.set_subdata, data[:50], -1)  # neg
+        self.assertRaises(ValueError, B.set_subdata, data, 10)  # no fit
+
+    # Check stored data is data
+    # -------------------------
+    def test_data_storage(self):
+        data = np.zeros(100)
+        B = Buffer(data=data)
+        B.set_data(data=data[:50], copy=False)
+        glir_cmd = B._glir.clear()[-1]
+        assert glir_cmd[-1].base is data
+
+    # Check setting oversized data
+    # ----------------------------
+    def test_oversized_data(self):
+        data = np.zeros(10)
+        B = Buffer(data=data)
+        # with self.assertRaises(ValueError):
+        #    B.set_data(np.ones(20))
+        self.assertRaises(ValueError, B.set_subdata, np.ones(20), offset=0)
+
+    # Check negative offset
+    # ---------------------
+    def test_negative_offset(self):
+        data = np.zeros(10)
+        B = Buffer(data=data)
+        # with self.assertRaises(ValueError):
+        #    B.set_data(np.ones(1), offset=-1)
+        self.assertRaises(ValueError, B.set_subdata, np.ones(1), offset=-1)
+
+    # Check offlimit offset
+    # ---------------------
+    def test_offlimit_offset(self):
+        data = np.zeros(10)
+        B = Buffer(data=data)
+        # with self.assertRaises(ValueError):
+        #    B.set_data(np.ones(1), offset=10 * data.dtype.itemsize)
+        self.assertRaises(ValueError, B.set_subdata,
+                          np.ones(1), offset=10 * data.dtype.itemsize)
+
+    # Buffer size
+    # -----------
+    def test_buffer_size(self):
+        data = np.zeros(10)
+        B = Buffer(data=data)
+        assert B.nbytes == data.nbytes
+
+    # Resize
+    # ------
+    def test_buffer_resize(self):
+        data = np.zeros(10)
+        B = Buffer(data=data)
+        data = np.zeros(20)
+        B.set_data(data)
+        assert B.nbytes == data.nbytes
+
+
+# -----------------------------------------------------------------------------
+class DataBufferTest(unittest.TestCase):
+
+    # Default init
+    # ------------
+    def test_default_init(self):
+        # Check default storage and copy flags
+        data = np.ones(100)
+        B = DataBuffer(data)
+        assert B.nbytes == data.nbytes
+        assert B.offset == 0
+        assert B.size == 100
+        assert B.itemsize == data.itemsize
+        assert B.stride == data.itemsize
+        assert B.dtype == data.dtype
+
+        # Given data must be actual numeric data
+        self.assertRaises(TypeError, DataBuffer, 'this is not nice data')
+
+    # Default init with structured data
+    # ---------------------------------
+    def test_structured_init(self):
+        # Check structured type
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        assert B.nbytes == data.nbytes
+        assert B.offset == 0
+        assert B.size == 10
+        assert B.itemsize == data.itemsize
+        assert B.stride == data.itemsize
+        assert B.dtype == data.dtype
+
+    # No CPU storage
+    # --------------
+    def test_no_storage_copy(self):
+        data = np.ones(100, np.float32)
+        B = DataBuffer(data)
+        assert B.stride == 4
+
+    # Wrong storage
+    # -------------
+    def test_non_contiguous_storage(self):
+        # Ask to have CPU storage and to use data as storage
+        # Not possible since data[::2] is not contiguous
+        data = np.ones(100, np.float32)
+        data_given = data[::2]
+
+        B = DataBuffer(data_given)
+        assert B.stride == 4*2
+
+    # Get buffer field
+    # ----------------
+    def test_getitem_field(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+
+        Z = B["position"]
+        assert Z.nbytes == 10 * 3 * np.dtype(np.float32).itemsize
+        assert Z.offset == 0
+        assert Z.size == 10
+        assert Z.itemsize == 3 * np.dtype(np.float32).itemsize
+        assert Z.stride == (3 + 2 + 4) * np.dtype(np.float32).itemsize
+        assert Z.dtype == (np.float32, 3)
+
+        Z = B["texcoord"]
+        assert Z.nbytes == 10 * 2 * np.dtype(np.float32).itemsize
+        assert Z.offset == 3 * np.dtype(np.float32).itemsize
+        assert Z.size == 10
+        assert Z.itemsize == 2 * np.dtype(np.float32).itemsize
+        assert Z.stride == (3 + 2 + 4) * np.dtype(np.float32).itemsize
+        assert Z.dtype == (np.float32, 2)
+
+        Z = B["color"]
+        assert Z.nbytes == 10 * 4 * np.dtype(np.float32).itemsize
+        assert Z.offset == (2 + 3) * np.dtype(np.float32).itemsize
+        assert Z.size == 10
+        assert Z.itemsize == 4 * np.dtype(np.float32).itemsize
+        assert Z.stride == (3 + 2 + 4) * np.dtype(np.float32).itemsize
+        assert Z.dtype == (np.float32, 4)
+
+    # Get view via index
+    # ------------------
+    def test_getitem_index(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        Z = B[0:1]
+        assert Z.base == B
+        assert Z.id == B.id
+        assert Z.nbytes == 1 * (3 + 2 + 4) * np.dtype(np.float32).itemsize
+        assert Z.offset == 0
+        assert Z.size == 1
+        assert Z.itemsize == (3 + 2 + 4) * np.dtype(np.float32).itemsize
+        assert Z.stride == (3 + 2 + 4) * np.dtype(np.float32).itemsize
+        assert Z.dtype == B.dtype
+        assert 'DataBufferView' in repr(Z)
+
+        # There's a few things we cannot do with a view
+        self.assertRaises(RuntimeError, Z.set_data, data)
+        self.assertRaises(RuntimeError, Z.set_subdata, data)
+        self.assertRaises(RuntimeError, Z.resize_bytes, 20)
+        self.assertRaises(RuntimeError, Z.__getitem__, 3)
+        self.assertRaises(RuntimeError, Z.__setitem__, 3, data)
+
+    # View get invalidated when base is resized
+    # -----------------------------------------
+    def test_invalid_view_after_resize(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        Y = B['position']
+        Z = B[5:]
+        B.resize_bytes(5)
+        assert Y._valid is False
+        assert Z._valid is False
+
+    # View get invalidated after setting oversized data
+    # -------------------------------------------------
+    def test_invalid_view_after_set_data(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        Z = B[5:]
+        B.set_data(np.zeros(15, dtype=dtype))
+        assert Z._valid is False
+
+    # Set data on base buffer : ok
+    # ----------------------------
+    def test_set_data_base(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        B.set_data(data)
+        last_cmd = B._glir.clear()[-1]
+        assert last_cmd[0] == 'DATA'
+
+        # Extra kwargs are caught
+        self.assertRaises(TypeError, B.set_data, data, foo=4)
+
+    # Check set_data using offset in data buffer
+    # ------------------------------------------
+    def test_set_data_offset(self):
+        data = np.zeros(100, np.float32)
+        subdata = data[:10]
+
+        B = DataBuffer(data)
+        B.set_subdata(subdata, offset=10)
+        last_cmd = B._glir.clear()[-1]
+        offset = last_cmd[2]
+        assert offset == 10*4
+
+    def test_getitem(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        assert B[1].dtype == dtype
+        assert B[1].size == 1
+        assert B[-1].dtype == dtype
+        assert B[-1].size == 1
+
+        self.assertRaises(IndexError, B.__getitem__, +999)
+        self.assertRaises(IndexError, B.__getitem__, -999)
+
+    def test_setitem(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        B[1] = data[0]
+        B[-1] = data[0]
+        B[:5] = data[:5]
+        B[5:0] = data[:5]  # Weird, but we apparently support this
+        # the below is no longer supported starting with NumPy 1.14.0
+        # this used to be converted to a single element array of the above
+        # dtype filled with 0s. This is no longer supported.
+        # B[1] = b''  # Gets converted into array of dtype. Lists do not work
+        # the below doesn't work on all systems (I guess?)
+        # B[1] = 0
+        B[1] = ([0, 0, 0], [0, 0], [0, 0, 0, 0],)
+
+        self.assertRaises(IndexError, B.__setitem__, +999, data[0])
+        self.assertRaises(IndexError, B.__setitem__, -999, data[0])
+        self.assertRaises(TypeError, B.__setitem__, [], data[0])
+
+    # Setitem + broadcast
+    # ------------------------------------------------------
+    def test_setitem_broadcast(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        self.assertRaises(ValueError, B.__setitem__, 'position', (1, 2, 3))
+
+    # Set every 2 item
+    # ------------------------------------------------------
+    def test_setitem_strided(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data1 = np.zeros(10, dtype=dtype)
+        data2 = np.ones(10, dtype=dtype)
+        B = DataBuffer(data1)
+        s = slice(None, None, 2)
+        self.assertRaises(ValueError, B.__setitem__, s, data2[::2])
+
+    # Set half the array
+    # ------------------------------------------------------
+    def test_setitem_half(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data1 = np.zeros(10, dtype=dtype)
+        data2 = np.ones(10, dtype=dtype)
+        B = DataBuffer(data1)
+        B._glir.clear()
+        B[:5] = data2[:5]
+        glir_cmds = B._glir.clear()
+        assert len(glir_cmds) == 1
+        set_data = glir_cmds[0][-1]
+        assert np.allclose(set_data['position'], data2['position'][:5])
+        assert np.allclose(set_data['texcoord'][:5], data2['texcoord'][:5])
+        assert np.allclose(set_data['color'][:5], data2['color'][:5])
+
+    # Set field without storage: error
+    # --------------------------------
+    def test_setitem_field_no_storage(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        self.assertRaises(ValueError, B.__setitem__, 'position', (1, 2, 3))
+
+    # Set every 2 item without storage:  error
+    # ----------------------------------------
+    def test_every_two_item_no_storage(self):
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2),
+                          ('color', np.float32, 4)])
+        data = np.zeros(10, dtype=dtype)
+        B = DataBuffer(data)
+        # with self.assertRaises(ValueError):
+        #    B[::2] = data[::2]
+        s = slice(None, None, 2)
+        self.assertRaises(ValueError, B.__setitem__, s, data[::2])
+
+    # Resize
+    # ------
+    def test_resize(self):
+        data = np.zeros(10)
+        B = DataBuffer(data=data)
+        data = np.zeros(20)
+        B.set_data(data)
+        assert B.nbytes == data.nbytes
+
+    # Resize now allowed using ellipsis
+    # -----------------------------
+    def test_no_resize_ellipsis(self):
+        data = np.zeros(10)
+        B = DataBuffer(data=data)
+        data = np.zeros(30)
+        self.assertRaises(ValueError, B.__setitem__, Ellipsis, data)
+
+    # Broadcast when using ellipses
+    def test_broadcast_ellipsis(self):
+        data = np.zeros(10)
+        B = DataBuffer(data=data)
+        data = np.zeros(5)
+        B[Ellipsis] = data
+        glir_cmd = B._glir.clear()[-1]
+        assert glir_cmd[-1].shape == (10,)
+
+
+class DataBufferViewTest(unittest.TestCase):
+
+    def test_init_view(self):
+        data = np.zeros(10)
+        B = DataBuffer(data=data)
+
+        V = DataBufferView(B, 1)
+        assert V.size == 1
+
+        V = DataBufferView(B, slice(0, 5))
+        assert V.size == 5
+
+        V = DataBufferView(B, slice(5, 0))
+        assert V.size == 5
+
+        V = DataBufferView(B, Ellipsis)
+        assert V.size == 10
+
+        self.assertRaises(TypeError, DataBufferView, B, [])
+        self.assertRaises(ValueError, DataBufferView, B, slice(0, 10, 2))
+
+
+# -----------------------------------------------------------------------------
+class VertexBufferTest(unittest.TestCase):
+
+    # VertexBuffer allowed base types
+    # -------------------------------
+    def test_init_allowed_dtype(self):
+        for dtype in (np.uint8, np.int8, np.uint16, np.int16, np.float32):
+            V = VertexBuffer(np.zeros((10, 3), dtype=dtype))
+            names = V.dtype.names
+            assert V.dtype[names[0]].base == dtype
+            assert V.dtype[names[0]].shape == (3,)
+        for dtype in (np.float64, np.int64):
+            self.assertRaises(TypeError, VertexBuffer,
+                              np.zeros((10, 3), dtype=dtype))
+
+        # Tuple/list is also allowed
+        V = VertexBuffer([1, 2, 3])
+        assert V.size == 3
+        assert V.itemsize == 4
+        #
+        V = VertexBuffer([[1, 2], [3, 4], [5, 6]])
+        assert V.size == 3
+        assert V.itemsize == 2 * 4
+
+        # Convert
+        data = np.zeros((10,), 'uint8')
+        B = VertexBuffer(data)
+        assert B.dtype[0].base == np.uint8
+        assert B.dtype[0].itemsize == 1
+        #
+        data = np.zeros((10, 2), 'uint8')
+        B = VertexBuffer(data)
+        assert B.dtype[0].base == np.uint8
+        assert B.dtype[0].itemsize == 2
+        B.set_data(data, convert=True)
+        assert B.dtype[0].base == np.float32
+        assert B.dtype[0].itemsize == 8
+        B = VertexBuffer(data[::2].copy())
+
+        # This is converted to 1D
+        B = VertexBuffer([[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]])
+        assert B.size == 10 
+
+        # Not allowed
+        self.assertRaises(TypeError, VertexBuffer, dtype=np.float64)
+        # self.assertRaises(TypeError, VertexBuffer, [[1,2,3,4,5],[1,2,3,4,5]])
+
+    # VertexBuffer not allowed base types
+    # -----------------------------------
+    def test_init_not_allowed_dtype(self):
+        for dtype in (np.uint32, np.int32, np.float64):
+            # with self.assertRaises(TypeError):
+            #    V = VertexBuffer(dtype=dtype)
+            self.assertRaises(TypeError, VertexBuffer, dtype=dtype)
+
+    def test_glsl_type(self):
+
+        data = np.zeros((10,), np.float32)
+        B = VertexBuffer(data)
+        C = B[1:]
+        assert B.glsl_type == ('attribute', 'float')
+        assert C.glsl_type == ('attribute', 'float')
+
+        data = np.zeros((10, 2), np.float32)
+        B = VertexBuffer(data)
+        C = B[1:]
+        assert B.glsl_type == ('attribute', 'vec2')
+        assert C.glsl_type == ('attribute', 'vec2')
+
+        data = np.zeros((10, 4), np.float32)
+        B = VertexBuffer(data)
+        C = B[1:]
+        assert B.glsl_type == ('attribute', 'vec4')
+        assert C.glsl_type == ('attribute', 'vec4')
+
+
+# -----------------------------------------------------------------------------
+class IndexBufferTest(unittest.TestCase):
+
+    # IndexBuffer allowed base types
+    # ------------------------------
+    def test_init_allowed_dtype(self):
+
+        # allowed dtypes
+        for dtype in (np.uint8, np.uint16, np.uint32):
+            b = IndexBuffer(np.zeros(10, dtype=dtype))
+            b.dtype == dtype
+
+        # no data => no dtype
+        V = IndexBuffer()
+        V.dtype is None
+
+        # Not allowed dtypes
+        for dtype in (np.int8, np.int16, np.int32,
+                      np.float16, np.float32, np.float64):
+            # with self.assertRaises(TypeError):
+            #    V = IndexBuffer(dtype=dtype)
+            data = np.zeros(10, dtype=dtype)
+            self.assertRaises(TypeError, IndexBuffer, data)
+
+        # Prepare some data
+        dtype = np.dtype([('position', np.float32, 3),
+                          ('texcoord', np.float32, 2), ])
+        sdata = np.zeros(10, dtype=dtype)
+
+        # Normal data is
+        data = np.zeros([1, 2, 3], np.uint8)
+        B = IndexBuffer(data)
+        assert B.dtype == np.uint8
+
+        # We can also convert
+        B.set_data(data, convert=True)
+        assert B.dtype == np.uint32
+
+        # Structured data not allowed
+        self.assertRaises(TypeError, IndexBuffer, dtype=dtype)
+        self.assertRaises(TypeError, B.set_data, sdata)
+
+
+run_tests_if_main()

vispy/gloo/tests/test_context.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+
+import gc
+
+from vispy.testing import (assert_in, run_tests_if_main, assert_raises,
+                           assert_equal, assert_not_equal)
+
+from vispy import gloo
+from vispy.gloo import (GLContext, get_default_config)
+
+
+class DummyCanvas(object):
+
+    @property
+    def glir(self):
+        return self
+
+    def command(self, *args):
+        pass
+
+
+class DummyCanvasBackend(object):
+
+    def __init__(self):
+        self.set_current = False
+        self._vispy_canvas = DummyCanvas()
+
+    def _vispy_set_current(self):
+        self.set_current = True
+
+
+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'})
+
+    # Capabilites are passed on
+    assert 'gl_version' in c.capabilities
+
+
+def test_context_taking():
+    """Test GLContext ownership and taking"""
+    def get_canvas(c):
+        return c.shared.ref
+
+    cb = DummyCanvasBackend()
+    c = GLContext()
+
+    # Context is not taken and cannot get backend_canvas
+    assert c.shared.name is None
+    assert_raises(RuntimeError, get_canvas, c)
+    assert_in('None backend', repr(c.shared))
+
+    # Take it
+    c.shared.add_ref('test-foo', cb)
+    assert c.shared.ref is cb
+    assert_in('test-foo backend', repr(c.shared))
+
+    # Now we can take it again
+    c.shared.add_ref('test-foo', cb)
+    assert len(c.shared._refs) == 2
+    # assert_raises(RuntimeError, c.take, 'test', cb)
+
+    # Canvas backend can delete (we use a weak ref)
+    cb = DummyCanvasBackend()  # overwrite old object
+    gc.collect()
+
+    # No more refs
+    assert_raises(RuntimeError, get_canvas, c)
+
+
+def test_gloo_without_app():
+    """Test gloo without vispy.app (with FakeCanvas)"""
+    # Create dummy parser
+    class DummyParser(gloo.glir.BaseGlirParser):
+        def __init__(self):
+            self.commands = []
+
+        def parse(self, commands):
+            self.commands.extend(commands)
+
+    p = DummyParser()
+
+    # Create fake canvas and attach our parser
+    c = gloo.context.FakeCanvas()
+    c.context.shared.parser = p
+
+    # Do some commands
+    gloo.clear()
+    c.flush()
+    gloo.clear()
+    c.flush()
+
+    assert len(p.commands) in (2, 3)  # there may be a CURRENT command
+    assert p.commands[-1][1] == 'glClear'
+
+
+run_tests_if_main()