vispy 0.15.0__cp312-cp312-macosx_10_13_x86_64.whl

vispy/glsl/transforms/power-scale.glsl

@@ -0,0 +1,139 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+/*
+  Power scales are similar to linear scales, except there's an exponential
+  transform that is applied to the input domain value before the output range
+  value is computed. The mapping to the output range value y can be expressed
+  as a function of the input domain value x: y = mx^k + b, where k is the
+  exponent value. Power scales also support negative values, in which case the
+  input value is multiplied by -1, and the resulting output value is also
+  multiplied by -1.
+*/
+
+uniform int  power_scale_clamp;
+uniform int  power_scale_discard;
+uniform vec2 power_scale_range;
+uniform vec2 power_scale_domain;
+uniform float power_scale_exponent;
+
+float forward(float value)
+{
+    vec2 domain = power_scale_domain;
+    vec2 range = power_scale_range;
+    float exponent = power_scale_exponent;
+    float v = pow(abs(value), exponent);
+    float t = (v - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (power_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (power_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 = power_scale_domain;
+    vec2 range = power_scale_range;
+    float exponent = power_scale_exponent;
+    vec2 v = pow(abs(value), vec2(exponent));
+    vec2 t = (v - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (power_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (power_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 = power_scale_domain;
+    vec2 range = power_scale_range;
+    float exponent = power_scale_exponent;
+    vec3 v = pow(abs(value), vec3(exponent));
+    vec3 t = (v - domain.x) /(domain.y - domain.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (power_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (power_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 = power_scale_domain;
+    vec2 range = power_scale_range;
+    float exponent = power_scale_exponent;
+    float t = (abs(value) - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (power_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (power_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    float v = domain.x + t*(domain.y - domain.x);
+    return sign(value) * pow(abs(v), 1.0/exponent);
+}
+
+vec2 inverse(vec2 value)
+{
+    vec2 domain = power_scale_domain;
+    vec2 range = power_scale_range;
+    float exponent = power_scale_exponent;
+    vec2 t = (abs(value) - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (power_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (power_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    vec2 v = domain.x + t*(domain.y - domain.x);
+    return sign(value) * pow(abs(v), vec2(1.0/exponent));
+}
+
+vec3 inverse(vec3 value)
+{
+    vec2 domain = power_scale_domain;
+    vec2 range = power_scale_range;
+    float exponent = power_scale_exponent;
+    vec3 t = (abs(value) - range.x) / (range.y - range.x);
+
+#ifdef __FRAGMENT_SHADER__
+    if (power_scale_discard > 0)
+        if (t != clamp(t, 0.0, 1.0))
+            discard;
+#endif
+
+    if (power_scale_clamp > 0)
+        t = clamp(t, 0.0, 1.0);
+
+    vec3 v = domain.x + t*(domain.y - domain.x);
+    return sign(value) * pow(abs(v), vec3(1.0/exponent));
+}

vispy/glsl/transforms/projection.glsl

@@ -0,0 +1,7 @@
+// Simple matrix projection
+uniform mat4 projection;
+
+vec4 transform(vec4 position)
+{
+    return projection*position;
+}

vispy/glsl/transforms/pvm.glsl

@@ -0,0 +1,13 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+uniform mat4 view;
+uniform mat4 model;
+uniform mat4 projection;
+
+vec4 transform(vec4 position)
+{
+    return projection*view*model*position;
+}

vispy/glsl/transforms/rotate.glsl

@@ -0,0 +1,45 @@
+// -----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier
+// Distributed under the (new) BSD License. See LICENSE.txt for more info.
+// -----------------------------------------------------------------------------
+uniform vec3 rotate_axis;
+uniform vec3 rotate_origin;
+uniform float rotate_angle;
+uniform mat4 rotate_forward_matrix;
+uniform mat4 rotate_inverse_matrix;
+
+vec2 forward(vec2 position)
+{
+    vec4 P = vec4(position,0.0,1.0);
+    P.xy -= rotate_origin.xy;
+    P = rotate_forward_matrix*P;
+    P.xy += rotate_origin.xy;
+    return P.xy;
+}
+
+vec3 forward(vec3 position)
+{
+    vec4 P = vec4(position,1.0);
+    P.xyz -= rotate_origin;
+    P = rotate_forward_matrix*P;
+    P.xyz += rotate_origin;
+    return P.xyz;
+}
+
+vec2 inverse(vec2 position)
+{
+    vec4 P = vec4(position,0.0,1.0);
+    P.xy -= rotate_origin.xy;
+    P = rotate_inverse_matrix*P;
+    P.xy += rotate_origin.xy;
+    return P.xy;
+}
+
+vec3 inverse(vec3 position)
+{
+    vec4 P = vec4(position,1.0);
+    P.xyz -= rotate_origin;
+    P = rotate_inverse_matrix*P;
+    P.xyz += rotate_origin;
+    return P.xyz;
+}

vispy/glsl/transforms/trackball.glsl

@@ -0,0 +1,15 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+uniform mat4 trackball_view;
+uniform mat4 trackball_model;
+uniform mat4 trackball_projection;
+
+vec4 transform(vec4 position)
+{
+    return trackball_projection
+           * trackball_view
+           * trackball_model
+           * position;
+}

vispy/glsl/transforms/translate.glsl

@@ -0,0 +1,35 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+uniform vec3 translate_translate;
+
+vec2 forward(float x, float y)
+{ return vec2(x,y) + translate_translate.xy; }
+
+vec2 forward(vec2 P)
+{ return P + translate_translate.xy; }
+
+vec3 forward(float x, float y, float z)
+{ return vec3(x,y,z) + translate_translate); }
+
+vec3 forward(vec3 P)
+{ return P + translate_translate; }
+
+vec4 forward(vec4 P)
+{ return vec4(P.xyz + translate_translate, P.w); }
+
+vec2 inverse(float x, float y)
+{ return vec2(x,y) - translate_translate.xy; }
+
+vec2 inverse(vec2 P)
+{ return P - translate_translate.xy; }
+
+vec3 inverse(float x, float y, float z)
+{ return vec3(x,y,z) - translate_translate); }
+
+vec3 inverse(vec3 P)
+{ return P - translate_translate; }
+
+vec4 inverse(vec4 P)
+{ return vec4(P.xyz - translate_translate, P.w); }

vispy/glsl/transforms/transverse_mercator.glsl

@@ -0,0 +1,38 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+//
+//   Transverse Mercator projection
+//   See http://en.wikipedia.org/wiki/Transverse_Mercator_projection
+//
+// ----------------------------------------------------------------------------
+#include "math/constants.glsl"
+
+// 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)); }
+
+vec2 forward(float lambda, float phi)
+{
+    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);
+}
+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 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);
+}
+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/viewport-clipping.glsl

@@ -0,0 +1,14 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+uniform vec4 viewport;    // in pixels
+uniform vec2 iResolution; // in pixels
+void clipping(void)
+{
+    vec2 position = gl_FragCoord.xy;
+         if( position.x < (viewport.x)) discard;
+    else if( position.x > (viewport.x+viewport.z)) discard;
+    else if( position.y < (viewport.y)) discard;
+    else if( position.y > (viewport.y+viewport.w)) discard;
+}

vispy/glsl/transforms/viewport-transform.glsl

@@ -0,0 +1,16 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+uniform vec4 viewport;    // in pixels
+uniform vec2 iResolution; // in pixels
+vec4 transform(vec4 position)
+{
+    float w = viewport.z / iResolution.x;
+    float h = viewport.w / iResolution.y;
+    float x = 2.0*(viewport.x / iResolution.x) - 1.0 + w;
+    float y = 2.0*(viewport.y / iResolution.y) - 1.0 + h;
+    return  vec4((x + w*position.x/position.w)*position.w,
+                 (y + h*position.y/position.w)*position.w,
+                 position.z, position.w);
+}

vispy/glsl/transforms/viewport.glsl

@@ -0,0 +1,50 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+uniform vec4 viewport_local;
+uniform vec4 viewport_global;
+uniform int viewport_transform;
+uniform int viewport_clipping;
+
+#ifdef __VERTEX_SHADER__
+void transform(void)
+{
+    if (viewport_transform == 0) return;
+
+    vec4 position = gl_Position;
+
+    float w = viewport_local.z / viewport_global.z;
+    float h = viewport_local.w / viewport_global.w;
+    float x = 2.0*(viewport_local.x / viewport_global.z) - 1.0 + w;
+    float y = 2.0*(viewport_local.y / viewport_global.w) - 1.0 + h;
+
+    gl_Position = vec4((x + w*position.x/position.w)*position.w,
+                       (y + h*position.y/position.w)*position.w,
+                       position.z, position.w);
+}
+#endif
+
+#ifdef __FRAGMENT_SHADER__
+void clipping(void)
+{
+//    if (viewport_clipping == 0) return;
+
+    vec2 position = gl_FragCoord.xy;
+         if( position.x < (viewport_local.x))                  discard;
+    else if( position.x > (viewport_local.x+viewport_local.z)) discard;
+    else if( position.y < (viewport_local.y))                  discard;
+    else if( position.y > (viewport_local.y+viewport_local.w)) discard;
+
+    /*
+    if( length(position.x - viewport_local.x) < 1.0 )
+        gl_FragColor = vec4(0,0,0,1);
+    else if( length(position.x - viewport_local.x - viewport_local.z) < 1.0 )
+        gl_FragColor = vec4(0,0,0,1);
+    else if( length(position.y - viewport_local.y) < 1.0 )
+        gl_FragColor = vec4(0,0,0,1);
+    else if( length(position.y - viewport_local.y - viewport_local.w) < 1.0 )
+        gl_FragColor = vec4(0,0,0,1);
+    */
+}
+#endif

vispy/glsl/transforms/x.glsl

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

vispy/glsl/transforms/y.glsl

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

vispy/glsl/transforms/z.glsl

@@ -0,0 +1,14 @@
+// ----------------------------------------------------------------------------
+// Copyright (c) 2014, Nicolas P. Rougier. All Rights Reserved.
+// Distributed under the (new) BSD License.
+// ----------------------------------------------------------------------------
+
+float get_z(vec3 xyz)
+{
+    return xyz.z;
+}
+
+float get_z(vec4 xyzw)
+{
+    return xyzw.z;
+}

vispy/io/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""Utilities related to data reading, writing, fetching, and generation."""
+
+
+from os import path as _op
+
+from .datasets import (load_iris, load_crate, load_data_file,  # noqa
+                       load_spatial_filters)  # noqa
+from .mesh import read_mesh, write_mesh  # noqa
+from .image import (read_png, write_png, imread, imsave, _make_png,  # noqa
+                    _check_img_lib)  # noqa
+
+_data_dir = _op.join(_op.dirname(__file__), '_data')
+
+__all__ = ['imread', 'imsave', 'load_iris', 'load_crate',
+           'load_spatial_filters', 'load_data_file',
+           'read_mesh', 'read_png', 'write_mesh',
+           'write_png']

vispy/io/datasets.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+import numpy as np
+from os import path as op
+
+from ..util import load_data_file
+
+# This is the package data dir, not the dir for config, etc.
+DATA_DIR = op.join(op.dirname(__file__), '_data')
+
+
+def load_iris():
+    """Load the iris dataset
+
+    Returns
+    -------
+    iris : NpzFile
+        data['data'] : a (150, 4) NumPy array with the iris' features
+        data['group'] : a (150,) NumPy array with the iris' group
+    """
+    return np.load(load_data_file('iris/iris.npz',
+                                  force_download='2014-09-04'))
+
+
+def load_crate():
+    """Load an image of a crate
+
+    Returns
+    -------
+    crate : array
+        256x256x3 crate image.
+    """
+    return np.load(load_data_file('orig/crate.npz'))['crate']
+
+
+def pack_unit(value):
+    """Packs float values between [0,1] into 4 unsigned int8
+
+    Returns
+    -------
+    pack: array
+        packed interpolation kernel
+    """
+    pack = np.zeros(value.shape + (4,), dtype=np.ubyte)
+    for i in range(4):
+        value, pack[..., i] = np.modf(value * 256.)
+    return pack
+
+
+def pack_ieee(value):
+    """Packs float ieee binary representation into 4 unsigned int8
+
+    Returns
+    -------
+    pack: array
+        packed interpolation kernel
+    """
+    return np.fromstring(value.tobytes(),
+                         np.ubyte).reshape((value.shape + (4,)))
+
+
+def load_spatial_filters(packed=True):
+    """Load spatial-filters kernel
+
+    Parameters
+    ----------
+    packed : bool
+        Whether or not the data should be in "packed" representation
+        for use in GLSL code.
+
+    Returns
+    -------
+    kernel : array
+        16x1024x4 (packed float in rgba) or
+        16x1024 (unpacked float)
+        16 interpolation kernel with length 1024 each.
+
+    names : tuple of strings
+        Respective interpolation names, plus "Nearest" which does
+        not require a filter but can still be used
+    """
+    names = ("Linear", "Hanning", "Hamming", "Hermite",
+             "Kaiser", "Quadric", "Cubic", "CatRom",
+             "Mitchell", "Spline16", "Spline36", "Gaussian",
+             "Bessel", "Sinc", "Lanczos", "Blackman", "Nearest")
+
+    kernel = np.load(op.join(DATA_DIR, 'spatial-filters.npy'))
+    if packed:
+        # convert the kernel to a packed representation
+        kernel = pack_unit(kernel)
+
+    return kernel, names