vispy 0.14.0__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

vispy/visuals/collections/collection.py

@@ -0,0 +1,253 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+A collection is a container for several items having the same data
+structure (dtype). Each data type can be declared as local (it specific to a
+vertex), shared (it is shared among an item vertices) or global (it is shared
+by all vertices). It is based on the BaseCollection but offers a more intuitive
+interface.
+"""
+
+import numpy as np
+from ... import gloo
+from . util import fetchcode
+from . base_collection import BaseCollection
+from ..shaders import ModularProgram
+from ...util.event import EventEmitter
+
+
+class Collection(BaseCollection):
+    """
+    A collection is a container for several items having the same data
+    structure (dtype). Each data type can be declared as local (it is specific
+    to a vertex), shared (it is shared among item vertices) or global (it is
+    shared by all items). It is based on the BaseCollection but offers a more
+    intuitive interface.
+
+    Parameters
+    ----------
+    dtype: list
+        Data individual types as (name, dtype, scope, default)
+
+    itype: np.dtype or None
+        Indices data type
+
+    mode : GL_ENUM
+        GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP,
+        GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN
+
+    vertex: str or tuple of str
+       Vertex shader to use to draw this collection
+
+    fragment:  str or tuple of str
+       Fragment shader to use to draw this collection
+
+    kwargs: str
+        Scope can also be specified using keyword argument,
+        where parameter name must be one of the dtype.
+    """
+
+    _gtypes = {('float32', 1): "float",
+               ('float32', 2): "vec2",
+               ('float32', 3): "vec3",
+               ('float32', 4): "vec4",
+               ('int32', 1): "int",
+               ('int32', 2): "ivec2",
+               ('int32', 3): "ivec3",
+               ('int32', 4): "ivec4"}
+
+    def __init__(self, dtype, itype, mode, vertex, fragment, program=None, 
+                 **kwargs):
+        """
+        """
+
+        self._uniforms = {}
+        self._attributes = {}
+        self._varyings = {}
+        self._mode = mode
+        vtype = []
+        utype = []
+
+        self.update = EventEmitter(source=self, type='collection_update')
+
+        # Build vtype and utype according to parameters
+        declarations = {"uniforms": "",
+                        "attributes": "",
+                        "varyings": ""}
+        defaults = {}
+        for item in dtype:
+            name, (basetype, count), scope, default = item
+            basetype = np.dtype(basetype).name
+            if scope[0] == "!":
+                scope = scope[1:]
+            else:
+                scope = kwargs.pop(name, scope)
+            defaults[name] = default
+            gtype = Collection._gtypes[(basetype, count)]
+            if scope == "local":
+                # numpy dtypes with size 1 are ambiguous, only add size if it is greater than 1
+                vtype.append((name, basetype, count) if count != 1 else (name, basetype))
+                declarations[
+                    "attributes"] += "attribute %s %s;\n" % (gtype, name)
+            elif scope == "shared":
+                # numpy dtypes with size 1 are ambiguous, only add size if it is greater than 1
+                utype.append((name, basetype, count) if count != 1 else (name, basetype))
+                declarations["varyings"] += "varying %s %s;\n" % (gtype, name)
+            else:
+                declarations["uniforms"] += "uniform %s %s;\n" % (gtype, name)
+                self._uniforms[name] = None
+
+        if len(kwargs) > 0:
+            raise NameError("Invalid keyword argument(s): %s" % 
+                            list(kwargs.keys()))
+
+        vtype = np.dtype(vtype)
+        itype = np.dtype(itype) if itype else None
+        utype = np.dtype(utype) if utype else None
+
+        BaseCollection.__init__(self, vtype=vtype, utype=utype, itype=itype)
+        self._declarations = declarations
+        self._defaults = defaults
+
+        # Build program (once base collection is built)
+        saved = vertex
+        vertex = ""
+
+        if self.utype is not None:
+            vertex += fetchcode(self.utype) + vertex
+        else:
+            vertex += "void fetch_uniforms(void) { }\n" + vertex
+        vertex += self._declarations["uniforms"]
+        vertex += self._declarations["attributes"]
+        vertex += saved
+
+        self._vertex = vertex
+        self._fragment = fragment
+
+        if program is None:
+            program = ModularProgram(vertex, fragment)
+        else:
+            program.vert = vertex
+            program.frag = fragment
+        if hasattr(program, 'changed'):
+            program.changed.connect(self.update)
+        self._programs.append(program)
+
+        # Initialize uniforms
+        for name in self._uniforms.keys():
+            self._uniforms[name] = self._defaults.get(name)
+            program[name] = self._uniforms[name]
+
+    def view(self, transform, viewport=None):
+        """Return a view on the collection using provided transform"""
+        return CollectionView(self, transform, viewport)
+
+        # program = gloo.Program(self._vertex, self._fragment)
+        # if "transform" in program.hooks:
+        #     program["transform"] = transform
+        # if "viewport" in program.hooks:
+        #     if viewport is not None:
+        #         program["viewport"] = viewport
+        #     else:
+        #         program["viewport"] = Viewport()
+        # self._programs.append(program)
+        # program.bind(self._vertices_buffer)
+        # for name in self._uniforms.keys():
+        #     program[name] = self._uniforms[name]
+        # #if self._uniforms_list is not None:
+        # #    program["uniforms"] = self._uniforms_texture
+        # #    program["uniforms_shape"] = self._ushape
+
+        # # Piggy backing
+        # def draw():
+        #     if self._need_update:
+        #         self._update()
+        #         program.bind(self._vertices_buffer)
+        #         if self._uniforms_list is not None:
+        #             program["uniforms"] = self._uniforms_texture
+        #             program["uniforms_shape"] = self._ushape
+
+        #     if self._indices_list is not None:
+        #         Program.draw(program, self._mode, self._indices_buffer)
+        #     else:
+        #         Program.draw(program, self._mode)
+
+        # program.draw = draw
+        # return program
+
+    def __getitem__(self, key):
+
+        program = self._programs[0]
+        for name, (storage, _, _) in program._code_variables.items():
+            if name == key and storage == 'uniform':
+                return program[key]
+        return BaseCollection.__getitem__(self, key)
+
+    def __setitem__(self, key, value):
+        try:
+            BaseCollection.__setitem__(self, key, value)
+        except IndexError:
+            for program in self._programs:
+                program[key] = value
+
+    def draw(self, mode=None):
+        """Draw collection"""
+        if self._need_update:
+            self._update()
+
+        program = self._programs[0]
+
+        mode = mode or self._mode
+        if self._indices_list is not None:
+            program.draw(mode, self._indices_buffer)
+        else:
+            program.draw(mode)
+
+
+class CollectionView(object):
+
+    def __init__(self, collection, transform=None, viewport=None):
+
+        vertex = collection._vertex
+        fragment = collection._fragment
+        program = gloo.Program(vertex, fragment)
+
+#        if "transform" in program.hooks and transform is not None:
+#            program["transform"] = transform
+#        if "viewport" in program.hooks and viewport is not None:
+#            program["viewport"] = viewport
+
+        program.bind(collection._vertices_buffer)
+        for name in collection._uniforms.keys():
+            program[name] = collection._uniforms[name]
+
+        collection._programs.append(program)
+        self._program = program
+        self._collection = collection
+
+    def __getitem__(self, key):
+        return self._program[key]
+
+    def __setitem__(self, key, value):
+        self._program[key] = value
+
+    def draw(self):
+
+        program = self._program
+        collection = self._collection
+        mode = collection._mode
+
+        if collection._need_update:
+            collection._update()
+            # self._program.bind(self._vertices_buffer)
+            if collection._uniforms_list is not None:
+                program["uniforms"] = collection._uniforms_texture
+                program["uniforms_shape"] = collection._ushape
+
+        if collection._indices_list is not None:
+            program.draw(mode, collection._indices_buffer)
+        else:
+            program.draw(mode)

vispy/visuals/collections/path_collection.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+from . raw_path_collection import RawPathCollection
+from . agg_path_collection import AggPathCollection
+from . agg_fast_path_collection import AggFastPathCollection
+
+
+def PathCollection(mode="agg", *args, **kwargs):
+    """
+    mode: string
+      - "raw"   (speed: fastest, size: small, output: ugly, no dash,
+                 no thickness)
+      - "agg"   (speed: medium, size: medium output: nice, some flaws, no dash)
+      - "agg+"  (speed: slow, size: big, output: perfect, no dash)
+    """
+    if mode == "raw":
+        return RawPathCollection(*args, **kwargs)
+    elif mode == "agg+":
+        return AggPathCollection(*args, **kwargs)
+    return AggFastPathCollection(*args, **kwargs)

vispy/visuals/collections/point_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_point_collection import RawPointCollection
+from . agg_point_collection import AggPointCollection
+
+
+def PointCollection(mode="raw", *args, **kwargs):
+    """
+    mode: string
+      - "raw"  (speed: fastest, size: small,   output: ugly)
+      - "agg"  (speed: fast,    size: small,   output: beautiful)
+    """
+    if mode == "raw":
+        return RawPointCollection(*args, **kwargs)
+    return AggPointCollection(*args, **kwargs)

vispy/visuals/collections/polygon_collection.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+""" """
+from . raw_polygon_collection import RawPolygonCollection
+# from . agg_polygon_collection import AggPolygonCollection
+# from . agg_fast_polygon_collection import AggPolygonCollection
+
+
+def PolygonCollection(mode="raw", *args, **kwargs):
+    """
+    mode: string
+      - "raw"   (speed: fastest, size: small, output: ugly, no dash, no
+                 thickness)
+      - "agg"   (speed: medium,  size: medium output: nice, some flaws, no
+                 dash)
+      - "agg+"  (speed: slow, size: big, output: perfect, no dash)
+    """
+    # if mode == "raw":
+    return RawPolygonCollection(*args, **kwargs)
+    # elif mode == "agg":
+    #    return AggFastPolygonCollection(*args, **kwargs)
+    # return AggPolygonCollection(*args, **kwargs)

vispy/visuals/collections/raw_path_collection.py

@@ -0,0 +1,119 @@
+# -*- 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 RawPathCollection(Collection):
+
+    """
+    """
+
+    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 : Transform instance
+            Used to define the transform(vec4) 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)),
+                      ('id', (np.float32, 1), '!local', 0),
+                      ('color', (np.float32, 4), 'local', (0, 0, 0, 1)),
+                      ("linewidth", (np.float32, 1), 'global', 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-path.vert')
+        if transform is None:
+            transform = NullTransform()
+        self.transform = transform        
+        if fragment is None:
+            fragment = glsl.get('collections/raw-path.frag')
+
+        vertex = transform + vertex
+        Collection.__init__(self, dtype=dtype, itype=None, mode='line_strip',
+                            vertex=vertex, fragment=fragment, **kwargs)
+        self._programs[0].vert['transform'] = self.transform
+
+    def append(self, P, closed=False, itemsize=None, **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
+        ----------
+        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 len(P)
+        itemcount = len(P) / itemsize
+        P = P.reshape(itemcount, itemsize, 3)
+        if closed:
+            V = np.empty((itemcount, itemsize + 3), dtype=self.vtype)
+            # Apply default values on vertices
+            for name in self.vtype.names:
+                if name not in ['collection_index', 'position']:
+                    V[name][1:-2] = kwargs.get(name, self._defaults[name])
+            V["position"][:, 1:-2] = P
+            V["position"][:, -2] = V["position"][:, 1]
+        else:
+            V = np.empty((itemcount, itemsize + 2), dtype=self.vtype)
+            # Apply default values on vertices
+            for name in self.vtype.names:
+                if name not in ['collection_index', 'position']:
+                    V[name][1:-1] = kwargs.get(name, self._defaults[name])
+            V["position"][:, 1:-1] = P
+        V["id"] = 1
+        V[:, 0] = V[:, 1]
+        V[:, -1] = V[:, -2]
+        V["id"][:, 0] = 0
+        V["id"][:, -1] = 0
+
+        # 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 + 2 + closed)

vispy/visuals/collections/raw_point_collection.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""
+Raw Point Collection
+
+This collection provides very fast points. Output quality is ugly so it must be
+used at small size only (2/3 pixels). You've been warned.
+"""
+
+from __future__ import division
+
+import numpy as np
+from ... import glsl
+from . collection import Collection
+from ..transforms import NullTransform
+
+
+class RawPointCollection(Collection):
+    """
+    Raw Point Collection
+
+    This collection provides very fast points. Output quality is ugly so it
+    must be used at small size only (2/3 pixels). You've been warned.
+    """
+
+    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 : Transform instance
+            Used to define the transform(vec4) 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)),
+                      ('size', (np.float32, 1), "global", 3.0),
+                      ('color', (np.float32, 4), "global", (0, 0, 0, 1))]
+
+        dtype = base_dtype
+        if user_dtype:
+            dtype.extend(user_dtype)
+
+        if vertex is None:
+            vertex = glsl.get("collections/raw-point.vert")
+        if transform is None:
+            transform = NullTransform()
+        self.transform = transform        
+        if fragment is None:
+            fragment = glsl.get("collections/raw-point.frag")
+
+        Collection.__init__(self, dtype=dtype, itype=None, mode="points",
+                            vertex=vertex, fragment=fragment, **kwargs)
+
+        # Set hooks if necessary
+        program = self._programs[0]
+        program.vert['transform'] = self.transform
+
+    def append(self, P, itemsize=None, **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
+        ----------
+        P : np.array
+            Vertices positions of the points(s) to be added
+
+        itemsize: int or None
+            Size of an individual path
+
+        color : list, array or 4-tuple
+           Path color
+        """
+        itemsize = itemsize or 1
+        itemcount = len(P) // itemsize
+
+        V = np.empty(len(P), dtype=self.vtype)
+
+        # Apply default values on vertices
+        for name in self.vtype.names:
+            if name not in ['position', "collection_index"]:
+                V[name] = kwargs.get(name, self._defaults[name])
+        V["position"] = P
+
+        # 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_polygon_collection.py

@@ -0,0 +1,77 @@
+# -*- 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
+from ...geometry import triangulate
+
+
+class RawPolygonCollection(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,  # 16 for WebGL
+                            mode="triangles",
+                            vertex=vertex, fragment=fragment, **kwargs)
+
+        # Set hooks if necessary
+        program = self._programs[0]
+        program.vert['transform'] = self.transform
+
+    def append(self, points, **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
+
+        color : list, array or 4-tuple
+           Path color
+        """
+        vertices, indices = triangulate(points)
+        itemsize = len(vertices)
+        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"] = vertices
+
+        # 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)