vispy 0.9.5__cp38-cp38-win_amd64.whl → 0.14.0__cp38-cp38-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/isocurve.py

@@ -122,7 +122,7 @@ class IsocurveVisual(LineVisual):
         # this works for now and the existing examples, but should be tested
         # thoroughly also with the data-sanity check in set_data-function
         choice = np.nonzero((self.levels > self._data.min()) &
-                            (self._levels < self._data.max()))
+                            (self.levels < self._data.max()))
         levels_to_calc = np.array(self.levels)[choice]
 
         # save minimum level index

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/line/line.py

@@ -327,8 +327,7 @@ class _GLLineVisual(Visual):
         if self._parent._changed['pos']:
             if self._parent._pos is None:
                 return False
-            # todo: does this result in unnecessary copies?
-            pos = np.ascontiguousarray(self._parent._pos.astype(np.float32))
+            pos = np.ascontiguousarray(self._parent._pos, dtype=np.float32)
             self._pos_vbo.set_data(pos)
             self._program.vert['position'] = self._pos_vbo
             self._program.vert['to_vec4'] = self._ensure_vec4_func(pos.shape[-1])
@@ -437,9 +436,7 @@ class _AggLineVisual(Visual):
         if self._parent._changed['pos']:
             if self._parent._pos is None:
                 return False
-            # todo: does this result in unnecessary copies?
-            self._pos = np.ascontiguousarray(
-                self._parent._pos.astype(np.float32))
+            self._pos = np.ascontiguousarray(self._parent._pos, dtype=np.float32)
             bake = True
 
         if self._parent._changed['color']: