vispy 0.15.0__cp312-cp312-macosx_10_13_x86_64.whl

vispy/glsl/colormaps/hot.glsl

@@ -0,0 +1,22 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_hot(float t)
+{
+    return vec3(smoothstep(0.0,    1.0/3.0,t),
+                smoothstep(1.0/3.0,2.0/3.0,t),
+                smoothstep(2.0/3.0,1.0,    t));
+}
+
+vec3 colormap_hot(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_hot(t), under, over);
+}
+
+vec4 colormap_hot(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_hot(t),1.0), under, over);
+}

vispy/glsl/colormaps/ice.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_ice(float t)
+{
+   return vec3(t, t, 1.0);
+}
+
+vec3 colormap_ice(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_ice(t), under, over);
+}
+
+vec4 colormap_ice(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_ice(t),1.0), under, over);
+}

vispy/glsl/colormaps/icefire.glsl

@@ -0,0 +1,23 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+#include "colormaps/ice.glsl"
+#include "colormaps/fire.glsl"
+
+vec3 colormap_icefire(float t)
+{
+    return colormap_segment(0.0,0.5,t) * colormap_ice(2.0*(t-0.0)) +
+           colormap_segment(0.5,1.0,t) * colormap_fire(2.0*(t-0.5));
+}
+
+vec3 colormap_icefire(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_icefire(t), under, over);
+}
+
+vec4 colormap_icefire(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_icefire(t),1.0), under, over);
+}

vispy/glsl/colormaps/parse.py

@@ -0,0 +1,40 @@
+import os
+import re
+
+
+def get(filename):
+    for path in ["..", "."]:
+        filepath = os.path.join(path, filename)
+        if os.path.exists(filepath):
+            with open(filepath) as infile:
+                code = infile.read()
+                # comment = '#line 0 // Start of "%s"\n' % filename
+                comment = '// --- start of "%s" ---\n' % filename
+            return comment + code
+    return '#error "%s" not found !\n' % filename
+
+code = """
+#include "colormap/colormaps.glsl"
+"""
+
+re_include = re.compile(r'\#include\s*"(?P<filename>[a-zA-Z0-9\-\.\/]+)"')
+
+includes = []
+
+
+def replace(match):
+    filename = match.group("filename")
+    if filename not in includes:
+        includes.append(filename)
+        text = get(filename)
+        # lineno = code.count("\n",0,match.start())+1
+        # text += '\n#line %d // End of "%s"' % (lineno, filename)
+        text += '// --- end of "%s" ---\n' % filename
+        return text
+    return ''
+
+
+if __name__ == "__main__":
+    while re.search(re_include, code):
+        code = re.sub(re_include, replace, code)
+    print(code)

vispy/glsl/colormaps/reds.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_reds(float t)
+{
+    return mix(vec3(1,1,1), vec3(1,0,0), t);
+}
+
+vec3 colormap_reds(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_reds(t), under, over);
+}
+
+vec4 colormap_reds(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_reds(t),1.0), under, over);
+}

vispy/glsl/colormaps/spring.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_spring(float t)
+{
+    return mix(vec3(1.0,0.0,1.0), vec3(1.0,1.0,0.0), t);
+}
+
+vec3 colormap_spring(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_spring(t), under, over);
+}
+
+vec4 colormap_spring(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_spring(t),1.0), under, over);
+}

vispy/glsl/colormaps/summer.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_summer(float t)
+{
+    return mix(vec3(0.0,0.5,0.4), vec3(1.0,1.0,0.4), t);
+}
+
+vec3 colormap_summer(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_summer(t), under, over);
+}
+
+vec4 colormap_summer(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_summer(t),1.0), under, over);
+}

vispy/glsl/colormaps/user.glsl

@@ -0,0 +1,22 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+uniform sampler1D colormap;
+
+vec3 colormap_user(float t)
+{
+    return texture1D(colormap, t).rgb;
+}
+
+vec3 colormap_user(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_user(t), under, over);
+}
+
+vec4 colormap_user(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_user(t),1.0), under, over);
+}

vispy/glsl/colormaps/util.glsl

@@ -0,0 +1,41 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+/*
+ * t <= 0    : return 0
+ * 0 < t < 1 : return t
+ * t >= 1    : return 0
+ */
+float
+colormap_segment(float edge0, float edge1, float x)
+{
+    return step(edge0,x) * (1.0-step(edge1,x));
+}
+
+/*
+ * t <= 0    : return under
+ * 0 < t < 1 : return color
+ * t >= 1    : return over
+ */
+vec3
+colormap_underover(float t, vec3 color, vec3 under, vec3 over)
+{
+    return step(t,0.0)*under +
+           colormap_segment(0.0,1.0,t)*color +
+           step(1.0,t)*over;
+}
+
+/*
+ * t <= 0    : return under
+ * 0 < t < 1 : return color
+ * t >= 1    : return over
+ */
+vec4
+colormap_underover(float t, vec4 color, vec4 under, vec4 over)
+{
+    return step(t,0.0)*under +
+           colormap_segment(0.0,1.0,t)*color +
+           step(1.0,t)*over;
+}

vispy/glsl/colormaps/wheel.glsl

@@ -0,0 +1,21 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+// Wheel colormap by Morgan McGuire
+vec3 colormap_wheel(float t)
+{
+    return clamp(abs(fract(t + vec3(1.0, 2.0 / 3.0, 1.0 / 3.0)) * 6.0 - 3.0) -1.0, 0.0, 1.0);
+}
+
+vec3 colormap_wheel(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_wheel(t), under, over);
+}
+
+vec4 colormap_wheel(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_wheel(t),1.0), under, over);
+}

vispy/glsl/colormaps/winter.glsl

@@ -0,0 +1,20 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+#include "colormaps/util.glsl"
+
+vec3 colormap_winter(float t)
+{
+    return mix(vec3(0.0,0.0,1.0), vec3(0.0,1.0,0.5), sqrt(t));
+}
+
+vec3 colormap_winter(float t, vec3 under, vec3 over)
+{
+    return colormap_underover(t, colormap_winter(t), under, over);
+}
+
+vec4 colormap_winter(float t, vec4 under, vec4 over)
+{
+    return colormap_underover(t, vec4(colormap_winter(t),1.0), under, over);
+}

vispy/glsl/lines/agg.frag

@@ -0,0 +1,320 @@
+#include "math/constants.glsl"
+
+const float THETA = 15.0 * 3.14159265358979323846264/180.0;
+
+float
+cap( int type, float dx, float dy, float t )
+{
+    float d = 0.0;
+    dx = abs(dx);
+    dy = abs(dy);
+
+    // None
+    if      (type == 0)  discard;
+    // Round
+    else if (type == 1)  d = sqrt(dx*dx+dy*dy);
+    // Triangle in
+    else if (type == 3)  d = (dx+abs(dy));
+    // Triangle out
+    else if (type == 2)  d = max(abs(dy),(t+dx-abs(dy)));
+    // Square
+    else if (type == 4)  d = max(dx,dy);
+    // Butt
+    else if (type == 5)  d = max(dx+t,dy);
+
+    return d;
+}
+
+float
+join( in int type, in float d, in vec2 segment, in vec2 texcoord,
+      in vec2 miter, in float miter_limit, in float linewidth )
+{
+    float dx = texcoord.x;
+
+    // Round join
+    // --------------------------------
+    if( type == 1 )
+    {
+        if (dx < segment.x) {
+            d = max(d,length( texcoord - vec2(segment.x,0.0)));
+            //d = length( texcoord - vec2(segment.x,0.0));
+        } else if (dx > segment.y) {
+            d = max(d,length( texcoord - vec2(segment.y,0.0)));
+            //d = length( texcoord - vec2(segment.y,0.0));
+        }
+    }
+
+    // Bevel join
+    // --------------------------------
+    else if ( type == 2 )
+    {
+        if( (dx < segment.x) ||  (dx > segment.y) )
+            d = max(d, min(abs(miter.x),abs(miter.y)));
+    }
+
+    // Miter limit
+    // --------------------------------
+    if( (dx < segment.x) ||  (dx > segment.y) )
+    {
+        d = max(d, min(abs(miter.x),
+                       abs(miter.y)) - miter_limit*linewidth/2.0 );
+    }
+
+    return d;
+}
+
+
+// Uniforms
+uniform sampler2D u_dash_atlas;
+
+// Varying
+varying vec4  v_color;
+varying vec2  v_segment;
+varying vec2  v_angles;
+varying vec2  v_linecaps;
+varying vec2  v_texcoord;
+varying vec2  v_miter;
+varying float v_miter_limit;
+varying float v_length;
+varying float v_linejoin;
+varying float v_linewidth;
+varying float v_antialias;
+varying float v_dash_phase;
+varying float v_dash_period;
+varying float v_dash_index;
+varying vec2  v_dash_caps;
+varying float v_closed;
+void main()
+{
+    // gl_FragColor = v_color; return;
+    // vec4 color = v_color;
+
+    // If color is fully transparent we just discard the fragment
+    if( v_color.a <= 0.0 ) {
+        discard;
+    }
+
+    // Test if dash pattern is the solid one (0)
+    bool solid = (v_dash_index == 0.0);
+
+    float dx = v_texcoord.x;
+    float dy = v_texcoord.y;
+    float t = v_linewidth/2.0-v_antialias;
+    float width = v_linewidth;
+    float d = 0.0;
+
+    vec2 linecaps = v_linecaps;
+    vec2 dash_caps = v_dash_caps;
+    float line_start = 0.0;
+    float line_stop  = v_length;
+    // Test if path is closed
+    bool closed = (v_closed > 0.0);
+
+    // ------------------------------------------------------------------------
+    // Solid line
+    // ------------------------------------------------------------------------
+    if( solid ) {
+        d = abs(dy);
+
+        if( (!closed) && (dx < line_start) )
+        {
+            d = cap( int(v_linecaps.x), abs(dx), abs(dy), t );
+        }
+        else if( (!closed) &&  (dx > line_stop) )
+        {
+            d = cap( int(v_linecaps.y), abs(dx)-line_stop, abs(dy), t );
+        }
+        else
+        {
+            d = join( int(v_linejoin), abs(dy), v_segment, v_texcoord,
+                      v_miter, v_miter_limit, v_linewidth );
+        }
+
+    // ------------------------------------------------------------------------
+    // Dash line
+    // ------------------------------------------------------------------------
+    } else {
+        float segment_start = v_segment.x;
+        float segment_stop  = v_segment.y;
+        float segment_center = (segment_start+segment_stop)/2.0;
+        float freq = v_dash_period*width;
+        float u = mod( dx + v_dash_phase*width,freq );
+        vec4 tex = texture2D(u_dash_atlas, vec2(u/freq, v_dash_index));
+        float dash_center= tex.x * width;
+        float dash_type  = tex.y;
+        float _start = tex.z * width;
+        float _stop  = tex.a * width;
+        float dash_start = dx - u + _start;
+        float dash_stop  = dx - u + _stop;
+
+        // This test if the we are dealing with a discontinuous angle
+        bool discont = ((dx <  segment_center) && abs(v_angles.x) > THETA) ||
+                       ((dx >= segment_center) && abs(v_angles.y) > THETA);
+        if( dx < line_start) discont = false;
+        if( dx > line_stop)  discont = false;
+
+        // When path is closed, we do not have room for linecaps, so we make
+        // room by shortening the total length
+        if (closed){
+            line_start += v_linewidth/2.0;
+            line_stop  -= v_linewidth/2.0;
+            linecaps = v_dash_caps;
+        }
+
+
+        // Check is dash stop is before line start
+        if( dash_stop <= line_start )
+        {
+            discard;
+        }
+        // Check is dash start is beyond line stop
+        if( dash_start >= line_stop )
+        {
+            discard;
+        }
+
+        // Check if current pattern start is beyond segment stop
+        if( discont )
+        {
+            // Dash start is beyond segment, we discard
+            if( dash_start > segment_stop )
+            {
+                discard;
+            }
+
+            // Dash stop is before segment, we discard
+            if( dash_stop < segment_start )
+            {
+                discard;
+            }
+
+            // Special case for round caps (nicer with this)
+            if( (u > _stop) && (dash_stop > segment_stop ) &&
+                (abs(v_angles.y) < M_PI/2.0))
+            {
+                if( dash_caps.x == 1.0) discard;
+            }
+            // Special case for round caps  (nicer with this)
+            else if( (u < _start) && (dash_start < segment_start ) &&
+                     (abs(v_angles.x) < M_PI/2.0))
+            {
+                if( dash_caps.y == 1.0) discard;
+            }
+
+            // Special case for triangle caps (in & out) and square
+            // We make sure the cap stop at crossing frontier
+            if( (dash_caps.x != 1.0) && (dash_caps.x != 5.0) )
+            {
+                if( (dash_start < segment_start ) &&
+                    (abs(v_angles.x) < M_PI/2.0) )
+                {
+                    float a = v_angles.x/2.0;
+                    float x = (segment_start-dx)*cos(a) - dy*sin(a);
+                    float y = (segment_start-dx)*sin(a) + dy*cos(a);
+                    if( (x > 0.0) ) discard;
+                    // We transform the cap into square to avoid holes
+                    dash_caps.x = 4.0;
+                }
+            }
+            // Special case for triangle caps (in & out) and square
+            // We make sure the cap stop at crossing frontier
+            if( (dash_caps.y != 1.0) && (dash_caps.y != 5.0) )
+            {
+                if( (dash_stop > segment_stop ) &&
+                    (abs(v_angles.y) < M_PI/2.0) )
+                {
+                    float a = v_angles.y/2.0;
+                    float x = (dx-segment_stop)*cos(a) - dy*sin(a);
+                    float y = (dx-segment_stop)*sin(a) + dy*cos(a);
+                    if( (x > 0.0) ) discard;
+                    // We transform the caps into square to avoid holes
+                    dash_caps.y = 4.0;
+                }
+            }
+        }
+
+        // Line cap at start
+        if( (dx < line_start) && (dash_start < line_start) &&
+            (dash_stop > line_start) )
+        {
+            d = cap( int(linecaps.x), dx-line_start, dy, t);
+        }
+        // Line cap at stop
+        else if( (dx > line_stop) && (dash_stop > line_stop) &&
+                 (dash_start < line_stop)  )
+        {
+            d = cap( int(linecaps.y), dx-line_stop, dy, t);
+        }
+        // Dash cap left
+        else if( dash_type < 0.0 )
+        {
+            float u = max( u-dash_center , 0.0 );
+            d = cap( int(dash_caps.y), abs(u), dy, t);
+        }
+        // Dash cap right
+        else if( dash_type > 0.0 )
+        {
+            float u = max( dash_center-u, 0.0 );
+            d = cap( int(dash_caps.x), abs(u), dy, t);
+        }
+        // Dash body (plain)
+        else if( dash_type == 0.0 )
+        {
+            d = abs(dy);
+        }
+
+        // Antialiasing at segment angles region
+        if( discont )
+        {
+            if( dx < segment_start )
+            {
+                // For sharp angles, we do not enforce cap shape
+                if( (dash_start < segment_start ) &&
+                    (abs(v_angles.x) > M_PI/2.0))
+                {
+                    d = abs(dy);
+                }
+                // Antialias at outer border
+                dx = segment_start - dx;
+                float angle = M_PI/2.+v_angles.x;
+                float f = abs( dx*cos(angle) - dy*sin(angle));
+                d = max(f,d);
+            }
+            else if( (dx > segment_stop) )
+            {
+                // For sharp angles, we do not enforce cap shape
+                if( (dash_stop > segment_stop ) &&
+                    (abs(v_angles.y) > M_PI/2.0) )
+                {
+                    d = abs(dy);
+                }
+                // Antialias at outer border
+                dx = dx - segment_stop;
+                float angle = M_PI/2.+v_angles.y;
+                float f = abs( dx*cos(angle) - dy*sin(angle));
+                d = max(f,d);
+            }
+        }
+
+        // Line join
+        //if( (dx > line_start) && (dx < line_stop) )
+        {
+            d = join( int(v_linejoin), d, v_segment, v_texcoord,
+                      v_miter, v_miter_limit, v_linewidth );
+        }
+    }
+
+
+    // Distance to border
+    // ------------------------------------------------------------------------
+    d = d - t;
+    if( d < 0.0 )
+    {
+        gl_FragColor = v_color;
+    }
+    else
+    {
+        d /= v_antialias;
+        gl_FragColor = vec4(v_color.xyz, exp(-d*d)*v_color.a);
+    }
+}