vispy 0.15.0__cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

vispy/glsl/markers/marker.vert

@@ -0,0 +1,46 @@
+// ----------------------------------------------------------------------------
+// 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 vec4  fg_color;
+attribute vec4  bg_color;
+attribute float orientation;
+attribute float linewidth;
+
+// Varyings
+// ------------------------------------
+varying float v_size;
+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_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/markers/markers.glsl

@@ -0,0 +1,24 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+#include "markers/arrow.glsl"
+#include "markers/asterisk.glsl"
+#include "markers/chevron.glsl"
+#include "markers/clover.glsl"
+#include "markers/club.glsl"
+#include "markers/cross.glsl"
+#include "markers/diamond.glsl"
+#include "markers/disc.glsl"
+#include "markers/ellipse.glsl"
+#include "markers/hbar.glsl"
+#include "markers/heart.glsl"
+#include "markers/infinity.glsl"
+#include "markers/pin.glsl"
+#include "markers/ring.glsl"
+#include "markers/spade.glsl"
+#include "markers/square.glsl"
+#include "markers/tag.glsl"
+#include "markers/triangle.glsl"
+#include "markers/vbar.glsl"

vispy/glsl/markers/pin.glsl

@@ -0,0 +1,18 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+float marker_pin(vec2 P, float size)
+{
+    size *= .9;
+
+    vec2 c1 = vec2(0.0,-0.15)*size;
+    float r1 = length(P-c1)-size/2.675;
+    vec2 c2 = vec2(+1.49,-0.80)*size;
+    float r2 = length(P-c2) - 2.*size;
+    vec2 c3 = vec2(-1.49,-0.80)*size;
+    float r3 = length(P-c3) - 2.*size;
+    float r4 = length(P-c1)-size/5;
+    return max( min(r1,max(max(r2,r3),-P.y)), -r4);
+}

vispy/glsl/markers/ring.glsl

@@ -0,0 +1,11 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+float marker_ring(vec2 P, float size)
+{
+    float r1 = length(P) - size/2.;
+    float r2 = length(P) - size/4.;
+    return max(r1,-r2);
+}

vispy/glsl/markers/spade.glsl

@@ -0,0 +1,28 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_spade(vec2 P, float size)
+{
+   // Reversed heart (diamond + 2 circles)
+   float s= size * 0.85 / 3.5;
+   float x = M_SQRT2/2.0 * (P.x + P.y) + 0.4*s;
+   float y = M_SQRT2/2.0 * (P.x - P.y) - 0.4*s;
+   float r1 = max(abs(x),abs(y)) - s;
+   float r2 = length(P - M_SQRT2/2.0*vec2(+1.0,+0.2)*s) - s;
+   float r3 = length(P - M_SQRT2/2.0*vec2(-1.0,+0.2)*s) - s;
+   float r4 =  min(min(r1,r2),r3);
+
+   // Root (2 circles and 2 planes)
+   const vec2 c1 = vec2(+0.65, 0.125);
+   const vec2 c2 = vec2(-0.65, 0.125);
+   float r5 = length(P-c1*size) - size/1.6;
+   float r6 = length(P-c2*size) - size/1.6;
+   float r7 = P.y - 0.5*size;
+   float r8 = 0.1*size - P.y;
+   float r9 = max(-min(r5,r6), max(r7,r8));
+
+    return min(r4,r9);
+}

vispy/glsl/markers/square.glsl

@@ -0,0 +1,10 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_square(vec2 P, float size)
+{
+    return max(abs(P.x), abs(P.y)) - size/2.0;
+}

vispy/glsl/markers/tag.glsl

@@ -0,0 +1,11 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+float marker_tag(vec2 P, float size)
+{
+    float r1 = max(abs(P.x)- size/2.0, abs(P.y)- size/6.0);
+    float r2 = abs(P.x-size/2.0)+abs(P.y)-size;
+    return max(r1,.75*r2);
+}

vispy/glsl/markers/triangle.glsl

@@ -0,0 +1,14 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+float marker_triangle(vec2 P, float size)
+{
+    float x = M_SQRT2/2.0 * (P.x - (P.y-size/6));
+    float y = M_SQRT2/2.0 * (P.x + (P.y-size/6));
+    float r1 = max(abs(x), abs(y)) - size/(2.0*M_SQRT2);
+    float r2 = P.y-size/6;
+    return max(r1,r2);
+}

vispy/glsl/markers/vbar.glsl

@@ -0,0 +1,9 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// -----------------------------------------------------------------------------
+
+float marker_vbar(vec2 P, float size)
+{
+    return max(abs(P.y)- size/2.0, abs(P.x)- size/6.0);
+}

vispy/glsl/math/circle-through-2-points.glsl

@@ -0,0 +1,30 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+
+   Computes the center of the 2 circles with given radius passing through
+   p1 & p2
+
+   Parameters:
+   -----------
+
+   p0, p1: Points ascribed in the circles
+   radius: Radius of the circle
+
+   Return:
+   -------
+   Centers of the two circles with specified radius
+
+   --------------------------------------------------------- */
+
+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);
+}

vispy/glsl/math/constants.glsl

@@ -0,0 +1,48 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+#ifndef _CONSTANTS_
+#define _CONSTANTS_
+
+// The base of natural logarithms (e)
+const float M_E = 2.71828182845904523536028747135266250;
+
+// The logarithm to base 2 of M_E (log2(e))
+const float M_LOG2E = 1.44269504088896340735992468100189214;
+
+// The logarithm to base 10 of M_E (log10(e))
+const float M_LOG10E = 0.434294481903251827651128918916605082;
+
+// The natural logarithm of 2 (loge(2))
+const float M_LN2 = 0.693147180559945309417232121458176568;
+
+// The natural logarithm of 10 (loge(10))
+const float M_LN10 = 2.30258509299404568401799145468436421;
+
+// Pi, the ratio of a circle's circumference to its diameter.
+const float M_PI = 3.14159265358979323846264338327950288;
+
+// Pi divided by two (pi/2)
+const float M_PI_2 = 1.57079632679489661923132169163975144;
+
+// Pi divided by four  (pi/4)
+const float M_PI_4 = 0.785398163397448309615660845819875721;
+
+// The reciprocal of pi (1/pi)
+const float M_1_PI = 0.318309886183790671537767526745028724;
+
+// Two times the reciprocal of pi (2/pi)
+const float M_2_PI = 0.636619772367581343075535053490057448;
+
+// Two times the reciprocal of the square root of pi (2/sqrt(pi))
+const float M_2_SQRTPI = 1.12837916709551257389615890312154517;
+
+// The square root of two (sqrt(2))
+const float M_SQRT2 = 1.41421356237309504880168872420969808;
+
+// The reciprocal of the square root of two (1/sqrt(2))
+const float M_SQRT1_2 = 0.707106781186547524400844362104849039;
+
+#endif

vispy/glsl/math/double.glsl

@@ -0,0 +1,114 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+/*
+  This shader program emulates double-precision variables using a vec2 instead
+  of single-precision floats. Any function starting with double_* operates on
+  these variables. See https://blog.cyclemap.link/2011-06-09-glsl-part2-emu/.
+
+  NOTE: Some NVIDIA cards optimize the double-precision code away. Results are
+  therefore hardware dependent.
+*/
+#define double vec2
+
+
+/* -------------------------------------------------------------------------
+
+   Create an emulated double by storing first part of float in first half of
+   vec2
+
+   ------------------------------------------------------------------------- */
+
+vec2 double_set(float value)
+{
+    double result;
+    result.x = value;
+    result.y = 0.0;
+    return result;
+}
+
+
+
+/* -------------------------------------------------------------------------
+
+   Add two emulated doubles. Complexity comes from carry-over.
+
+   ------------------------------------------------------------------------- */
+
+vec2 double_add(double value_a, double value_b)
+{
+    double result;
+    float t1, t2, e;
+
+    t1 = value_a.x + value_b.x;
+    e = t1 - value_a.x;
+    t2 = ((value_b.x - e) + (value_a.x - (t1 - e))) + value_a.y + value_b.y;
+    result.x = t1 + t2;
+    result.y = t2 - (result.x - t1);
+    return result;
+}
+
+
+
+/* -------------------------------------------------------------------------
+
+   Multiply two emulated doubles.
+
+   ------------------------------------------------------------------------- */
+
+vec2 double_mul(double value_a, double value_b)
+{
+    double result;
+    float c11, c21, c2, e, t1, t2;
+    float a1, a2, b1, b2, cona, conb, split = 8193.;
+
+    cona = value_a.x * split;
+    conb = value_b.x * split;
+    a1 = cona - (cona - value_a.x);
+    b1 = conb - (conb - value_b.x);
+    a2 = value_a.x - a1;
+    b2 = value_b.x - b1;
+
+    c11 = value_a.x * value_b.x;
+    c21 = a2 * b2 + (a2 * b1 + (a1 * b2 + (a1 * b1 - c11)));
+
+    c2 = value_a.x * value_b.y + value_a.y * value_b.x;
+
+    t1 = c11 + c2;
+    e = t1 - c11;
+    t2 = value_a.y * value_b.y + ((c2 - e) + (c11 - (t1 - e))) + c21;
+
+    result.x = t1 + t2;
+    result.y = t2 - (result.x - t1);
+
+    return result;
+}
+
+
+
+/* -------------------------------------------------------------------------
+
+   Compare two emulated doubles.
+   Return -1 if a < b
+           0 if a == b
+           1 if a > b
+
+   ------------------------------------------------------------------------- */
+
+float double_compare(double value_a, double value_b)
+{
+    if (value_a.x < value_b.x) {
+        return -1.;
+    } else if (value_a.x == value_b.x) {
+        if (value_a.y < value_b.y) {
+            return -1.;
+        } else if (value_a.y == value_b.y) {
+            return 0.;
+        } else {
+            return 1.;
+        }
+    } else {
+        return 1.;
+    }
+}

vispy/glsl/math/functions.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+   Hyperbolic cosine
+   --------------------------------------------------------- */
+float cosh(float x)
+{
+    return 0.5 * (exp(x)+exp(-x));
+}
+
+/* ---------------------------------------------------------
+   Hyperbolic sine
+   --------------------------------------------------------- */
+float sinh(float x)
+{
+    return 0.5 * (exp(x)-exp(-x));
+}

vispy/glsl/math/point-to-line-distance.glsl

@@ -0,0 +1,31 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+   Compute distance from a point to a line (2d)
+
+   Parameters:
+   -----------
+
+   p0, p1: Points describing the line
+   p: Point to computed distance to
+
+   Return:
+   -------
+   Distance of p to (p0,p1)
+
+   --------------------------------------------------------- */
+float point_to_line_distance(vec2 p0, vec2 p1, vec2 p)
+{
+    // Projection p' of p such that p' = p0 + u*(p1-p0)
+    vec2 v = p1 - p0;
+    float l2 = v.x*v.x + v.y*v.y;
+    float u = ((p.x-p0.x)*v.x + (p.y-p0.y)*v.y) / l2;
+
+    // h is the projection of p on (p0,p1)
+    vec2 h = p0 + u*v;
+
+    return length(p-h);
+}

vispy/glsl/math/point-to-line-projection.glsl

@@ -0,0 +1,29 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+
+   Project a point p onto a line (p0,p1) and return linear position u such that
+   p' = p0 + u*(p1-p0)
+
+   Parameters:
+   -----------
+
+   p0, p1: Points describing the line
+   p: Point to be projected
+
+   Return:
+   -------
+   Linear position of p onto (p0,p1)
+
+   --------------------------------------------------------- */
+float point_to_line_projection(vec2 p0, vec2 p1, vec2 p)
+{
+    // Projection p' of p such that p' = p0 + u*(p1-p0)
+    // Then  u *= lenght(p1-p0)
+    vec2 v = p1 - p0;
+    float l = length(v);
+    return ((p.x-p0.x)*v.x + (p.y-p0.y)*v.y) / l;
+}

vispy/glsl/math/signed-line-distance.glsl

@@ -0,0 +1,27 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+
+   Computes the signed distance from a line
+
+   Parameters:
+   -----------
+
+   p0, p1: Points describing the line
+   p: Point to measure distance from
+
+   Return:
+   -------
+   Signed distance
+
+   --------------------------------------------------------- */
+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));
+}

vispy/glsl/math/signed-segment-distance.glsl

@@ -0,0 +1,30 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+
+   Computes the signed distance from a line segment
+
+   Parameters:
+   -----------
+
+   p0, p1: Points describing the line segment
+   p: Point to measure distance from
+
+   Return:
+   -------
+   Signed distance
+
+   --------------------------------------------------------- */
+
+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);
+}