vispy 0.15.0__cp312-cp312-macosx_10_13_x86_64.whl

vispy/glsl/misc/viewport-NDC.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+vec2 NDC_to_viewport(vec4 position, vec2 viewport)
+{
+    vec2 p = position.xy/position.w;
+    return (p+1.0)/2.0 * viewport;
+}
+
+vec4 viewport_to_NDC(vec2 position, vec2 viewport)
+{
+    return vec4(2.0*(position/viewport) - 1.0, 0.0, 1.0);
+}
+
+vec4 viewport_to_NDC(vec3 position, vec2 viewport)
+{
+    return vec4(2.0*(position.xy/viewport) - 1.0, position.z, 1.0);
+}

vispy/glsl/transforms/azimuthal-equal-area.glsl

@@ -0,0 +1,32 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+float scale(float x) { return sqrt(2.0/(1.0+x)); }
+float angle(float x) { return 2.0 * asin(x/2.0); }
+
+vec2 forward(float longitude, float latitude)
+{
+    float cos_lon = cos(longitude);
+    float cos_lat = cos(latitude);
+    float k = scale(cos_lon * cos_lat);
+    return vec2( k * cos_lat * sin(longitude), k * sin(latitude));
+}
+vec2 forward(vec2 P) { return forward(P.x,P.y); }
+vec3 forward(vec3 P) { return vec3(forward(P.x,P.y), P.z); }
+vec4 forward(vec4 P) { return vec4(forward(P.x,P.y), P.z, P.w); }
+
+vec2 inverse(float x, float y)
+{
+    float rho = sqrt(x*x + y*y);
+    float c = angle(rho);
+    float sinc = sin(c);
+    float cosc = cos(c);
+    if (rho != 0)
+        return vec2( atan(x*sinc, rho*cosc), asin(y*sinc/rho));
+    return vec2( atan(x*sinc, rho*cosc), asin(0));
+}
+vec2 inverse(vec2 P) { return inverse(P.x,P.y); }
+vec3 inverse(vec3 P) { return vec3(inverse(P.x,P.y), P.z); }
+vec4 inverse(vec4 P) { return vec4(inverse(P.x,P.y), P.z, P.w); }

vispy/glsl/transforms/azimuthal-equidistant.glsl

@@ -0,0 +1,38 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+float scale(float x) {
+    float c = acos(x);
+    if (c != 0.0)
+        return c / sin(c);
+    discard;
+ }
+float angle(float x) { return x; }
+
+vec2 forward(float longitude, float latitude)
+{
+    float cos_lon = cos(longitude);
+    float cos_lat = cos(latitude);
+    float k = scale(cos_lon * cos_lat);
+    return vec2( k * cos_lat * sin(longitude), k * sin(latitude));
+}
+vec2 forward(vec2 P) { return forward(P.x,P.y); }
+vec3 forward(vec3 P) { return vec3(forward(P.x,P.y), P.z); }
+vec4 forward(vec4 P) { return vec4(forward(P.x,P.y), P.z, P.w); }
+
+vec2 inverse(float x, float y)
+{
+    float rho = sqrt(x*x + y*y);
+    float c = angle(rho);
+    float sinc = sin(c);
+    float cosc = cos(c);
+    //if (rho != 0)
+    return vec2( atan(x*sinc, rho*cosc), asin(y*sinc/rho));
+    //else
+    //return vec2( atan(x*sinc, rho*cosc), asin(1e10));
+}
+vec2 inverse(vec2 P) { return inverse(P.x,P.y); }
+vec3 inverse(vec3 P) { return vec3(inverse(P.x,P.y), P.z); }
+vec4 inverse(vec4 P) { return vec4(inverse(P.x,P.y), P.z, P.w); }

vispy/glsl/transforms/hammer.glsl

@@ -0,0 +1,44 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+//
+//   Hammer projection
+//   See http://en.wikipedia.org/wiki/Hammer_projection
+//
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+const float B = 2.0;
+
+vec4 forward(float longitude, float latitude, float z, float w)
+{
+    float cos_lat = cos(latitude);
+    float sin_lat = sin(latitude);
+    float cos_lon = cos(longitude/B);
+    float sin_lon = sin(longitude/B);
+    float d = sqrt(1.0 + cos_lat * cos_lon);
+    float x = (B * M_SQRT2 * cos_lat * sin_lon) / d;
+    float y =     (M_SQRT2 * sin_lat) / d;
+    return vec4(x,y,z,w);
+}
+vec4 forward(float x, float y) {return forward(x, y, 0.0, 1.0);}
+vec4 forward(float x, float y, float z) {return forward(x, y, 0.0, 1.0);}
+vec4 forward(vec2 P) { return forward(P.x, P.y); }
+vec4 forward(vec3 P) { return forward(P.x, P.y, P.z, 1.0); }
+vec4 forward(vec4 P) { return forward(P.x, P.y, P.z, P.w); }
+
+
+vec2 inverse(float x, float y)
+{
+    float z = 1.0 - (x*x/16.0) - (y*y/4.0);
+    // if (z < 0.0)
+    //     discard;
+    z = sqrt(z);
+    float longitude = 2.0*atan( (z*x),(2.0*(2.0*z*z - 1.0)));
+    float latitude = asin(z*y);
+    return vec2(longitude, latitude);
+}
+vec2 inverse(vec2 P) { return inverse(P.x,P.y); }
+vec3 inverse(vec3 P) { return vec3(inverse(P.x,P.y), P.z); }
+vec4 inverse(vec4 P) { return vec4(inverse(P.x,P.y), P.z, P.w); }

vispy/glsl/transforms/identity.glsl

@@ -0,0 +1,6 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "transforms/identity_forward.glsl"
+#include "transforms/identity_inverse.glsl"

vispy/glsl/transforms/identity_forward.glsl

@@ -0,0 +1,23 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+   Forward identity projection (identity)
+
+   Parameters:
+   -----------
+
+   position : 2d position in cartesian coordinates
+
+   Return:
+   -------
+   2d position in cartesian coordinates
+
+   --------------------------------------------------------- */
+
+vec2 transform_identity_forward(vec2 P)
+{
+    return P;
+}

vispy/glsl/transforms/identity_inverse.glsl

@@ -0,0 +1,23 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/* ---------------------------------------------------------
+   Inverse cartesian projection (identity)
+
+   Parameters:
+   -----------
+
+   position : 2d position in cartesian coordinates
+
+   Return:
+   -------
+
+   2d position in cartesian coordinates
+
+   --------------------------------------------------------- */
+vec2 transform_identity_inverse(vec2 P)
+{
+    return P;
+}

vispy/glsl/transforms/linear-scale.glsl

@@ -0,0 +1,127 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+/*
+  Linear scales are the most common scale, and a good default choice to map a
+  continuous input domain to a continuous output range. The mapping is linear
+  in that the output range value y can be expressed as a linear function of the
+  input domain value x: y = mx + b. The input domain is typically a dimension
+  of the data that you want to visualize, such as the height of students
+  (measured in meters) in a sample population. The output range is typically a
+  dimension of the desired output visualization, such as the height of bars
+  (measured in pixels) in a histogram.
+*/
+uniform int  linear_scale_clamp;
+uniform int  linear_scale_discard;
+uniform vec2 linear_scale_range;
+uniform vec2 linear_scale_domain;
+
+
+float forward(float value)
+{
+    vec2 domain = linear_scale_domain;
+    vec2 range = linear_scale_range;
+    float t = (value - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (linear_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (linear_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    return range.x + t*(range.y - range.x);
+}
+
+vec2 forward(vec2 value)
+{
+    vec2 domain = linear_scale_domain;
+    vec2 range = linear_scale_range;
+    vec2 t = (value - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (linear_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (linear_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    return range.x + t*(range.y - range.x);
+}
+
+vec3 forward(vec3 value)
+{
+    vec2 domain = linear_scale_domain;
+    vec2 range = linear_scale_range;
+    vec3 t = (value - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (linear_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (linear_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    return range.x + t*(range.y - range.x);
+}
+
+float inverse(float value)
+{
+    vec2 domain = linear_scale_domain;
+    vec2 range = linear_scale_range;
+    float t = (value - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (linear_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (linear_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    return domain.x + t*(domain.y - domain.x);
+}
+
+vec2 inverse(vec2 value)
+{
+    vec2 domain = linear_scale_domain;
+    vec2 range = linear_scale_range;
+    vec2 t = (value - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (linear_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (linear_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    return domain.x + t*(domain.y - domain.x);
+}
+
+vec3 inverse(vec3 value)
+{
+    vec2 domain = linear_scale_domain;
+    vec2 range = linear_scale_range;
+    vec3 t = (value - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (linear_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (linear_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    return domain.x + t*(domain.y - domain.x);
+}

vispy/glsl/transforms/log-scale.glsl

@@ -0,0 +1,126 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+uniform int  log_scale_clamp;
+uniform int  log_scale_discard;
+uniform vec2 log_scale_range;
+uniform vec2 log_scale_domain;
+uniform float log_scale_base;
+
+float forward(float value)
+{
+    vec2 domain = log_scale_domain;
+    vec2 range = log_scale_range;
+    float base = log_scale_base;
+
+    float v = log(value) / log(base);
+    float t = (v - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (log_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (log_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+    return sign(value) * (range.x + t*(range.y - range.x));
+}
+
+vec2 forward(vec2 value)
+{
+    vec2 domain = log_scale_domain;
+    vec2 range = log_scale_range;
+    float base = log_scale_base;
+    vec2 v = log(value) / log(base);
+    vec2 t = (v - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (log_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (log_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+    return sign(value) * (range.x + t*(range.y - range.x));
+}
+
+vec3 forward(vec3 value)
+{
+    vec2 domain = log_scale_domain;
+    vec2 range = log_scale_range;
+    float base = log_scale_base;
+    vec3 v = log(value) / log(base);
+    vec3 t = (v - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (log_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (log_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+    return sign(value) * (range.x + t*(range.y - range.x));
+}
+
+
+float inverse(float value)
+{
+    vec2 domain = log_scale_domain;
+    vec2 range = log_scale_range;
+    float base = log_scale_base;
+    float t = (abs(value) - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (log_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (log_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+    float v = domain.x + t*(domain.y - domain.x);
+    return sign(value) * pow(base, abs(v));
+}
+
+vec2 inverse(vec2 value)
+{
+    vec2 domain = log_scale_domain;
+    vec2 range = log_scale_range;
+    float base = log_scale_base;
+    vec2 t = (abs(value) - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (log_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (log_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+    vec2 v = domain.x + t*(domain.y - domain.x);
+    return sign(value) * pow(vec2(base), abs(v));
+}
+
+vec3 inverse(vec3 value)
+{
+    vec2 domain = log_scale_domain;
+    vec2 range = log_scale_range;
+    float base = log_scale_base;
+    vec3 t = (abs(value) - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (log_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (log_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+    vec3 v = domain.x + t*(domain.y - domain.x);
+    return sign(value) * pow(vec3(base), abs(v));
+}

vispy/glsl/transforms/mercator-transverse-forward.glsl

@@ -0,0 +1,40 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Constants
+// ---------
+const float k0 = 0.75;
+const float a  = 1.00;
+
+// Helper functions
+// ----------------
+float cosh(float x) { return 0.5 * (exp(x)+exp(-x)); }
+float sinh(float x) { return 0.5 * (exp(x)-exp(-x)); }
+
+
+/* ---------------------------------------------------------
+   Transverse Mercator projection
+   -> http://en.wikipedia.org/wiki/Transverse_Mercator_projection
+
+
+   Parameters:
+   -----------
+
+   position : 2d position in (longitude,latitiude) coordinates
+
+   Return:
+   -------
+   2d position in cartesian coordinates
+
+   --------------------------------------------------------- */
+
+vec2 transform_forward(vec2 P)
+{
+    float lambda = P.x;
+    float phi = P.y;
+    float x = 0.5*k0*log((1.0+sin(lambda)*cos(phi)) / (1.0 - sin(lambda)*cos(phi)));
+    float y = k0*a*atan(tan(phi), cos(lambda));
+    return vec2(x,y);
+}

vispy/glsl/transforms/mercator-transverse-inverse.glsl

@@ -0,0 +1,40 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+// Constants
+// ------------------------------------
+const float k0 = 0.75;
+const float a  = 1.00;
+
+
+// Helper functions
+// ------------------------------------
+float cosh(float x) { return 0.5 * (exp(x)+exp(-x)); }
+float sinh(float x) { return 0.5 * (exp(x)-exp(-x)); }
+
+
+/* ---------------------------------------------------------
+   Inverse Lambert azimuthal equal-area projection
+   -> http://en.wikipedia.org/wiki/Transverse_Mercator_projection
+
+   Parameters:
+   -----------
+
+   position : 2d position in cartesian coordinates
+
+   Return:
+   -------
+   2d position in (longitude,latitiude) coordinates
+
+   --------------------------------------------------------- */
+
+vec2 transform_inverse(vec2 P)
+{
+    float x = P.x;
+    float y = P.y;
+    float lambda = atan(sinh(x/(k0*a)),cos(y/(k0*a)));
+    float phi    = asin(sin(y/(k0*a))/cosh(x/(k0*a)));
+    return vec2(lambda,phi);
+}

vispy/glsl/transforms/panzoom.glsl

@@ -0,0 +1,10 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+uniform vec2 panzoom_scale;
+uniform vec2 panzoom_translate;
+vec4 panzoom(vec4 position)
+{
+    return vec4(panzoom_scale*position.xy + panzoom_translate, position.z, 1.0);
+}

vispy/glsl/transforms/polar.glsl

@@ -0,0 +1,41 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+//
+//   Polar projection
+//   See http://en.wikipedia.org/wiki/Hammer_projection
+//
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+uniform float polar_origin;
+
+vec4 forward(float rho, float theta, float z, float w)
+{
+    return vec4(rho * cos(theta + polar_origin),
+                rho * sin(theta + polar_origin),
+                z, w);
+}
+vec4 forward(float x, float y) {return forward(x, y, 0.0, 1.0);}
+vec4 forward(float x, float y, float z) {return forward(x, y, z, 1.0);}
+vec4 forward(vec2 P) { return forward(P.x, P.y); }
+vec4 forward(vec3 P) { return forward(P.x, P.y, P.z, 1.0); }
+vec4 forward(vec4 P) { return forward(P.x, P.y, P.z, P.w); }
+// vec4 forward(float x, float y, float z) { return vec3(forward(x,y),z); }
+
+vec4 inverse(float x, float y, float z, float w)
+{
+    float rho = length(vec2(x,y));
+    float theta = atan(y,x);
+    if( theta < 0.0 )
+        theta = 2.0*M_PI+theta;
+    return vec4(rho, theta-polar_origin, z, w);
+}
+vec4 inverse(float x, float y) {return inverse(x,y,0.0,1.0); }
+vec4 inverse(float x, float y, float z) {return inverse(x,y,z,1.0); }
+vec4 inverse(vec2 P) { return inverse(P.x, P.y, 0.0, 1.0); }
+vec4 inverse(vec3 P) { return inverse(P.x, P.y, P.z, 1.0); }
+vec4 inverse(vec4 P) { return inverse(P.x, P.y, P.z, P.w); }
+
+//vec3 inverse(float x, float y, float z) { return vec3(inverse(x,y),z); }

vispy/glsl/transforms/position.glsl

@@ -0,0 +1,44 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+vec4 position(float x)
+{
+    return vec4(x, 0.0, 0.0, 1.0);
+}
+
+vec4 position(float x, float y)
+{
+    return vec4(x, y, 0.0, 1.0);
+}
+
+vec4 position(vec2 xy)
+{
+    return vec4(xy, 0.0, 1.0);
+}
+
+vec4 position(float x, float y, float z)
+{
+    return vec4(x, y, z, 1.0);
+}
+
+vec4 position(vec3 xyz)
+{
+    return vec4(xyz, 1.0);
+}
+
+vec4 position(vec4 xyzw)
+{
+    return xyzw;
+}
+
+vec4 position(vec2 xy, float z)
+{
+    return vec4(xy, z, 1.0);
+}
+
+vec4 position(float x, vec2 yz)
+{
+    return vec4(x, yz, 1.0);
+}