vispy 0.12.1__cp310-cp310-win_amd64.whl → 0.14.0__cp310-cp310-win_amd64.whl

vispy/visuals/instanced_mesh.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+"""An instanced version of MeshVisual with arbitrary shifts, transforms, and colors."""
+
+from __future__ import division
+
+import numpy as np
+
+from ..gloo import VertexBuffer
+from ..gloo.texture import downcast_to_32bit_if_needed
+from ..color import ColorArray
+from .filters import InstancedShadingFilter
+from .shaders import Variable
+
+from .mesh import MeshVisual
+
+
+_VERTEX_SHADER = """
+uniform bool use_instance_colors;
+
+// these attributes will be defined on an instance basis
+attribute vec3 shift;
+attribute vec3 transform_x;
+attribute vec3 transform_y;
+attribute vec3 transform_z;
+
+varying vec4 v_base_color;
+void main() {
+
+    v_base_color = $color_transform($base_color);
+
+    // transform is generated from column vectors (new basis vectors)
+    // https://en.wikibooks.org/wiki/GLSL_Programming/Vector_and_Matrix_Operations#Constructors
+    mat3 instance_transform = mat3(transform_x, transform_y, transform_z);
+    vec3 pos_rotated = instance_transform * $to_vec4($position).xyz;
+    vec4 pos_shifted = $to_vec4(pos_rotated + shift);
+    gl_Position = $transform(pos_shifted);
+}
+"""
+
+
+class InstancedMeshVisual(MeshVisual):
+    """Instanced Mesh visual.
+
+    Mostly identical to MeshVisual, but additionally takes arrays of
+    of positions and transforms (optionally colors) to create multiple
+    instances of the mesh.
+
+    Instancing is a rendering technique that re-uses the same mesh data
+    by applying transformations to vertices and vertex data or textures,
+    wich can drastically improve performance compared to having many
+    simple MeshVisuals.
+
+    Parameters
+    ----------
+    instance_positions : (I, 3) array
+        Coordinates for each instance of the mesh.
+    instance_transforms : (I, 3, 3) array
+        Matrices for the transforms to apply to each instance.
+    instance_colors : ColorArray
+        Matrices of colors for each instance. Colors
+    *args : list
+        Positional arguments to pass to :class:`~vispy.visuals.mesh.MeshVisual`.
+    **kwargs : dict
+        Keyword arguments to pass to :class:`~vispy.visuals.mesh.MeshVisual`.
+
+    Examples
+    --------
+    See example `scene/instanced_mesh_visual.py` in the gallery.
+    """
+
+    _shaders = {
+        'vertex': _VERTEX_SHADER,
+        'fragment': MeshVisual._shaders['fragment'],
+    }
+
+    _shading_filter_class = InstancedShadingFilter
+
+    def __init__(self, *args, instance_positions, instance_transforms, instance_colors=None, **kwargs):
+        self._instance_positions = None
+        self._instance_positions_vbo = None
+        self._instance_transforms = None
+        self._instance_transforms_vbos = None
+        self._instance_colors = None
+        self._instance_colors_vbo = None
+        super().__init__(*args, **kwargs)
+        self.instance_positions = instance_positions
+        self.instance_transforms = instance_transforms
+        self.instance_colors = instance_colors
+
+    @property
+    def instance_positions(self):
+        return self._instance_positions
+
+    @instance_positions.setter
+    def instance_positions(self, pos):
+        pos = np.reshape(pos, (-1, 3))
+        if pos.ndim != 2 or pos.shape[-1] != 3:
+            raise ValueError(f'positions must be 3D coordinates, but provided data has shape {pos.shape}')
+        self._instance_positions = downcast_to_32bit_if_needed(pos, dtype=np.float32)
+        self._instance_positions_vbo = VertexBuffer(self._instance_positions, divisor=1)
+        self.mesh_data_changed()
+
+    @property
+    def instance_transforms(self):
+        return self._instance_transforms
+
+    @instance_transforms.setter
+    def instance_transforms(self, matrix):
+        matrix = np.reshape(matrix, (-1, 3, 3))
+        if matrix.ndim != 3 or matrix.shape[1:] != (3, 3):
+            raise ValueError(f'transforms must be an array of 3x3 matrices, but provided data has shape {matrix.shape}')
+        self._instance_transforms = downcast_to_32bit_if_needed(matrix, dtype=np.float32)
+        # copy if not c contiguous
+        self._instance_transforms_vbos = (
+            VertexBuffer(np.ascontiguousarray(self._instance_transforms[..., 0]), divisor=1),
+            VertexBuffer(np.ascontiguousarray(self._instance_transforms[..., 1]), divisor=1),
+            VertexBuffer(np.ascontiguousarray(self._instance_transforms[..., 2]), divisor=1),
+        )
+        self.mesh_data_changed()
+
+    @property
+    def instance_colors(self):
+        return self._instance_colors
+
+    @instance_colors.setter
+    def instance_colors(self, colors):
+        if colors is not None:
+            colors = ColorArray(colors)
+            self._instance_colors_vbo = VertexBuffer(colors.rgba, divisor=1)
+        else:
+            self._instance_colors_vbo = Variable('base_color', self._color.rgba)
+
+        self._instance_colors = colors
+        self.mesh_data_changed()
+
+    def _update_data(self):
+        with self.events.data_updated.blocker():
+            super()._update_data()
+
+        # set instance buffers
+        self.shared_program.vert['base_color'] = self._instance_colors_vbo
+        self.shared_program['transform_x'] = self._instance_transforms_vbos[0]
+        self.shared_program['transform_y'] = self._instance_transforms_vbos[1]
+        self.shared_program['transform_z'] = self._instance_transforms_vbos[2]
+        self.shared_program['shift'] = self._instance_positions_vbo
+
+        self.events.data_updated()

vispy/visuals/line/dash_atlas.py

@@ -2,6 +2,8 @@
 # Copyright (c) Vispy Development Team. All Rights Reserved.
 # Distributed under the (new) BSD License. See LICENSE.txt for more info.
 
+from functools import lru_cache
+
 import numpy as np
 
 
@@ -40,46 +42,49 @@ class DashAtlas(object):
         self._atlas[key] = [self._index / float(self._data.shape[0]), period]
         self._index += 1
         self._dirty = True
-        # self.add_pattern(value)
-
-    def make_pattern(self, pattern, caps=[1, 1]):
-        """ """
-
-        # A pattern is defined as on/off sequence of segments
-        # It must be a multiple of 2
-        if len(pattern) > 1 and len(pattern) % 2:
-            pattern = [pattern[0] + pattern[-1]] + pattern[1:-1]
-        P = np.array(pattern)
-
-        # Period is the sum of all segment length
-        period = np.cumsum(P)[-1]
-
-        # Find all start and end of on-segment only
-        C, c = [], 0
-        for i in range(0, len(P) + 2, 2):
-            a = max(0.0001, P[i % len(P)])
-            b = max(0.0001, P[(i + 1) % len(P)])
-            C.extend([c, c + a])
-            c += a + b
-        C = np.array(C)
-
-        # Build pattern
+
+    def make_pattern(self, pattern, caps=(1, 1)):
         length = self._data.shape[1]
-        Z = np.zeros((length, 4), dtype=np.float32)
-        for i in np.arange(0, len(Z)):
-            x = period * (i) / float(len(Z) - 1)
-            index = np.argmin(abs(C - (x)))
-            if index % 2 == 0:
-                if x <= C[index]:
-                    dash_type = +1
-                else:
-                    dash_type = 0
-                dash_start, dash_end = C[index], C[index + 1]
+        return _make_pattern(length, pattern, caps)
+
+
+@lru_cache(maxsize=32)
+def _make_pattern(length, pattern, caps):
+    """Make a concrete dash pattern of a given length."""
+    # A pattern is defined as on/off sequence of segments
+    # It must be a multiple of 2
+    if len(pattern) > 1 and len(pattern) % 2:
+        pattern = [pattern[0] + pattern[-1]] + pattern[1:-1]
+    P = np.array(pattern)
+
+    # Period is the sum of all segment length
+    period = np.cumsum(P)[-1]
+
+    # Find all start and end of on-segment only
+    C, c = [], 0
+    for i in range(0, len(P) + 2, 2):
+        a = max(0.0001, P[i % len(P)])
+        b = max(0.0001, P[(i + 1) % len(P)])
+        C.extend([c, c + a])
+        c += a + b
+    C = np.array(C)
+
+    # Build pattern
+    Z = np.zeros((length, 4), dtype=np.float32)
+    for i in np.arange(0, len(Z)):
+        x = period * (i) / float(len(Z) - 1)
+        index = np.argmin(abs(C - (x)))
+        if index % 2 == 0:
+            if x <= C[index]:
+                dash_type = +1
+            else:
+                dash_type = 0
+            dash_start, dash_end = C[index], C[index + 1]
+        else:
+            if x > C[index]:
+                dash_type = -1
             else:
-                if x > C[index]:
-                    dash_type = -1
-                else:
-                    dash_type = 0
-                dash_start, dash_end = C[index - 1], C[index]
-            Z[i] = C[index], dash_type, dash_start, dash_end
-        return Z, period
+                dash_type = 0
+            dash_start, dash_end = C[index - 1], C[index]
+        Z[i] = C[index], dash_type, dash_start, dash_end
+    return Z, period

vispy/visuals/markers.py

@@ -11,6 +11,7 @@ from ..color import ColorArray
 from ..gloo import VertexBuffer
 from .shaders import Function, Variable
 from .visual import Visual
+from ..util.event import Event
 
 
 _VERTEX_SHADER = """
@@ -43,28 +44,27 @@ void main (void) {
 
     vec4 pos = vec4(a_position, 1);
     vec4 fb_pos = $visual_to_framebuffer(pos);
+    vec4 x;
+    vec4 size_vec;
     gl_Position = $framebuffer_to_render(fb_pos);
 
     // NOTE: gl_stuff uses framebuffer coords!
-
-    if (u_scaling == true) {
-        // calculate point size from visual to framebuffer coords to determine size
-        // move horizontally in framebuffer space
-        // then go to scene coordinates (not visual, so scaling is accounted for)
-        vec4 x = $framebuffer_to_scene(fb_pos + vec4(big_float, 0, 0, 0));
-        // subtract position, so we get the scene-coordinate vector describing
-        // an "horizontal direction parallel to the screen"
-        vec4 scene_pos = $framebuffer_to_scene(fb_pos);
-        x = (x - scene_pos);
-        // multiply that direction by the size (in scene space) and add it to the position
+    if (u_scaling) {
+        // scaling == "scene": scale marker using entire visual -> framebuffer set of transforms
+        // scaling == "visual": scale marker using only the Visual's transform
+        pos = $framebuffer_to_scene_or_visual(fb_pos);
+        x = $framebuffer_to_scene_or_visual(fb_pos + vec4(big_float, 0, 0, 0));
+        x = (x - pos);
+        // multiply that direction by the size and add it to the position
         // this gives us the position of the edge of the point, which we convert in screen space
-        vec4 size_vec = $scene_to_framebuffer(scene_pos + normalize(x) * a_size);
+        size_vec = $scene_or_visual_to_framebuffer(pos + normalize(x) * a_size);
         // divide by `w` for perspective, and subtract pos
         // this gives us the actual screen-space size of the point
         $v_size = size_vec.x / size_vec.w - fb_pos.x / fb_pos.w;
         v_edgewidth = ($v_size / a_size) * a_edgewidth;
     }
     else {
+        // scaling == "fixed": marker is always the same number of pixels
         $v_size = a_size * u_px_scale;
         v_edgewidth = a_edgewidth * u_px_scale;
     }
@@ -73,12 +73,13 @@ void main (void) {
     gl_PointSize = $v_size + 4. * (v_edgewidth + 1.5 * u_antialias);
 
     if (u_spherical == true) {
+        // similar as above for scaling, but in towards the screen direction
         // Get the framebuffer z direction relative to this sphere in visual coords
-        vec4 z = $framebuffer_to_visual(fb_pos + vec4(0, 0, big_float, 0));
+        vec4 z = $framebuffer_to_scene_or_visual(fb_pos + vec4(0, 0, big_float, 0));
         z = (z - pos);
         // Get the depth of the sphere in its middle point on the screen
         // size/2 because we need the radius, not the diameter
-        vec4 depth_z_vec = $visual_to_framebuffer(pos + normalize(z) * a_size / 2);
+        vec4 depth_z_vec = $scene_or_visual_to_framebuffer(pos + normalize(z) * a_size / 2);
         v_depth_middle = depth_z_vec.z / depth_z_vec.w - fb_pos.z / fb_pos.w;
         // size ratio between aliased and non-aliased, needed for correct depth
         v_alias_ratio = gl_PointSize / $v_size;
@@ -505,8 +506,20 @@ class MarkersVisual(Visual):
         The color used to draw each symbol interior.
     symbol : str or array
         The style of symbol used to draw each marker (see Notes).
-    scaling : bool
-        If set to True, marker scales when rezooming.
+    scaling : str | bool
+        Scaling method of individual markers. If set to "fixed" (default) then
+        no scaling is done and markers will always be the same number of
+        pixels on the screen. If set to "scene" then the chain of transforms
+        from the Visual's transform to the transform mapping to the OpenGL
+        framebuffer are used to scaling the marker. This has the effect of the
+        marker staying the same size in the "scene" coordinate space and
+        changing size as the visualization is zoomed in and out. If set to
+        "visual" the marker is scaled only using the transform of the Visual
+        and not the rest of the scene/camera. This means that something like
+        a camera changing the view will not affect the size of the marker, but
+        the user can still scale it using the Visual's transform. For
+        backwards compatibility this can be set to the boolean ``False`` for
+        "fixed" or ``True`` for "scene".
     alpha : float
         The opacity level of the visual.
     antialias : float
@@ -534,10 +547,11 @@ class MarkersVisual(Visual):
     _symbol_shader_values = symbol_shader_values
     _symbol_shader = symbol_func
 
-    def __init__(self, scaling=False, alpha=1, antialias=1, spherical=False,
+    def __init__(self, scaling="fixed", alpha=1, antialias=1, spherical=False,
                  light_color='white', light_position=(1, -1, 1), light_ambient=0.3, **kwargs):
         self._vbo = VertexBuffer()
         self._data = None
+        self._scaling = "fixed"
 
         Visual.__init__(self, vcode=self._shaders['vertex'], fcode=self._shaders['fragment'])
         self._symbol_func = Function(self._symbol_shader)
@@ -551,6 +565,8 @@ class MarkersVisual(Visual):
                           blend_func=('src_alpha', 'one_minus_src_alpha'))
         self._draw_mode = 'points'
 
+        self.events.add(data_updated=Event)
+
         if len(kwargs) > 0:
             self.set_data(**kwargs)
 
@@ -638,6 +654,7 @@ class MarkersVisual(Visual):
             self._vbo.set_data(data)
             self.shared_program.bind(self._vbo)
 
+        self.events.data_updated()
         self.update()
 
     @property
@@ -677,9 +694,18 @@ class MarkersVisual(Visual):
 
     @scaling.setter
     def scaling(self, value):
-        value = bool(value)
-        self.shared_program['u_scaling'] = value
-        self._scaling = value
+        scaling_modes = {
+            False: "fixed",
+            True: "scene",
+            "fixed": "fixed",
+            "scene": "scene",
+            "visual": "visual",
+        }
+        if value not in scaling_modes:
+            possible_options = ", ".join(repr(opt) for opt in scaling_modes)
+            raise ValueError(f"Unknown scaling option {value!r}, expected one of: {possible_options}")
+        self._scaling = scaling_modes[value]
+        self.shared_program['u_scaling'] = self._scaling != "fixed"
         self.update()
 
     @property
@@ -764,16 +790,15 @@ class MarkersVisual(Visual):
 
     def _prepare_transforms(self, view):
         view.view_program.vert['visual_to_framebuffer'] = view.get_transform('visual', 'framebuffer')
-        view.view_program.vert['framebuffer_to_visual'] = view.get_transform('framebuffer', 'visual')
         view.view_program.vert['framebuffer_to_render'] = view.get_transform('framebuffer', 'render')
-        view.view_program.vert['framebuffer_to_scene'] = view.get_transform('framebuffer', 'scene')
-        view.view_program.vert['scene_to_framebuffer'] = view.get_transform('scene', 'framebuffer')
+        scaling = view._scaling if view._scaling != "fixed" else "scene"
+        view.view_program.vert['framebuffer_to_scene_or_visual'] = view.get_transform('framebuffer', scaling)
+        view.view_program.vert['scene_or_visual_to_framebuffer'] = view.get_transform(scaling, 'framebuffer')
 
     def _prepare_draw(self, view):
         if self._data is None:
             return False
         view.view_program['u_px_scale'] = view.transforms.pixel_scale
-        view.view_program['u_scaling'] = self.scaling
 
     def _compute_bounds(self, axis, view):
         pos = self._data['a_position']

vispy/visuals/mesh.py

@@ -283,8 +283,8 @@ class MeshVisual(Visual):
         clim_func = 'float cmap(float val) { return (val - $cmin) / ($cmax - $cmin); }'
         if colors.ndim == 2 and colors.shape[1] == 1:
             fun = Function(clim_func)
-            fun['cmin'] = self.clim[0]
-            fun['cmax'] = self.clim[1]
+            fun['cmin'] = self._clim_values[0]
+            fun['cmax'] = self._clim_values[1]
             fun = FunctionChain(None, [fun, Function(self.cmap.glsl_map)])
         else:
             fun = Function(null_color_transform)

vispy/visuals/tests/test_instanced_mesh.py

@@ -0,0 +1,50 @@
+import numpy as np
+from vispy import scene, use
+
+from vispy.testing import (TestingCanvas, requires_application,
+                           run_tests_if_main, requires_pyopengl)
+
+
+def setup_module(module):
+    use(gl='gl+')
+
+
+def teardown_module(module):
+    use(gl='gl2')
+
+
+@requires_pyopengl()
+@requires_application()
+def test_mesh_with_vertex_values():
+    size = (80, 60)
+    with TestingCanvas(size=size) as c:
+        use(gl='gl+')
+        vert = np.array([[0, 0, 0], [0, 30, 0], [40, 0, 0]])
+        faces = np.array([0, 1, 2])
+        pos = np.array([[0, 0, 0], [80, 60, 0]])
+        # identity and rotate 180
+        trans = np.array([
+            [
+                [1, 0, 0],
+                [0, 1, 0],
+                [0, 0, 1],
+            ],
+            [
+                [-1, 0, 0],
+                [0, -1, 0],
+                [0, 0, 1],
+            ],
+        ])
+        colors = ['red', 'blue']
+        mesh = scene.visuals.InstancedMesh(
+            vertices=vert, faces=faces, instance_positions=pos, instance_transforms=trans, instance_colors=colors
+        )
+        v = c.central_widget.add_view(border_width=0)
+        v.add(mesh)
+        render = c.render()
+        assert np.allclose(render[10, 10], (255, 0, 0, 255))
+        assert np.allclose(render[-10, -10], (0, 0, 255, 255))
+        assert np.allclose(render[30, 40], (0, 0, 0, 255))
+
+
+run_tests_if_main()

vispy/visuals/tests/test_mesh.py

@@ -31,6 +31,23 @@ def test_mesh_color():
     np.testing.assert_allclose(vertices['position'], new_vertices)
 
 
+@requires_pyopengl()
+@requires_application()
+def test_mesh_with_vertex_values():
+    size = (45, 40)
+    with TestingCanvas(size=size) as c:
+        v = c.central_widget.add_view(border_width=0)
+        vertices = np.array([(0, 0, 0), (0, 0, 1), (1, 0, 0)], dtype=float)
+        faces = np.array([(0, 1, 2)])
+        mesh = scene.visuals.Mesh(
+            vertices=vertices,
+            faces=faces,
+            vertex_values=np.ones(len(vertices)),
+        )
+        v.add(mesh)
+        c.render()
+
+
 @requires_pyopengl()
 @requires_application()
 @pytest.mark.parametrize('shading', [None, 'flat', 'smooth'])

vispy/visuals/text/_sdf_cpu.pyx

@@ -1,5 +1,4 @@
-# -*- coding: utf-8 -*-
-
+# cython: language_level=3, boundscheck=False, cdivision=True, wraparound=False, initializedcheck=False, nonecheck=False
 # A Cython implementation of the "eight-points signed sequential Euclidean
 # distance transform algorithm" (8SSEDT)
 
@@ -18,13 +17,14 @@ ctypedef np.complex64_t DTYPE_ct
 cdef DTYPE_ct MAX_VAL = (1e6 + 1e6j)
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
 def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
                          int w, int h, DTYPE_t sp_f):
     # initialize grids
-    cdef np.ndarray[DTYPE_ct, ndim=2] g0 = np.zeros((h, w), dtype_c)
-    cdef np.ndarray[DTYPE_ct, ndim=2] g1 = np.zeros((h, w), dtype_c)
+    cdef np.ndarray[DTYPE_ct, ndim=2] g0_arr = np.zeros((h, w), dtype_c)
+    cdef np.ndarray[DTYPE_ct, ndim=2] g1_arr = np.zeros((h, w), dtype_c)
+    cdef DTYPE_ct[:, ::1] g0 = g0_arr
+    cdef DTYPE_ct[:, ::1] g1 = g1_arr
+    cdef DTYPE_t[:, :] pixels_view = pixels
     cdef Py_ssize_t y, x
     for y in range(h):
         g0[y, 0] = MAX_VAL
@@ -32,9 +32,9 @@ def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
         g1[y, 0] = MAX_VAL
         g1[y, w-1] = MAX_VAL
         for x in range(1, w-1):
-            if pixels[y, x] > 0:
+            if pixels_view[y, x] > 0:
                 g0[y, x] = MAX_VAL
-            if pixels[y, x] < 1:
+            if pixels_view[y, x] < 1:
                 g1[y, x] = MAX_VAL
     for x in range(w):
         g0[0, x] = MAX_VAL
@@ -50,37 +50,35 @@ def _calc_distance_field(np.ndarray[DTYPE_t, ndim=2] pixels,
     cdef DTYPE_t r_sp_f_2 = 1. / (sp_f * 2.)
     for y in range(1, h-1):
         for x in range(1, w-1):
-            pixels[y, x] = sqrt(dist(g0[y, x])) - sqrt(dist(g1[y, x]))
-            if pixels[y, x] < 0:
-                pixels[y, x] = (pixels[y, x] + sp_f) * r_sp_f_2
+            pixels_view[y, x] = sqrt(dist(g0[y, x])) - sqrt(dist(g1[y, x]))
+            if pixels_view[y, x] < 0:
+                pixels_view[y, x] = (pixels_view[y, x] + sp_f) * r_sp_f_2
             else:
-                pixels[y, x] = 0.5 + pixels[y, x] * r_sp_f_2
-            pixels[y, x] = max(min(pixels[y, x], 1), 0)
+                pixels_view[y, x] = 0.5 + pixels_view[y, x] * r_sp_f_2
+            pixels_view[y, x] = max(min(pixels_view[y, x], 1), 0)
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef Py_ssize_t compare(DTYPE_ct *cell, DTYPE_ct xy, DTYPE_t *current):
+cdef inline Py_ssize_t compare(DTYPE_ct *cell, DTYPE_ct xy, DTYPE_t *current) noexcept nogil:
     cdef DTYPE_t val = dist(xy)
     if val < current[0]:
         cell[0] = xy
         current[0] = val
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef DTYPE_t dist(DTYPE_ct val):
+cdef DTYPE_t dist(DTYPE_ct val) noexcept nogil:
     return val.real*val.real + val.imag*val.imag
 
 
-@cython.boundscheck(False)  # designed to stay within bounds
-@cython.wraparound(False)  # we don't use negative indexing
-cdef void _propagate(np.ndarray[DTYPE_ct, ndim=2] grid):
+cdef void _propagate(DTYPE_ct[:, :] grid) noexcept nogil:
     cdef Py_ssize_t height = grid.shape[0]
     cdef Py_ssize_t width = grid.shape[1]
     cdef Py_ssize_t y, x
     cdef DTYPE_t current
-    cdef DTYPE_ct a0=-1, a1=-1j, a2=-1-1j, a3=1-1j
+    cdef DTYPE_ct a0, a1, a2, a3
+    a0 = -1
+    a1 = -1j
+    a2 = -1 - 1j
+    a3 = 1 - 1j
     cdef DTYPE_ct b0=1
     cdef DTYPE_ct c0=1, c1=1j, c2=-1+1j, c3=1+1j
     cdef DTYPE_ct d0=-1

vispy/visuals/tube.py

@@ -80,7 +80,7 @@ class TubeVisual(MeshVisual):
 
             # Add a vertex for each point on the circle
             v = np.arange(tube_points,
-                          dtype=np.float) / tube_points * 2 * np.pi
+                          dtype=np.float32) / tube_points * 2 * np.pi
             cx = -1. * r * np.cos(v)
             cy = r * np.sin(v)
             grid[i] = (pos + cx[:, np.newaxis]*normal +