vispy 0.15.0__cp313-cp313-win_amd64.whl

vispy/visuals/windbarb.py

@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+"""Windbarb Visual and shader definitions."""
+
+import numpy as np
+
+from vispy.color import ColorArray
+from vispy.gloo import VertexBuffer
+from vispy.visuals.shaders import Variable
+from vispy.visuals.visual import Visual
+
+_VERTEX_SHADER = """
+uniform float u_antialias;
+uniform float u_px_scale;
+uniform float u_scale;
+
+attribute vec3  a_position;
+attribute vec2  a_wind;
+attribute vec4  a_fg_color;
+attribute vec4  a_bg_color;
+attribute float a_edgewidth;
+attribute float a_size;
+attribute float a_trig;
+
+varying vec4 v_fg_color;
+varying vec4 v_bg_color;
+varying vec2 v_wind;
+varying float v_trig;
+varying float v_edgewidth;
+varying float v_antialias;
+
+void main (void) {
+    $v_size = a_size * u_px_scale * u_scale;
+    v_edgewidth = a_edgewidth * float(u_px_scale);
+    v_wind = a_wind.xy;
+    v_trig = a_trig;
+    v_antialias = u_antialias;
+    v_fg_color  = a_fg_color;
+    v_bg_color  = a_bg_color;
+    gl_Position = $transform(vec4(a_position,1.0));
+    float edgewidth = max(v_edgewidth, 1.0);
+    gl_PointSize = ($v_size) + 4.*(edgewidth + 1.5*v_antialias);
+}
+"""
+
+_FRAGMENT_SHADER = """
+#include "math/constants.glsl"
+#include "math/signed-segment-distance.glsl"
+#include "antialias/antialias.glsl"
+varying vec4 v_fg_color;
+varying vec4 v_bg_color;
+varying vec2 v_wind;
+varying float v_trig;
+varying float v_edgewidth;
+varying float v_antialias;
+
+// SDF-Triangle by @rougier
+// https://github.com/rougier/python-opengl/blob/master/code/chapter-06/SDF-triangle.py
+float sdf_triangle(vec2 p, vec2 p0, vec2 p1, vec2 p2)
+{
+    vec2 e0 = p1 - p0;
+    vec2 e1 = p2 - p1;
+    vec2 e2 = p0 - p2;
+    vec2 v0 = p - p0;
+    vec2 v1 = p - p1;
+    vec2 v2 = p - p2;
+    vec2 pq0 = v0 - e0*clamp( dot(v0,e0)/dot(e0,e0), 0.0, 1.0 );
+    vec2 pq1 = v1 - e1*clamp( dot(v1,e1)/dot(e1,e1), 0.0, 1.0 );
+    vec2 pq2 = v2 - e2*clamp( dot(v2,e2)/dot(e2,e2), 0.0, 1.0 );
+    float s = sign( e0.x*e2.y - e0.y*e2.x );
+    vec2 d = min( min( vec2( dot( pq0, pq0 ), s*(v0.x*e0.y-v0.y*e0.x) ),
+                     vec2( dot( pq1, pq1 ), s*(v1.x*e1.y-v1.y*e1.x) )),
+                     vec2( dot( pq2, pq2 ), s*(v2.x*e2.y-v2.y*e2.x) ));
+    return -sqrt(d.x)*sign(d.y);
+}
+
+void main()
+{
+    // Discard plotting marker body and edge if zero-size
+    if ($v_size <= 0.)
+        discard;
+
+    float edgewidth = max(v_edgewidth, 1.0);
+    float linewidth = max(v_edgewidth, 1.0);
+    float edgealphafactor = min(v_edgewidth, 1.0);
+
+    float size = $v_size + 4.*(edgewidth + 1.5*v_antialias);
+    // factor 6 for acute edge angles that need room as for star marker
+    
+    vec2 wind = v_wind;
+    
+    if (v_trig > 0.)
+    {
+        float u = wind.x * cos(radians(wind.y));
+        float v = wind.x * sin(radians(wind.y));
+        wind = vec2(u, v);
+    }
+    
+    // knots to m/s
+    wind *= 2.;
+    
+    // normalized distance
+    float dx = 0.5;
+    // normalized center point
+    vec2 O = vec2(dx);
+    // normalized x-component
+    vec2 X = normalize(wind) * dx / M_SQRT2 / 1.1 * vec2(1, -1);
+    // normalized y-component
+    // here the barb can be mirrored for southern earth * (vec2(1., -1.)
+    //vec2 Y = X.yx * vec2(1., -1.); // southern hemisphere
+    vec2 Y = X.yx * vec2(-1., 1.); // northern hemisphere
+    // PointCoordinate
+    vec2 P = gl_PointCoord;
+
+    // calculate barb items
+    float speed = length(wind);
+    int flag = int(floor(speed / 50.));
+    speed -= float (50 * flag);
+    int longbarb = int(floor(speed / 10.));
+    speed -= float (longbarb * 10);
+    int shortbarb = int(floor(speed / 5.));
+    int calm = shortbarb + longbarb + flag;
+
+    // starting distance
+    float r;
+    // calm, plot circles
+    if (calm == 0)
+    {
+        r = abs(length(O-P)- dx * 0.2);
+        r = min(r, abs(length(O-P)- dx * 0.1));
+    }
+    else
+    {
+        // plot shaft
+        r = segment_distance(P, O, O-X);
+        float pos = 1.;
+
+        // plot flag(s)
+        while(flag >= 1)
+        {
+            r = min(r, sdf_triangle(P, O-X*pos, O-X*pos-X*.4-Y*.4, O-X*pos-X*.4));
+            flag -= 1;
+            pos -= 0.15;
+        }
+        // plot longbarb(s)
+        while(longbarb >= 1)
+        {
+            r = min(r, segment_distance(P, O-X*pos, O-X*pos-X*.4-Y*.4));
+            longbarb -= 1;
+            pos -= 0.15;
+        }
+        // plot shortbarb
+        while(shortbarb >= 1)
+        {
+            if (pos == 1.0)
+                pos -= 0.15;
+            r = min(r, segment_distance(P, O-X*pos, O-X*pos-X*.2-Y*.2));
+            shortbarb -= 1;
+            pos -= 0.15;
+        }
+    }
+
+    // apply correction for size
+    r *= size;
+
+    vec4 edgecolor = vec4(v_fg_color.rgb, edgealphafactor*v_fg_color.a);
+
+    if (r > 0.5 * v_edgewidth + v_antialias)
+    {
+        // out of the marker (beyond the outer edge of the edge
+        // including transition zone due to antialiasing)
+        discard;
+    }
+
+    gl_FragColor = filled(r, edgewidth, v_antialias, edgecolor);
+}
+"""
+
+
+class WindbarbVisual(Visual):
+    """Visual displaying windbarbs."""
+
+    _shaders = {
+        'vertex': _VERTEX_SHADER,
+        'fragment': _FRAGMENT_SHADER,
+    }
+
+    def __init__(self, **kwargs):
+        self._vbo = VertexBuffer()
+        self._v_size_var = Variable('varying float v_size')
+        self._marker_fun = None
+        self._data = None
+        Visual.__init__(self, vcode=self._shaders['vertex'], fcode=self._shaders['fragment'])
+        self.shared_program.vert['v_size'] = self._v_size_var
+        self.shared_program.frag['v_size'] = self._v_size_var
+        self.set_gl_state(depth_test=True, blend=True,
+                          blend_func=('src_alpha', 'one_minus_src_alpha'))
+        self._draw_mode = 'points'
+        if len(kwargs) > 0:
+            self.set_data(**kwargs)
+        self.freeze()
+
+    def set_data(self, pos=None, wind=None, trig=True, size=50.,
+                 antialias=1., edge_width=1., edge_color='black',
+                 face_color='white'):
+        """Set the data used to display this visual.
+
+        Parameters
+        ----------
+        pos : array
+            The array of locations to display each windbarb.
+        wind : array
+            The array of wind vector components to display each windbarb.
+            in m/s. For knots divide by two.
+        trig : bool
+            True - wind contains (mag, ang)
+            False - wind contains (u, v)
+            defaults to True
+        size : float or array
+            The windbarb size in px.
+        antialias : float
+            The antialiased area (in pixels).
+        edge_width : float | None
+            The width of the windbarb outline in pixels.
+        edge_color : Color | ColorArray
+            The color used to draw each symbol outline.
+        face_color : Color | ColorArray
+            The color used to draw each symbol interior.
+        """
+        assert (isinstance(pos, np.ndarray) and
+                pos.ndim == 2 and pos.shape[1] in (2, 3))
+        assert (isinstance(wind, np.ndarray) and
+                pos.ndim == 2 and pos.shape[1] == 2)
+        if edge_width < 0:
+            raise ValueError('edge_width cannot be negative')
+
+        # since the windbarb starts in the fragment center,
+        # we need to multiply by 2 for correct length
+        size *= 2
+
+        edge_color = ColorArray(edge_color).rgba
+        if len(edge_color) == 1:
+            edge_color = edge_color[0]
+
+        face_color = ColorArray(face_color).rgba
+        if len(face_color) == 1:
+            face_color = face_color[0]
+
+        n = len(pos)
+        data = np.zeros(n, dtype=[('a_position', np.float32, 3),
+                                  ('a_wind', np.float32, 2),
+                                  ('a_trig', np.float32, 0),
+                                  ('a_fg_color', np.float32, 4),
+                                  ('a_bg_color', np.float32, 4),
+                                  ('a_size', np.float32),
+                                  ('a_edgewidth', np.float32)])
+        data['a_fg_color'] = edge_color
+        data['a_bg_color'] = face_color
+        data['a_edgewidth'] = edge_width
+        data['a_position'][:, :pos.shape[1]] = pos
+        data['a_wind'][:, :wind.shape[1]] = wind
+        if trig:
+            data['a_trig'] = 1.
+        else:
+            data['a_trig'] = 0.
+        data['a_size'] = size
+        self.shared_program['u_antialias'] = antialias
+        self._data = data
+        self._vbo.set_data(data)
+        self.shared_program.bind(self._vbo)
+        self.update()
+
+    def _prepare_transforms(self, view):
+        xform = view.transforms.get_transform()
+        view.view_program.vert['transform'] = xform
+
+    def _prepare_draw(self, view):
+        view.view_program['u_px_scale'] = view.transforms.pixel_scale
+        view.view_program['u_scale'] = 1
+
+    def _compute_bounds(self, axis, view):
+        pos = self._data['a_position']
+        if pos is None:
+            return None
+        if pos.shape[1] > axis:
+            return (pos[:, axis].min(), pos[:, axis].max())
+        else:
+            return (0, 0)

vispy/visuals/xyz_axis.py

@@ -0,0 +1,34 @@
+
+import numpy as np
+
+from .line import LineVisual
+
+
+class XYZAxisVisual(LineVisual):
+    """
+    Simple 3D axis for indicating coordinate system orientation. Axes are
+    x=red, y=green, z=blue.
+    """
+
+    def __init__(self, **kwargs):
+        pos = np.array([[0, 0, 0],
+                        [1, 0, 0],
+                        [0, 0, 0],
+                        [0, 1, 0],
+                        [0, 0, 0],
+                        [0, 0, 1]])
+        color = np.array([[1, 0, 0, 1],
+                          [1, 0, 0, 1],
+                          [0, 1, 0, 1],
+                          [0, 1, 0, 1],
+                          [0, 0, 1, 1],
+                          [0, 0, 1, 1]])
+        connect = 'segments'
+        method = 'gl'
+
+        kwargs.setdefault('pos', pos)
+        kwargs.setdefault('color', color)
+        kwargs.setdefault('connect', connect)
+        kwargs.setdefault('method', method)
+
+        LineVisual.__init__(self, **kwargs)

vispy-0.15.0.dist-info/METADATA

@@ -0,0 +1,243 @@
+Metadata-Version: 2.4
+Name: vispy
+Version: 0.15.0
+Summary: Interactive visualization in Python
+Home-page: http://vispy.org
+Download-URL: https://pypi.python.org/pypi/vispy
+Author: Vispy contributors
+Author-email: vispy@googlegroups.com
+License: BSD-3-Clause
+Keywords: visualization,OpenGl,ES,medical,imaging,3D,plotting,numpy,bigdata,ipython,jupyter,widgets
+Platform: any
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: IPython
+Provides: vispy
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: freetype-py
+Requires-Dist: hsluv
+Requires-Dist: kiwisolver
+Requires-Dist: packaging
+Provides-Extra: ipython-static
+Requires-Dist: ipython; extra == "ipython-static"
+Provides-Extra: pyglet
+Requires-Dist: pyglet>=1.2; extra == "pyglet"
+Provides-Extra: pyqt5
+Requires-Dist: pyqt5; extra == "pyqt5"
+Provides-Extra: pyqt6
+Requires-Dist: pyqt6; extra == "pyqt6"
+Provides-Extra: pyside
+Requires-Dist: PySide; extra == "pyside"
+Provides-Extra: pyside2
+Requires-Dist: PySide2; extra == "pyside2"
+Provides-Extra: pyside6
+Requires-Dist: PySide6; extra == "pyside6"
+Provides-Extra: glfw
+Requires-Dist: glfw; extra == "glfw"
+Provides-Extra: sdl2
+Requires-Dist: PySDL2; extra == "sdl2"
+Provides-Extra: wx
+Requires-Dist: wxPython; extra == "wx"
+Provides-Extra: tk
+Requires-Dist: pyopengltk; extra == "tk"
+Provides-Extra: doc
+Requires-Dist: pydata-sphinx-theme; extra == "doc"
+Requires-Dist: numpydoc; extra == "doc"
+Requires-Dist: sphinxcontrib-apidoc; extra == "doc"
+Requires-Dist: sphinx-gallery; extra == "doc"
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: pillow; extra == "doc"
+Requires-Dist: pytest; extra == "doc"
+Requires-Dist: pyopengl; extra == "doc"
+Provides-Extra: io
+Requires-Dist: meshio; extra == "io"
+Requires-Dist: Pillow; extra == "io"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-sugar; extra == "test"
+Requires-Dist: meshio; extra == "test"
+Requires-Dist: pillow; extra == "test"
+Requires-Dist: sphinx_gallery; extra == "test"
+Requires-Dist: imageio; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: download-url
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: platform
+Dynamic: provides
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+VisPy: interactive scientific visualization in Python
+-----------------------------------------------------
+
+Main website: http://vispy.org
+
+|Build Status| |Coverage Status| |Zenodo Link| |Contributor Covenant|
+
+----
+
+VisPy is a **high-performance interactive 2D/3D data visualization
+library**. VisPy leverages the computational power of modern **Graphics
+Processing Units (GPUs)** through the **OpenGL** library to display very
+large datasets. Applications of VisPy include:
+
+-  High-quality interactive scientific plots with millions of points.
+-  Direct visualization of real-time data.
+-  Fast interactive visualization of 3D models (meshes, volume
+   rendering).
+-  OpenGL visualization demos.
+-  Scientific GUIs with fast, scalable visualization widgets (`Qt <http://www.qt.io>`__ or
+   `IPython notebook <http://ipython.org/notebook.html>`__ with WebGL).
+
+Releases
+--------
+
+See `CHANGELOG.md <./CHANGELOG.md>`_.
+
+Announcements
+-------------
+
+See the `VisPy Website <https://vispy.org/news.html>`_.
+
+Using VisPy
+-----------
+
+VisPy is a young library under heavy development at this time. It
+targets two categories of users:
+
+1. **Users knowing OpenGL**, or willing to learn OpenGL, who want to
+   create beautiful and fast interactive 2D/3D visualizations in Python
+   as easily as possible.
+2. **Scientists without any knowledge of OpenGL**, who are seeking a
+   high-level, high-performance plotting toolkit.
+
+If you're in the first category, you can already start using VisPy.
+VisPy offers a Pythonic, NumPy-aware, user-friendly interface for OpenGL
+ES 2.0 called **gloo**. You can focus on writing your GLSL code instead
+of dealing with the complicated OpenGL API - VisPy takes care of that
+automatically for you.
+
+If you're in the second category, we're starting to build experimental
+high-level plotting interfaces. Notably, VisPy now ships a very basic
+and experimental OpenGL backend for matplotlib.
+
+
+Installation
+------------
+
+Please follow the detailed
+`installation instructions <http://vispy.org/installation.html>`_
+on the VisPy website.
+
+Structure of VisPy
+------------------
+
+Currently, the main subpackages are:
+
+-  **app**: integrates an event system and offers a unified interface on
+   top of many window backends (Qt4, wx, glfw, jupyter notebook,
+   and others). Relatively stable API.
+-  **gloo**: a Pythonic, object-oriented interface to OpenGL. Relatively
+   stable API.
+-  **scene**: this is the system underlying our upcoming high level
+   visualization interfaces. Under heavy development and still
+   experimental, it contains several modules.
+
+   -  **Visuals** are graphical abstractions representing 2D shapes, 3D
+      meshes, text, etc.
+   -  **Transforms** implement 2D/3D transformations implemented on both
+      CPU and GPU.
+   -  **Shaders** implements a shader composition system for plumbing
+      together snippets of GLSL code.
+   -  The **scene graph** tracks all objects within a transformation
+      graph.
+-  **plot**: high-level plotting interfaces.
+
+The API of all public interfaces are subject to change in the future,
+although **app** and **gloo** are *relatively* stable at this point.
+
+Code of Conduct
+---------------
+
+The VisPy community requires its members to abide by the
+`Code of Conduct <./CODE_OF_CONDUCT.md>`_. In this CoC you will find the
+expectations of members, the penalties for violating these expectations, and
+how violations can be reported to the members of the community in charge of
+enforcing this Code of Conduct.
+
+Governance
+----------
+
+The VisPy project maintainers make decisions about the project based on a
+simple consensus model. This is described in more detail on the
+`governance page <https://vispy.org/governance/GOVERNANCE.html>`_ of the vispy
+website as well as the
+`list of maintainers <https://vispy.org/governance/MAINTAINERS.html>`_.
+
+In addition to decisions about the VisPy project, there is also a steering
+committee for the overall VisPy organization. More information about this
+committee can also be found on the `steering committee page <https://vispy.org/org/STEERING-COMMITTEE.html>`_
+of the vispy website,
+along with the organization's `charter <https://vispy.org/org/CHARTER.html>`_ and
+other related documents (linked in the charter).
+
+Genesis
+-------
+
+VisPy began when four developers with their own visualization libraries
+decided to team up:
+`Luke Campagnola <http://luke.campagnola.me/>`__ with `PyQtGraph <http://www.pyqtgraph.org/>`__,
+`Almar Klein <http://www.almarklein.org/>`__ with `Visvis <https://github.com/almarklein/visvis>`__,
+`Cyrille Rossant <http://cyrille.rossant.net>`__ with `Galry <https://github.com/rossant/galry>`__,
+`Nicolas Rougier <http://www.loria.fr/~rougier/index.html>`__ with `Glumpy <https://github.com/rougier/Glumpy>`__.
+
+Now VisPy looks to build on the expertise of these developers and the
+broader open-source community to build a high-performance OpenGL library.
+
+----
+
+External links
+--------------
+
+-  `User mailing
+   list <https://groups.google.com/forum/#!forum/vispy>`__
+-  `Dev mailing
+   list <https://groups.google.com/forum/#!forum/vispy-dev>`__
+-  `Chat room <https://gitter.im/vispy/vispy>`__
+-  `Developer chat room <https://gitter.im/vispy/vispy-dev>`__
+-  `Wiki <http://github.com/vispy/vispy/wiki>`__
+-  `Gallery <http://vispy.org/gallery/index.html>`__
+-  `Documentation <http://vispy.readthedocs.org>`__
+
+.. |Build Status| image:: https://github.com/vispy/vispy/workflows/CI/badge.svg
+   :target: https://github.com/vispy/vispy/actions
+.. |Coverage Status| image:: https://img.shields.io/coveralls/vispy/vispy/main.svg
+   :target: https://coveralls.io/r/vispy/vispy?branch=main
+.. |Zenodo Link| image:: https://zenodo.org/badge/5822/vispy/vispy.svg
+   :target: http://dx.doi.org/10.5281/zenodo.17869
+.. |Contributor Covenant| image:: https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg
+   :target: CODE_OF_CONDUCT.md