vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/visuals/collections/raw_segment_collection.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+Raw Segment Collection
+
+This collection provides fast raw (& ugly) line segments.
+"""
+import numpy as np
+from ... import glsl
+from . collection import Collection
+from ..transforms import NullTransform
+
+
+class RawSegmentCollection(Collection):
+    """
+    Raw Segment Collection
+
+    This collection provides fast raw (& ugly) line segments.
+    """
+
+    def __init__(self, user_dtype=None, transform=None,
+                 vertex=None, fragment=None, **kwargs):
+        """
+        Initialize the collection.
+
+        Parameters
+        ----------
+        user_dtype: list
+            The base dtype can be completed (appended) by the used_dtype. It
+            only make sense if user also provide vertex and/or fragment shaders
+
+        transform : string
+            GLSL Transform code defining the vec4 transform(vec3) function
+
+        vertex: string
+            Vertex shader code
+
+        fragment: string
+            Fragment  shader code
+
+        color : string
+            'local', 'shared' or 'global'
+        """
+        base_dtype = [("position", (np.float32, 3), "!local", (0, 0, 0)),
+                      ("color", (np.float32, 4), "global", (0, 0, 0, 1)),
+                      ("viewport", (np.float32, 4), "global", (0, 0, 512, 512))
+                      ]
+
+        dtype = base_dtype
+        if user_dtype:
+            dtype.extend(user_dtype)
+
+        if vertex is None:
+            vertex = glsl.get('collections/raw-segment.vert')
+        if transform is None:
+            transform = NullTransform()
+        self.transform = transform        
+        if fragment is None:
+            fragment = glsl.get('collections/raw-segment.frag')
+
+        Collection.__init__(self, dtype=dtype, itype=None, mode='lines',
+                            vertex=vertex, fragment=fragment, **kwargs)
+        self._programs[0].vert['transform'] = self.transform
+
+    def append(self, P0, P1, itemsize=None, **kwargs):
+        """
+        Append a new set of segments to the collection.
+
+        For kwargs argument, n is the number of vertices (local) or the number
+        of item (shared)
+
+        Parameters
+        ----------
+        P : np.array
+            Vertices positions of the path(s) to be added
+
+        closed: bool
+            Whether path(s) is/are closed
+
+        itemsize: int or None
+            Size of an individual path
+
+        color : list, array or 4-tuple
+           Path color
+        """
+        itemsize = itemsize or 1
+        itemcount = len(P0) / itemsize
+
+        V = np.empty(itemcount, dtype=self.vtype)
+
+        # Apply default values on vertices
+        for name in self.vtype.names:
+            if name not in ['collection_index', 'P']:
+                V[name] = kwargs.get(name, self._defaults[name])
+
+        V = np.repeat(V, 2, axis=0)
+        V['P'][0::2] = P0
+        V['P'][1::2] = P1
+
+        # Uniforms
+        if self.utype:
+            U = np.zeros(itemcount, dtype=self.utype)
+            for name in self.utype.names:
+                if name not in ["__unused__"]:
+                    U[name] = kwargs.get(name, self._defaults[name])
+        else:
+            U = None
+
+        Collection.append(self, vertices=V, uniforms=U, itemsize=itemsize)

vispy/visuals/collections/raw_triangle_collection.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+import numpy as np
+from ... import glsl
+from . collection import Collection
+from ..transforms import NullTransform
+
+
+class RawTriangleCollection(Collection):
+
+    """
+    """
+
+    def __init__(self, user_dtype=None, transform=None,
+                 vertex=None, fragment=None, **kwargs):
+
+        base_dtype = [('position', (np.float32, 3), '!local', (0, 0, 0)),
+                      ('color', (np.float32, 4), 'local', (0, 0, 0, 1))]
+
+        dtype = base_dtype
+        if user_dtype:
+            dtype.extend(user_dtype)
+
+        if vertex is None:
+            vertex = glsl.get('collections/raw-triangle.vert')
+        if transform is None:
+            transform = NullTransform()
+        self.transform = transform        
+        if fragment is None:
+            fragment = glsl.get('collections/raw-triangle.frag')
+
+        Collection.__init__(self, dtype=dtype, itype=np.uint32,
+                            mode="triangles",
+                            vertex=vertex, fragment=fragment, **kwargs)
+        self._programs[0].vert['transform'] = self.transform
+
+    def append(self, points, indices, **kwargs):
+        """
+        Append a new set of vertices to the collection.
+
+        For kwargs argument, n is the number of vertices (local) or the number
+        of item (shared)
+
+        Parameters
+        ----------
+        points : np.array
+            Vertices composing the triangles
+
+        indices : np.array
+            Indices describing triangles
+
+        color : list, array or 4-tuple
+           Path color
+        """
+        itemsize = len(points)
+        itemcount = 1
+
+        V = np.empty(itemcount * itemsize, dtype=self.vtype)
+        for name in self.vtype.names:
+            if name not in ['collection_index', 'position']:
+                V[name] = kwargs.get(name, self._defaults[name])
+        V["position"] = points
+
+        # Uniforms
+        if self.utype:
+            U = np.zeros(itemcount, dtype=self.utype)
+            for name in self.utype.names:
+                if name not in ["__unused__"]:
+                    U[name] = kwargs.get(name, self._defaults[name])
+        else:
+            U = None
+
+        Collection.append(self, vertices=V, uniforms=U,
+                          indices=np.array(indices).ravel(),
+                          itemsize=itemsize)

vispy/visuals/collections/segment_collection.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+from . raw_segment_collection import RawSegmentCollection
+from . agg_segment_collection import AggSegmentCollection
+
+
+def SegmentCollection(mode="agg-fast", *args, **kwargs):
+    """
+    mode: string
+      - "raw" (speed: fastest, size: small, output: ugly, no dash,
+               no thickness)
+      - "agg" (speed: slower, size: medium, output: perfect, no dash)
+    """
+    if mode == "raw":
+        return RawSegmentCollection(*args, **kwargs)
+    return AggSegmentCollection(*args, **kwargs)

vispy/visuals/collections/triangle_collection.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+
+from . raw_triangle_collection import RawTriangleCollection
+
+
+def TriangleCollection(mode="raw", *args, **kwargs):
+    """
+    mode: string
+      - "raw"  (speed: fastest, size: small,   output: ugly)
+      - "agg"  (speed: fast,    size: small,   output: beautiful)
+    """
+    return RawTriangleCollection(*args, **kwargs)

vispy/visuals/collections/util.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2013, Nicolas P. Rougier. All rights reserved.
+# Distributed under the terms of the new BSD License.
+# -----------------------------------------------------------------------------
+
+import numpy as np
+from functools import reduce
+from operator import mul
+
+
+def dtype_reduce(dtype, level=0, depth=0):
+    """Try to reduce dtype up to a given level when it is possible.
+
+    Examples
+    --------
+    >>> dtype =  [ ('vertex',  [('x', 'f4'), ('y', 'f4'), ('z', 'f4')]),
+    ...            ('normal',  [('x', 'f4'), ('y', 'f4'), ('z', 'f4')]),
+    ...            ('color',   [('r', 'f4'), ('g', 'f4'), ('b', 'f4'),
+    ...                         ('a', 'f4')])]
+
+    level 0 result::
+
+        ['color,vertex,normal,', 10, 'float32']
+
+    level 1 result::
+
+        [['color', 4, 'float32']
+         ['normal', 3, 'float32']
+         ['vertex', 3, 'float32']]
+
+    """
+    dtype = np.dtype(dtype)
+    fields = dtype.fields
+
+    # No fields
+    if fields is None:
+        if len(dtype.shape):
+            count = reduce(mul, dtype.shape)
+        else:
+            count = 1
+        # size = dtype.itemsize / count
+        if dtype.subdtype:
+            name = str(dtype.subdtype[0])
+        else:
+            name = str(dtype)
+        return ['', count, name]
+    else:
+        items = []
+        name = ''
+        # Get reduced fields
+        for key, value in fields.items():
+            dtype_list = dtype_reduce(value[0], level, depth + 1)
+            if isinstance(dtype_list[0], str):
+                items.append([key, dtype_list[1], dtype_list[2]])
+            else:
+                items.append(dtype_list)
+            name += key + ','
+
+        # Check if we can reduce item list
+        ctype = None
+        count = 0
+        for i, item in enumerate(items):
+            # One item is a list, we cannot reduce
+            if not isinstance(item[0], str):
+                return items
+            else:
+                if i == 0:
+                    ctype = item[2]
+                    count += item[1]
+                else:
+                    if item[2] != ctype:
+                        return items
+                    count += item[1]
+        if depth >= level:
+            return [name, count, ctype]
+        else:
+            return items
+
+
+def fetchcode(utype, prefix=""):
+    """Generate the GLSL code needed to retrieve fake uniform values from a texture.
+
+    Parameters
+    ----------
+    uniforms : sampler2D
+        Texture to fetch uniforms from
+    uniforms_shape: vec3
+        Size of texture (width,height,count) where count is the number of float
+        to be fetched.
+    collection_index: float
+        Attribute giving the index of the uniforms to be fetched. This index
+        relates to the index in the uniform array from python side.
+
+    """
+    utype = np.dtype(utype)
+    _utype = dtype_reduce(utype, level=1)
+
+    header = """
+uniform   sampler2D uniforms;
+uniform   vec3      uniforms_shape;
+attribute float     collection_index;
+
+"""
+
+    # Header generation (easy)
+    types = {1: 'float', 2: 'vec2 ', 3: 'vec3 ',
+             4: 'vec4 ', 9: 'mat3 ', 16: 'mat4 '}
+    for name, count, _ in _utype:
+        if name != '__unused__':
+            header += "varying %s %s%s;\n" % (types[count], prefix, name)
+
+    # Body generation (not so easy)
+    body = """\nvoid fetch_uniforms() {
+    float rows   = uniforms_shape.x;
+    float cols   = uniforms_shape.y;
+    float count  = uniforms_shape.z;
+    float index  = collection_index;
+    int index_x  = int(mod(index, (floor(cols/(count/4.0))))) * int(count/4.0);
+    int index_y  = int(floor(index / (floor(cols/(count/4.0)))));
+    float size_x = cols - 1.0;
+    float size_y = rows - 1.0;
+    float ty     = 0.0;
+    if (size_y > 0.0)
+        ty = float(index_y)/size_y;
+    int i = index_x;
+    vec4 _uniform;\n"""
+
+    _utype = dict([(name, count) for name, count, _ in _utype])
+    store = 0
+    # Be very careful with utype name order (_utype.keys is wrong)
+    for name in utype.names:
+        if name == '__unused__':
+            continue
+        count, shift = _utype[name], 0
+        size = count
+        while count:
+            if store == 0:
+                body += "\n    _uniform = texture2D(uniforms, vec2(float(i++)/size_x,ty));\n"  # noqa
+                store = 4
+            if store == 4:
+                a = "xyzw"
+            elif store == 3:
+                a = "yzw"
+            elif store == 2:
+                a = "zw"
+            elif store == 1:
+                a = "w"
+            if shift == 0:
+                b = "xyzw"
+            elif shift == 1:
+                b = "yzw"
+            elif shift == 2:
+                b = "zw"
+            elif shift == 3:
+                b = "w"
+            i = min(min(len(b), count), len(a))
+            if size > 1:
+                body += "    %s%s.%s = _uniform.%s;\n" % (prefix, name, b[:i], a[:i])  # noqa
+            else:
+                body += "    %s%s = _uniform.%s;\n" % (prefix, name, a[:i])
+            count -= i
+            shift += i
+            store -= i
+
+    body += """}\n\n"""
+    return header + body