vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/glsl/__init__.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+# -----------------------------------------------------------------------------
+# Copyright (c) 2014, Nicolas P. Rougier
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+# -----------------------------------------------------------------------------
+import os
+import os.path as op
+
+from .. import config
+
+
+def find(name):
+    """Locate a filename into the shader library."""
+    if op.exists(name):
+        return name
+
+    path = op.dirname(__file__) or '.'
+
+    paths = [path] + config['include_path']
+
+    for path in paths:
+        filename = op.abspath(op.join(path, name))
+        if op.exists(filename):
+            return filename
+
+        for d in os.listdir(path):
+            fullpath = op.abspath(op.join(path, d))
+            if op.isdir(fullpath):
+                filename = op.abspath(op.join(fullpath, name))
+                if op.exists(filename):
+                    return filename
+
+    return None
+
+
+def get(name):
+    """Retrieve code from the given filename."""
+    filename = find(name)
+    if filename is None:
+        raise RuntimeError('Could not find %s' % name)
+    with open(filename) as fid:
+        return fid.read()

vispy/glsl/antialias/antialias.glsl

@@ -0,0 +1,7 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/stroke.glsl"
+#include "antialias/filled.glsl"
+#include "antialias/outline.glsl"

vispy/glsl/antialias/cap-butt.glsl

@@ -0,0 +1,31 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/stroke.glsl"
+
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for a line cap.
+   Type: butt
+
+   Parameters:
+   -----------
+
+
+   dx,dy    : signed distances to cap point (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+vec4 cap_butt(float dx, float dy, float linewidth, float antialias, vec4 color)
+{
+    float t = linewidth/2.0 - antialias;
+    float d = max(abs(dx)+t, abs(dy));
+    return stroke(d, linewidth, antialias, color);
+}

vispy/glsl/antialias/cap-round.glsl

@@ -0,0 +1,29 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/stroke.glsl"
+
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for a line cap.
+   Type: round
+
+   Parameters:
+   -----------
+
+   dx,dy    : signed distances to cap point (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+vec4 cap_round(float dx, float dy, float linewidth, float antialias, vec4 color)
+{
+    float d = lenght(vec2(dx,dy));
+    return stroke(d, linewidth, antialias, color);
+}

vispy/glsl/antialias/cap-square.glsl

@@ -0,0 +1,30 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/stroke.glsl"
+
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for a line cap.
+   Type: square
+
+   Parameters:
+   -----------
+
+   dx,dy    : signed distances to cap point (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+vec4 cap_square(float dx, float dy, float linewidth, float antialias, vec4 color)
+{
+    float t = linewidth/2.0 - antialias;
+    float d = max(abs(dx),abs(dy));
+    return stroke(d, linewidth, antialias, color);
+}

vispy/glsl/antialias/cap-triangle-in.glsl

@@ -0,0 +1,30 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/stroke.glsl"
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for a line cap.
+   Type: triangle in
+
+   Parameters:
+   -----------
+
+   type     : Type of cap
+   dx,dy    : signed distances to cap point (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+vec4 cap_triangle_in(float dx, float dy, float linewidth, float antialias, vec4 color)
+{
+    float t = linewidth/2.0 - antialias;
+    float d = (abs(dx)+abs(dy));
+    return stroke(d, linewidth, antialias, color);
+}

vispy/glsl/antialias/cap-triangle-out.glsl

@@ -0,0 +1,30 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/stroke.glsl"
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for a line cap.
+   Type: triangle out
+
+   Parameters:
+   -----------
+
+   dx,dy    : signed distances to cap point (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+vec4 cap_triangle_out(float dx, float dy, float linewidth, float antialias, vec4 color)
+{
+    float t = linewidth/2.0 - antialias;
+    float d = max(abs(dy),(t+abs(dx)-abs(dy)));
+
+    return stroke(d, linewidth, antialias, color);
+}

vispy/glsl/antialias/cap.glsl

@@ -0,0 +1,67 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/stroke.glsl"
+
+// Cap types
+// ----------------------------
+const int CAP_NONE         = 0;
+const int CAP_ROUND        = 1;
+const int CAP_TRIANGLE_IN  = 2;
+const int CAP_TRIANGLE_OUT = 3;
+const int CAP_SQUARE       = 4;
+const int CAP_BUTT         = 5;
+
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for a line cap.
+   Require the stroke function.
+
+   Parameters:
+   -----------
+
+   type     : Type of cap
+   dx,dy    : signed distances to cap point (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+vec4 cap(int type, float dx, float dy, float linewidth, float antialias, vec4 color)
+{
+    float d = 0.0;
+    dx = abs(dx);
+    dy = abs(dy);
+    float t = linewidth/2.0 - antialias;
+
+    // Round
+    if (type == CAP_ROUND)
+        d = sqrt(dx*dx+dy*dy);
+
+    // Square
+    else if (type == CAP_SQUARE)
+        d = max(dx,dy);
+
+    // Butt
+    else if (type == CAP_BUTT)
+        d = max(dx+t,dy);
+
+    // Triangle in
+    else if (type == CAP_TRIANGLE_IN)
+        d = (dx+abs(dy));
+
+    // Triangle out
+    else if (type == CAP_TRIANGLE_OUT)
+        d = max(abs(dy),(t+dx-abs(dy)));
+
+    // None
+    else
+        discard;
+
+    return stroke(d, linewidth, antialias, color);
+}

vispy/glsl/antialias/caps.glsl

@@ -0,0 +1,67 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "antialias/stroke.glsl"
+
+// Cap types
+// ----------------------------
+const int CAP_NONE         = 0;
+const int CAP_ROUND        = 1;
+const int CAP_TRIANGLE_IN  = 2;
+const int CAP_TRIANGLE_OUT = 3;
+const int CAP_SQUARE       = 4;
+const int CAP_BUTT         = 5;
+
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for a line cap.
+   Require the stroke function.
+
+   Parameters:
+   -----------
+
+   type     : Type of cap
+   dx,dy    : signed distances to cap point (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+vec4 cap(int type, float dx, float dy, float linewidth, float antialias, vec4 color)
+{
+    float d = 0.0;
+    dx = abs(dx);
+    dy = abs(dy);
+    float t = linewidth/2.0 - antialias;
+
+    // Round
+    if (type == CAP_ROUND)
+        d = sqrt(dx*dx+dy*dy);
+
+    // Square
+    else if (type == CAP_SQUARE)
+        d = max(dx,dy);
+
+    // Butt
+    else if (type == CAP_BUTT)
+        d = max(dx+t,dy);
+
+    // Triangle in
+    else if (type == CAP_TRIANGLE_IN)
+        d = (dx+abs(dy));
+
+    // Triangle out
+    else if (type == CAP_TRIANGLE_OUT)
+        d = max(abs(dy),(t+dx-abs(dy)));
+
+    // None
+    else
+        discard;
+
+    return stroke(d, linewidth, antialias, color);
+}

vispy/glsl/antialias/filled.glsl

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This file contains code for filling a shape with anti-alias.
+ */
+
+/**
+ * Compute antialiased fragment color for a filled shape.
+ *
+ * Parameters:
+ * -----------
+ *
+ * distance
+ *     Signed distance to border (in pixels)
+ * linewidth
+ *     Stroke line width (in pixels)
+ * antialias
+ *     Stroke antialiased area (in pixels)
+ * bg_color
+ *     Fill color
+ *
+ * Return:
+ * -------
+ * Fragment color (vec4)
+ */
+vec4 filled(float distance, float linewidth, float antialias, vec4 bg_color)
+{
+    vec4 frag_color;
+    float t = linewidth/2.0 - antialias;
+    float signed_distance = distance;
+    float border_distance = abs(signed_distance) - t;
+    float alpha = border_distance/antialias;
+    alpha = exp(-alpha*alpha);
+
+    if( border_distance < 0.0 ) {
+        frag_color = bg_color;
+    } else if( signed_distance < 0.0 ) {
+        frag_color = bg_color;
+    } else {
+        frag_color = vec4(bg_color.rgb, alpha * bg_color.a);
+    }
+
+    return frag_color;
+}
+
+vec4 filled(float distance, float linewidth, float antialias, vec4 fg_color, vec4 bg_color)
+{
+    return filled(distance, linewidth, antialias, fg_color);
+}

vispy/glsl/antialias/outline.glsl

@@ -0,0 +1,40 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for an outlined shape.
+
+   Parameters:
+   -----------
+
+   distance : signed distance to border (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+   fill:      Fill color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+
+vec4 outline(float distance, float linewidth, float antialias, vec4 fg_color, vec4 bg_color)
+{
+    vec4 frag_color;
+    float t = linewidth/2.0 - antialias;
+    float signed_distance = distance;
+    float border_distance = abs(signed_distance) - t;
+    float alpha = border_distance/antialias;
+    alpha = exp(-alpha*alpha);
+
+    if( border_distance < 0.0 )
+        frag_color = fg_color;
+    else if( signed_distance < 0.0 )
+        frag_color = mix(bg_color, fg_color, sqrt(alpha));
+    else
+        frag_color = vec4(fg_color.rgb, fg_color.a * alpha);
+    return frag_color;
+}

vispy/glsl/antialias/stroke.glsl

@@ -0,0 +1,43 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+   Compute antialiased fragment color for a stroke line.
+
+   Parameters:
+   -----------
+
+   distance : signed distance to border (in pixels)
+   linewidth: Stroke line width (in pixels)
+   antialias: Stroke antialiased area (in pixels)
+   stroke:    Stroke color
+
+   Return:
+   -------
+   Fragment color (vec4)
+
+   --------------------------------------------------------- */
+
+vec4 stroke(float distance, float linewidth, float antialias, vec4 fg_color)
+{
+    vec4 frag_color;
+    float t = linewidth/2.0 - antialias;
+    float signed_distance = distance;
+    float border_distance = abs(signed_distance) - t;
+    float alpha = border_distance/antialias;
+    alpha = exp(-alpha*alpha);
+
+    if( border_distance < 0.0 )
+        frag_color = fg_color;
+    else
+        frag_color = vec4(fg_color.rgb, fg_color.a * alpha);
+
+    return frag_color;
+}
+
+vec4 stroke(float distance, float linewidth, float antialias, vec4 fg_color, vec4 bg_color)
+{
+    return stroke(distance, linewidth, antialias, fg_color);
+}

vispy/glsl/arrowheads/angle.glsl

@@ -0,0 +1,99 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This file contains the shader code for drawing "angle" arrow heads, which
+ * are drawn as two lines moving away from the arrow tip under a certain
+ * angle.
+ */
+
+#include "arrowheads/util.glsl"
+
+/**
+ * Computes the signed distance to an angle arrow. This is a helper function,
+ * and in general you'll use arrow_angle_30, arrow_angle_60 or arrow_angle_90.
+ *
+ * Parameters:
+ * -----------
+ * texcoord 
+ *     Point to compute distance to
+ * size 
+ *     Size of the arrow head in pixels
+ * height
+ *     Height of the head (pixel)
+ * 
+ * See also
+ * --------
+ * arrow_angle_30, arrow_angle_60, arrow_angle_90
+ *
+ * Return:
+ * -------
+ * Signed distance to the arrow
+ */
+float arrow_angle(vec2 texcoord, float size, 
+                  float linewidth, float antialias, float height)
+{
+    float d;
+    vec2 start = -vec2(size/2.0, 0.0);
+    vec2 end   = +vec2(size/2.0, 0.0);
+
+    vec2 p1 = start + size*vec2(0.0, +height);
+    vec2 p2 = start + size*vec2(0.0, -height);
+
+    // Arrow tip (beyond segment end)
+    if( texcoord.x > size/2.0) {
+        // Head : 2 segments
+        float d1 = line_distance(texcoord, end, p1);
+        float d2 = line_distance(texcoord, p2, end);
+        // Body : 1 segment
+        float d3 = end.x - texcoord.x;
+        d = max(max(d1,d2), d3);
+    } else {
+        // Head : 2 segments
+        float d1 = segment_distance(texcoord, p1, end);
+        float d2 = segment_distance(texcoord, p2, end);
+        // Body : 1 segment
+        float d3 = segment_distance(texcoord, vec2(0.0, 0.0), end);
+        d = min(min(d1,d2), d3);
+    }
+    return d;
+}
+
+/**
+ * Returns the distance to an arrow with tip corner of 30 degrees
+ *
+ * See also
+ * --------
+ * arro_angle, arrow_angle_60, arrow_angle_90
+ */
+float arrow_angle_30(vec2 texcoord, float size,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, size, linewidth, antialias, 0.25);
+}
+
+/**
+ * Returns the distance to an arrow with tip corner of 60 degrees
+ *
+ * See also
+ * --------
+ * arro_angle, arrow_angle_30, arrow_angle_90
+ */
+float arrow_angle_60(vec2 texcoord, float size,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, size, linewidth, antialias, 0.5);
+}
+
+/**
+ * Returns the distance to an arrow with tip corner of 90 degrees
+ *
+ * See also
+ * --------
+ * arro_angle, arrow_angle_30, arrow_angle_60
+ */
+float arrow_angle_90(vec2 texcoord, float size,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, size, linewidth, antialias, 1.0);
+}

vispy/glsl/arrowheads/arrowheads.frag

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This file contains the fragment shader template for arrow heads.
+ * 
+ * Variables
+ * ---------
+ *
+ * $arrow_type
+ *     The type of arrow head. Examples incude: curved, stealth, triangle_30
+ *     and more.
+ * $fill_type
+ *     How to fill the arrow head. Possible values: "filled", "outline" or
+ *     "stroke".
+ *
+ * Varyings
+ * --------
+ * v_size
+ *     The arrow head size in pixels
+ * v_point_size
+ *     The actual size of the point used for drawing. This is larger than the
+ *     given arrow head size to make sure rotating goes well, and allows some
+ *     space for anti-aliasing.
+ * v_color
+ *     The color for the arrow head
+ * v_orientation
+ *     A direction vector for the orientation of the arrow head
+ * v_antialias
+ *     Anti-alias width
+ * v_linewidth
+ *     Width for the stroke or outline of the shape.
+ */
+#version 120
+#include "math/constants.glsl"
+#include "arrowheads/arrowheads.glsl"
+#include "antialias/antialias.glsl"
+
+// Varyings
+// ------------------------------------
+varying float v_size;
+varying float v_point_size;
+varying vec4  v_color;
+varying vec3  v_orientation;
+varying float v_antialias;
+varying float v_linewidth;
+
+void main()
+{
+    // 1. Move the origin to the center of the point
+    // 2. Rotate the canvas for drawing the arrow
+    // 3. Scale the coordinates with v_point_size
+    vec2 P = gl_PointCoord.xy - vec2(0.5, 0.5);
+    P = vec2(v_orientation.x*P.x - v_orientation.y*P.y,
+             v_orientation.y*P.x + v_orientation.x*P.y) * v_point_size;
+
+    float distance = arrow_$arrow_type(P, v_size, v_linewidth, v_antialias);
+    gl_FragColor = $fill_type(distance, v_linewidth, v_antialias, v_color,
+                              v_color);
+}

vispy/glsl/arrowheads/arrowheads.glsl

@@ -0,0 +1,12 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+#include "arrowheads/util.glsl"
+
+#include "arrowheads/curved.glsl"
+#include "arrowheads/stealth.glsl"
+#include "arrowheads/triangle.glsl"
+#include "arrowheads/angle.glsl"
+#include "arrowheads/inhibitor.glsl"