vispy 0.14.0__cp311-cp311-macosx_11_0_arm64.whl

vispy/glsl/arrowheads/arrowheads.vert

@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This file contains the vertex shader template for arrow heads.
+ *
+ * Variables
+ * ---------
+ * $transform
+ *     Projection matrix of vertex to the screen
+ *
+ * Attributes
+ * ----------
+ * v1
+ *     The first vertex of the arrow body
+ * v2
+ *     The second vertex of the arrow body. This will also be the center
+ *     location of the arrow head. Using v1, we determine a direction vector
+ *     to automatically determine the orientation.
+ * size
+ *     Size of the arrow head in pixels
+ * color
+ *     The color of the arrow head
+ * v_linewidth
+ *     The width for the stroke or outline of the shape.
+ *
+ * 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.
+ */
+
+#include "math/constants.glsl"
+
+// Uniforms
+// ------------------------------------
+uniform float antialias;
+
+// Attributes
+// ------------------------------------
+attribute vec4  v1;
+attribute vec4  v2;
+attribute float size;
+attribute vec4  color;
+attribute float linewidth;
+
+// 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;
+
+// Main (hooked)
+// ------------------------------------
+void main (void)
+{
+    v_size        = size;
+    v_point_size  = M_SQRT2 * size + 2.0 * (linewidth + 2.0*antialias);
+    v_antialias   = antialias;
+    v_color       = color;
+    v_linewidth   = linewidth;
+
+    vec3 body = $transform(v2).xyz - $transform(v1).xyz;
+    v_orientation = (body / length(body));
+
+    gl_Position = $transform(v2);
+    gl_PointSize = v_point_size;
+}

vispy/glsl/arrowheads/curved.glsl

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This files contains the code for drawing curved arrow heads.
+ */
+
+#include "arrowheads/util.glsl"
+
+/**
+ * Computes the signed distance to an curved arrow
+ *
+ * Parameters:
+ * -----------
+ * texcoord 
+ *     Point to compute distance to
+ * size 
+ *     size of the arrow head in pixels
+ * linewidth
+ *     Width of the line
+ * antialias
+ *     Anti alias width
+ *
+ * Return:
+ * -------
+ * Signed distance to the arrow
+ *
+ */
+float arrow_curved(vec2 texcoord, float size, float linewidth, float antialias)
+{
+    vec2 start = -vec2(size/2.0, 0.0);
+    vec2 end   = +vec2(size/2.0, 0.0);
+    float height = 0.5;
+
+    vec2 p1 = start + size*vec2(0.0, -height);
+    vec2 p2 = start + size*vec2(0.0, +height);
+    vec2 p3 = end;
+
+    // Head : 3 circles
+    vec2 c1  = circle_from_2_points(p1, p3, 6.0*size).zw;
+    float d1 = length(texcoord - c1) - 6.0*size;
+    vec2 c2  = circle_from_2_points(p2, p3, 6.0*size).xy;
+    float d2 = length(texcoord - c2) - 6.0*size;
+    vec2 c3  = circle_from_2_points(p1, p2, 3.0*size).xy;
+    float d3 = length(texcoord - c3) - 3.0*size;
+
+    return -min(d3, min(d1,d2));
+}

vispy/glsl/arrowheads/inhibitor.glsl

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This files contains the code for drawing curved arrow heads.
+ */
+
+#include "arrowheads/util.glsl"
+
+
+float arrow_inhibitor_round(vec2 texcoord, float size,
+                            float linewidth, float antialias)
+{
+    vec2 c = vec2(size/2.0, 0.0);
+    float radius = size/2.0;
+    float radius_inner = radius - linewidth/6.0;
+
+    float d1 = length(texcoord - c) - radius;
+    float d2 = length(texcoord - c) - radius_inner;
+    float d3 = texcoord.x - (size/2.5);
+
+    return max(d3, max(d1, -d2));
+    //return max(d1, -d2);
+}
+    
+

vispy/glsl/arrowheads/stealth.glsl

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This file contains the code for drawing "stealth" type arrow heads.
+ */
+
+#include "arrowheads/util.glsl"
+
+
+/**
+ * Computes the signed distance to an stealth arrow
+ *
+ * Parameters:
+ * -----------
+ *
+ * texcoord 
+ *     Point to compute distance to
+ * size
+ *     Size of the arrow head in pixels
+ * linewidth
+ *     Width of the line
+ * antialias
+ *     Anti alias width
+ *
+ * Return:
+ * -------
+ * Signed distance to the arrow
+ */
+float arrow_stealth(vec2 texcoord, float size, 
+                    float linewidth, float antialias)
+{
+    vec2 start = -vec2(size/2.0, 0.0);
+    vec2 end   = +vec2(size/2.0, 0.0);
+    float height = 0.5;
+
+    // Head : 4 lines
+    float d1 = line_distance(texcoord, start + size*vec2(0.0, +height), end);
+    float d2 = line_distance(texcoord, start + size*vec2(0.0, +height),
+                             start + size*vec2(0.3, 0.0));
+    float d3 = line_distance(texcoord, start + size*vec2(0.0, -height), end);
+    float d4 = line_distance(texcoord, start + size*vec2(0.0, -height),
+                             start + size*vec2(0.25, 0.0));
+
+    return max( max(-d1, d3), - max(-d2,d4));
+}

vispy/glsl/arrowheads/triangle.glsl

@@ -0,0 +1,97 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This file contains the code for drawing complete triangles as arrow heads.
+ * this includes triangles with a top corner of 30, 60 and 90 degrees.
+ */
+
+#include "arrowheads/util.glsl"
+
+/**
+ * Computes the signed distance to a triangle arrow. This is a helper function,
+ * and in general you'll use arrow_triangle_30, arrow_triangle_60, or
+ * arrow_triangle_90.
+ *
+ * Parameters:
+ * -----------
+ *
+ * texcoord 
+ *     Point to compute distance to
+ * size
+ *     Size of the arrow head in pixels
+ * linewidth
+ *     Width of the line
+ * antialias
+ *     Anti alias width
+ * height
+ *     Height of the head (pixel)
+ * 
+ * See also
+ * --------
+ * arrow_triangle_30, arrow_triangle_60, arrow_triangle_90
+ *
+ * Return:
+ * -------
+ * Signed distance to the arrow
+ *
+ */
+float arrow_triangle(vec2 texcoord, float size, 
+                     float linewidth, float antialias, float height)
+{
+    vec2 start = -vec2(size/2.0, 0.0);
+    vec2 end   = +vec2(size/2.0, 0.0);
+
+    // Head : 3 lines
+    vec2 p1 = start + size*vec2(0.0, +height);
+    vec2 p2 = start + size*vec2(0.0, -height);
+
+    float d1 = line_distance(texcoord, end, p1);
+    float d2 = line_distance(texcoord, p2, end);
+    float d3 = start.x - texcoord.x;
+
+
+    return max(max(d1, d2), d3);
+}
+
+/**
+ * Returns the signed distance to an triangle arrow head with a tip corner
+ * of 30 degrees.
+ *
+ * See also
+ * --------
+ * arrow_triangle, arrow_triangle_60, arrow_triangle_90
+ */
+float arrow_triangle_30(vec2 texcoord, float size,
+                        float linewidth, float antialias)
+{
+    return arrow_triangle(texcoord, size, linewidth, antialias, 0.25);
+}
+
+/**
+ * Returns the signed distance to an triangle arrow head with a tip corner
+ * of 60 degrees.
+ *
+ * See also
+ * --------
+ * arrow_triangle, arrow_triangle_30, arrow_triangle_90
+ */
+float arrow_triangle_60(vec2 texcoord, float size,
+                        float linewidth, float antialias)
+{
+    return arrow_triangle(texcoord, size, linewidth, antialias, 0.5);
+}
+
+/**
+ * Returns the signed distance to an triangle arrow head with a tip corner
+ * of 90 degrees.
+ *
+ * See also
+ * --------
+ * arrow_triangle, arrow_triangle_30, arrow_triangle_60
+ */
+float arrow_triangle_90(vec2 texcoord, float size,
+                        float linewidth, float antialias)
+{
+    return arrow_triangle(texcoord, size, linewidth, antialias, 1.0);
+}

vispy/glsl/arrowheads/util.glsl

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Vispy Development Team
+ * Distributed under the (new) BSD License. See LICENSE.txt for more info.
+ *
+ * This is a convencience include file with includes some math helper
+ * functions.
+ */
+
+#include "math/signed-line-distance.glsl"
+#include "math/point-to-line-distance.glsl"
+#include "math/signed-segment-distance.glsl"
+#include "math/circle-through-2-points.glsl"
+#include "math/point-to-line-projection.glsl"

vispy/glsl/arrows/angle-30.glsl

@@ -0,0 +1,12 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "arrows/util.glsl"
+
+float arrow_angle_30(vec2 texcoord,
+                     float body, float head,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, body, head, 0.25, linewidth, antialias);
+}

vispy/glsl/arrows/angle-60.glsl

@@ -0,0 +1,12 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "arrows/util.glsl"
+
+float arrow_angle_60(vec2 texcoord,
+                     float body, float head,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, body, head, 0.5, linewidth, antialias);
+}

vispy/glsl/arrows/angle-90.glsl

@@ -0,0 +1,12 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "arrows/util.glsl"
+
+float arrow_angle_90(vec2 texcoord,
+                     float body, float head,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, body, head, 1.0, linewidth, antialias);
+}

vispy/glsl/arrows/arrow.frag

@@ -0,0 +1,39 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+// Hooks:
+//  <paint>  : "stroke", "filled" or "outline"
+//  <marker> : "steath", "curved",
+//             "angle_30", "angle_60", "angle_90",
+//             "triangle_30", "triangle_60", "triangle_90",
+// ----------------------------------------------------------------------------
+#version 120
+#include "math/constants.glsl"
+#include "arrows/arrows.glsl"
+#include "antialias/antialias.glsl"
+
+// Varyings
+// ------------------------------------
+varying float v_antialias;
+varying float v_linewidth;
+varying float v_size;
+varying float v_head;
+varying float v_texcoord;
+varying vec4  v_fg_color;
+varying vec4  v_bg_color;
+varying vec2  v_orientation;
+
+// Main (hooked)
+// ------------------------------------
+void main()
+{
+    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_size;
+    float point_size = M_SQRT2*v_size  + 2.0 * (v_linewidth + 1.5*v_antialias);
+    float body = v_size/M_SQRT2;
+
+    float distance = arrow_<arrow>(P, body, v_head*body, v_linewidth, v_antialias);
+    gl_FragColor = <paint>(distance, v_linewidth, v_antialias, v_fg_color, v_bg_color);
+}

vispy/glsl/arrows/arrow.vert

@@ -0,0 +1,49 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+// Hooks:
+//  <transform> : vec4 function(position, ...)
+//
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+// Uniforms
+// ------------------------------------
+uniform float antialias;
+
+// Attributes
+// ------------------------------------
+attribute vec2  position;
+attribute float size;
+attribute float head;
+attribute vec4  fg_color;
+attribute vec4  bg_color;
+attribute float orientation;
+attribute float linewidth;
+
+// Varyings
+// ------------------------------------
+varying float v_size;
+varying float v_head;
+varying vec4  v_fg_color;
+varying vec4  v_bg_color;
+varying vec2  v_orientation;
+varying float v_antialias;
+varying float v_linewidth;
+
+// Main (hooked)
+// ------------------------------------
+void main (void)
+{
+    v_size        = size;
+    v_head        = head;
+    v_linewidth   = linewidth;
+    v_antialias   = antialias;
+    v_fg_color    = fg_color;
+    v_bg_color    = bg_color;
+    v_orientation = vec2(cos(orientation), sin(orientation));
+
+    gl_Position = <transform>;
+    gl_PointSize = M_SQRT2 * size + 2.0 * (linewidth + 1.5*antialias);
+}

vispy/glsl/arrows/arrows.glsl

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

vispy/glsl/arrows/common.glsl

@@ -0,0 +1,187 @@
+/* -------------------------------------------------------------------------
+ * Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+ * Distributed under the (new) BSD License.
+ * -------------------------------------------------------------------------
+ */
+
+// Computes the signed distance from a line
+float line_distance(vec2 p, vec2 p1, vec2 p2) {
+    vec2 center = (p1 + p2) * 0.5;
+    float len = length(p2 - p1);
+    vec2 dir = (p2 - p1) / len;
+    vec2 rel_p = p - center;
+    return dot(rel_p, vec2(dir.y, -dir.x));
+}
+
+// Computes the signed distance from a line segment
+float segment_distance(vec2 p, vec2 p1, vec2 p2) {
+    vec2 center = (p1 + p2) * 0.5;
+    float len = length(p2 - p1);
+    vec2 dir = (p2 - p1) / len;
+    vec2 rel_p = p - center;
+    float dist1 = abs(dot(rel_p, vec2(dir.y, -dir.x)));
+    float dist2 = abs(dot(rel_p, dir)) - 0.5*len;
+    return max(dist1, dist2);
+}
+
+// Computes the center with given radius passing through p1 & p2
+vec4 circle_from_2_points(vec2 p1, vec2 p2, float radius)
+{
+    float q = length(p2-p1);
+    vec2 m = (p1+p2)/2.0;
+    vec2 d = vec2( sqrt(radius*radius - (q*q/4.0)) * (p1.y-p2.y)/q,
+                   sqrt(radius*radius - (q*q/4.0)) * (p2.x-p1.x)/q);
+    return  vec4(m+d, m-d);
+}
+
+float arrow_curved(vec2 texcoord,
+                   float body, float head,
+                   float linewidth, float antialias)
+{
+    float w = linewidth/2.0 + antialias;
+    vec2 start = -vec2(body/2.0, 0.0);
+    vec2 end   = +vec2(body/2.0, 0.0);
+    float height = 0.5;
+
+    vec2 p1 = end - head*vec2(+1.0,+height);
+    vec2 p2 = end - head*vec2(+1.0,-height);
+    vec2 p3 = end;
+
+    // Head : 3 circles
+    vec2 c1  = circle_from_2_points(p1, p3, 1.25*body).zw;
+    float d1 = length(texcoord - c1) - 1.25*body;
+    vec2 c2  = circle_from_2_points(p2, p3, 1.25*body).xy;
+    float d2 = length(texcoord - c2) - 1.25*body;
+    vec2 c3  = circle_from_2_points(p1, p2, max(body-head, 1.0*body)).xy;
+    float d3 = length(texcoord - c3) - max(body-head, 1.0*body);
+
+    // Body : 1 segment
+    float d4 = segment_distance(texcoord, start, end - vec2(linewidth,0.0));
+
+    // Outside (because of circles)
+    if( texcoord.y > +(2.0*head + antialias) )
+         return 1000.0;
+    if( texcoord.y < -(2.0*head + antialias) )
+         return 1000.0;
+    if( texcoord.x < -(body/2.0 + antialias) )
+         return 1000.0;
+    if( texcoord.x > c1.x ) //(body + antialias) )
+         return 1000.0;
+
+    return min( d4, -min(d3,min(d1,d2)));
+}
+
+float arrow_triangle(vec2 texcoord,
+                     float body, float head, float height,
+                     float linewidth, float antialias)
+{
+    float w = linewidth/2.0 + antialias;
+    vec2 start = -vec2(body/2.0, 0.0);
+    vec2 end   = +vec2(body/2.0, 0.0);
+
+    // Head : 3 lines
+    float d1 = line_distance(texcoord, end, end - head*vec2(+1.0,-height));
+    float d2 = line_distance(texcoord, end - head*vec2(+1.0,+height), end);
+    float d3 = texcoord.x - end.x + head;
+
+    // Body : 1 segment
+    float d4 = segment_distance(texcoord, start, end - vec2(linewidth,0.0));
+
+    float d = min(max(max(d1, d2), -d3), d4);
+    return d;
+}
+
+float arrow_triangle_90(vec2 texcoord,
+                        float body, float head,
+                        float linewidth, float antialias)
+{
+    return arrow_triangle(texcoord, body, head, 1.0, linewidth, antialias);
+}
+
+float arrow_triangle_60(vec2 texcoord,
+                        float body, float head,
+                        float linewidth, float antialias)
+{
+    return arrow_triangle(texcoord, body, head, 0.5, linewidth, antialias);
+}
+
+float arrow_triangle_30(vec2 texcoord,
+                        float body, float head,
+                        float linewidth, float antialias)
+{
+    return arrow_triangle(texcoord, body, head, 0.25, linewidth, antialias);
+}
+
+float arrow_angle(vec2 texcoord,
+                  float body, float head, float height,
+                  float linewidth, float antialias)
+{
+    float d;
+    float w = linewidth/2.0 + antialias;
+    vec2 start = -vec2(body/2.0, 0.0);
+    vec2 end   = +vec2(body/2.0, 0.0);
+
+    // Arrow tip (beyond segment end)
+    if( texcoord.x > body/2.0) {
+        // Head : 2 segments
+        float d1 = line_distance(texcoord, end, end - head*vec2(+1.0,-height));
+        float d2 = line_distance(texcoord, end - head*vec2(+1.0,+height), 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, end - head*vec2(+1.0,-height), end);
+        float d2 = segment_distance(texcoord, end - head*vec2(+1.0,+height), end);
+        // Body : 1 segment
+        float d3 = segment_distance(texcoord, start, end - vec2(linewidth,0.0));
+        d = min(min(d1,d2), d3);
+    }
+    return d;
+}
+
+float arrow_angle_90(vec2 texcoord,
+                     float body, float head,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, body, head, 1.0, linewidth, antialias);
+}
+
+float arrow_angle_60(vec2 texcoord,
+                     float body, float head,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, body, head, 0.5, linewidth, antialias);
+}
+
+float arrow_angle_30(vec2 texcoord,
+                     float body, float head,
+                     float linewidth, float antialias)
+{
+    return arrow_angle(texcoord, body, head, 0.25, linewidth, antialias);
+}
+
+
+float arrow_stealth(vec2 texcoord,
+                    float body, float head,
+                    float linewidth, float antialias)
+{
+    float w = linewidth/2.0 + antialias;
+    vec2 start = -vec2(body/2.0, 0.0);
+    vec2 end   = +vec2(body/2.0, 0.0);
+    float height = 0.5;
+
+    // Head : 4 lines
+    float d1 = line_distance(texcoord, end-head*vec2(+1.0,-height),
+                                       end);
+    float d2 = line_distance(texcoord, end-head*vec2(+1.0,-height),
+                                       end-vec2(3.0*head/4.0,0.0));
+    float d3 = line_distance(texcoord, end-head*vec2(+1.0,+height), end);
+    float d4 = line_distance(texcoord, end-head*vec2(+1.0,+0.5),
+                                       end-vec2(3.0*head/4.0,0.0));
+
+    // Body : 1 segment
+    float d5 = segment_distance(texcoord, start, end - vec2(linewidth,0.0));
+
+    return min(d5, max( max(-d1, d3), - max(-d2,d4)));
+}