def test_FunctionChain():
f1 = Function("void f1(){}")
f2 = Function("void f2(){}")
f3 = Function("float f3(vec3 x){}")
f4 = Function("vec3 f4(vec3 y){}")
f5 = Function("vec3 f5(vec4 z){}")
ch = FunctionChain('chain', [f1, f2])
assert ch.name == 'chain'
assert ch.args == []
assert ch.rtype == 'void'
assert_in('f1', ch.compile())
assert_in('f2', ch.compile())
ch.remove(f2)
assert_not_in('f2', ch.compile())
ch.append(f2)
assert_in('f2', ch.compile())
ch = FunctionChain(funcs=[f5, f4, f3])
assert_equal('float', ch.rtype)
assert_equal([('vec4', 'z')], ch.args)
assert_in('f3', ch.compile())
assert_in('f4', ch.compile())
assert_in('f5', ch.compile())
assert_in(f3, ch.dependencies())
assert_in(f4, ch.dependencies())
assert_in(f5, ch.dependencies())
def test_FunctionCall():
fun = Function(transformScale)
fun['scale'] = '1.0'
fun2 = Function(transformZOffset)
# No args
assert_raises(TypeError, fun) # need 1 arg
assert_raises(TypeError, fun, 1, 2) # need 1 arg
call = fun('x')
# Test repr
exp = call.expression({fun: 'y'})
assert_equal(exp, 'y(x)')
# Test sig
assert len(call._args) == 1
# Test dependencies
assert_in(fun, call.dependencies())
assert_in(call._args[0], call.dependencies())
# More args
call = fun(fun2('foo'))
# Test repr
exp = call.expression({fun: 'y', fun2: 'z'})
assert_in('y(z(', exp)
# Test sig
assert len(call._args) == 1
call2 = call._args[0]
assert len(call2._args) == 1
# Test dependencies
assert_in(fun, call.dependencies())
assert_in(call._args[0], call.dependencies())
assert_in(fun2, call.dependencies())
assert_in(call2._args[0], call.dependencies())
def __init__(self, texture, texcoords, enabled=True):
"""Apply a texture on a mesh."""
vfunc = Function("""
void pass_coords() {
$v_texcoords = $texcoords;
}
""")
ffunc = Function("""
void apply_texture() {
if ($enabled == 1) {
gl_FragColor *= texture2D($u_texture, $texcoords);
}
}
""")
self._texcoord_varying = Varying('v_texcoord', 'vec2')
vfunc['v_texcoords'] = self._texcoord_varying
ffunc['texcoords'] = self._texcoord_varying
self._texcoords_buffer = VertexBuffer(
np.zeros((0, 2), dtype=np.float32))
vfunc['texcoords'] = self._texcoords_buffer
super().__init__(vcode=vfunc, vhook='pre', fcode=ffunc)
self.enabled = enabled
self.texture = texture
self.texcoords = texcoords
def _build_color_transform(data, cmap, clim=(0., 1.)):
if data.ndim == 2 and data.shape[1] == 1:
fun = Function(_clim)
fun['cmin'] = clim[0]
fun['cmax'] = clim[1]
fun = FunctionChain(None, [fun, Function(cmap.glsl_map)])
else:
fun = Function(_null_color_transform)
return fun
def __new__(cls, *args, **kwargs):
self = super(Filter, cls).__new__(cls)
if hasattr(cls, 'FRAG_SHADER'):
self.fshader = Function(self.FRAG_SHADER)
self.fshader_expr = self.fshader()
if hasattr(cls, 'VERT_SHADER'):
self.vshader = Function(self.VERT_SHADER)
self.vshader_expr = self.vshader()
return self
def test_StatementList():
func = Function("void func() {}")
main = Function("void main() {}")
main['pre'] = StatementList()
expr = func()
main['pre'].append(expr)
assert main['pre'].items == [expr]
main['pre'].add(expr)
assert main['pre'].items == [expr]
code = main.compile()
assert " func();" in code
main['pre'].remove(expr)
assert main['pre'].items == []
def test_StatementList():
func = Function("void func() {}")
main = Function("void main() {}")
main['pre'] = StatementList()
expr = func()
main['pre'].add(expr, 0)
assert list(main['pre'].items) == [expr]
main['pre'].add(expr)
assert list(main['pre'].items) == [expr]
code = main.compile()
assert " func();" in code
main['pre'].remove(expr)
assert list(main['pre'].items) == []
def cmap(self, cmap):
self._cmap = get_colormap(cmap)
self.shared_program.frag['cmap'] = Function(self._cmap.glsl_map)
# Colormap change fix
self.shared_program['texture2D_LUT'] = (self.cmap.texture_lut() if (
hasattr(self.cmap, 'texture_lut')) else None)
self.update()
def set_cmap(self, label, cmap):
if isinstance(cmap, str):
cmap = get_colormap(cmap)
self.volumes[label]['cmap'] = cmap
index = self.volumes[label]['index']
self.shared_program.frag['cmap{0:d}'.format(index)] = Function(
cmap.glsl_map)
def __init__(self,
n_volume_max=10,
threshold=None,
relative_step_size=0.8,
emulate_texture=False):
Visual.__init__(self)
self._n_volume_max = n_volume_max
# Only show back faces of cuboid. This is required because if we are
# inside the volume, then the front faces are outside of the clipping
# box and will not be drawn.
self.set_gl_state('translucent', cull_face=False)
tex_cls = TextureEmulated3D if emulate_texture else Texture3D
# Storage of information of volume
self._initial_shape = True
self._vol_shape = ()
self._vertex_cache_id = ()
self._clim = None
# Create gloo objects
self._vbo = None
self._tex = tex_cls((10, 10, 10),
interpolation='linear',
wrapping='clamp_to_edge')
# Set custom vertex shader
vert_shader, frag_shader = get_shaders(n_volume_max)
frag_dict['additive_multi_volume'] = frag_shader
# Create program
self._program = ModularProgram(vert_shader)
self.textures = []
for i in range(n_volume_max):
self.textures.append(
tex_cls((10, 10, 10),
interpolation='linear',
wrapping='clamp_to_edge'))
self._program['u_volumetex_{0}'.format(i)] = self.textures[i]
self._index_buffer = None
# Set params
self.method = 'additive_multi_volume'
self.relative_step_size = relative_step_size
for i in range(n_volume_max):
self._program.frag['cmap{0:d}'.format(i)] = Function(
get_colormap('grays').glsl_map)
self._program['u_enabled_{0}'.format(i)] = 0
self._program['u_weight_{0}'.format(i)] = 1
self.xd = None
self._block_size = None
self.volumes = {}
self._create_vertex_data()
def test_colormap():
"""Test named colormaps."""
autumn = get_colormap('autumn')
assert autumn.glsl_map is not ""
assert len(autumn[0.]) == 1
assert len(autumn[0.5]) == 1
assert len(autumn[1.]) == 1
assert len(autumn[[0., 0.5, 1.]]) == 3
assert len(autumn[np.array([0., 0.5, 1.])]) == 3
fire = get_colormap('fire')
assert_array_equal(fire[0].rgba, np.ones((1, 4)))
assert_array_equal(fire[1].rgba, np.array([[1, 0, 0, 1]]))
grays = get_colormap('grays')
assert_array_equal(grays[.5].rgb, np.ones((1, 3)) * .5)
hot = get_colormap('hot')
assert_allclose(hot[0].rgba, [[0, 0, 0, 1]], 1e-6, 1e-6)
assert_allclose(hot[0.5].rgba, [[1, .52272022, 0, 1]], 1e-6, 1e-6)
assert_allclose(hot[1.].rgba, [[1, 1, 1, 1]], 1e-6, 1e-6)
# Test the GLSL and Python mapping.
for name in get_colormaps():
colormap = get_colormap(name)
Function(colormap.glsl_map)
colors = colormap[np.linspace(-2., 2., 50)]
assert colors.rgba.min() >= 0
assert colors.rgba.max() <= 1
def __init__(self, cmap, zrange=(0, 1)):
if isinstance(cmap, str):
cmap = colormap.get_colormap(cmap)
self.cmap = Function(cmap.glsl_map)
self.fshader['cmap'] = self.cmap
self.fshader['zrange'] = zrange
self.vshader['zval'] = Varying('v_zval', dtype='float')
self.fshader['zval'] = self.vshader['zval']
def __init__(self, enabled=True, color='black', width=1.0,
wireframe_only=False, faces_only=False):
self._attached = False
self._color = Color(color)
self._width = width
self._enabled = enabled
self._wireframe_only = wireframe_only
self._faces_only = faces_only
vfunc = Function(wireframe_vertex_template)
ffunc = Function(wireframe_fragment_template)
self._bc = VertexBuffer(np.zeros((0, 3), dtype=np.float32))
vfunc['bc'] = self._bc
super().__init__(vcode=vfunc, fcode=ffunc)
self.enabled = enabled
def _build_color_transform(self):
if self.num_channels != 3:
raise NotImplementedError(
"MultiChannelimageVisuals only support 3 channels.")
else:
# RGB/A image data (no colormap)
fclim = Function(_apply_clim)
fgamma = Function(_apply_gamma)
fun = FunctionChain(
None, [Function(_null_color_transform), fclim, fgamma])
fclim['clim_r'] = self._texture.textures[0].clim_normalized
fclim['clim_g'] = self._texture.textures[1].clim_normalized
fclim['clim_b'] = self._texture.textures[2].clim_normalized
fgamma['gamma_r'] = self.gamma[0]
fgamma['gamma_g'] = self.gamma[1]
fgamma['gamma_b'] = self.gamma[2]
return fun
def _build_color_transform(self):
# this first line should be the only difference from the same method in base Image
if len(self.tile_shape) == 2 or self.tile_shape[2] == 1:
# luminance data
fclim = Function(self._func_templates['clim_float'])
fgamma = Function(self._func_templates['gamma_float'])
# NOTE: red_to_luminance only uses the red component, fancy internalformats
# may need to use the other components or a different function chain
fun = FunctionChain(
None,
[
Function(self._func_templates['red_to_luminance']),
fclim,
fgamma,
Function(self.cmap.glsl_map),
],
)
else:
# RGB/A image data (no colormap)
fclim = Function(self._func_templates['clim'])
fgamma = Function(self._func_templates['gamma'])
fun = FunctionChain(
None,
[
Function(self._func_templates['null_color_transform']),
fclim,
fgamma,
],
)
fclim['clim'] = self._texture.clim_normalized
fgamma['gamma'] = self.gamma
return fun
def __init__(self, data):
super(SignalsVisual, self).__init__()
self._program = ModularProgram(self.VERTEX_SHADER,
self.FRAGMENT_SHADER)
nsignals, nsamples = data.shape
# nsamples, nsignals = data.shape
self._data = data
a_index = np.c_[np.repeat(np.arange(nsignals), nsamples),
np.tile(np.arange(nsamples), nsignals)].astype(
np.float32)
# Doesn't seem to work nor to be very efficient.
# indices = nsignals * np.arange(nsamples)
# indices = indices[None, :] + np.arange(nsignals)[:, None]
# indices = indices.flatten().astype(np.uint32)
# self._ibuffer = gloo.IndexBuffer(indices)
self._buffer = gloo.VertexBuffer(data.reshape(-1, 1))
self._program['a_position'] = self._buffer
self._program['a_index'] = a_index
x_transform = Function(X_TRANSFORM)
x_transform['nsamples'] = nsamples
self._program.vert['get_x'] = x_transform
y_transform = Function(Y_TRANSFORM)
y_transform['scale'] = Variable('uniform float u_signal_scale', 5.)
y_transform['nsignals'] = nsignals
self._program.vert['get_y'] = y_transform
self._y_transform = y_transform
colormap = Function(DISCRETE_CMAP)
cmap = np.random.uniform(size=(1, nsignals, 3), low=.5,
high=.9).astype(np.float32)
tex = gloo.Texture2D((cmap * 255).astype(np.uint8))
colormap['colormap'] = Variable('uniform sampler2D u_colormap', tex)
colormap['ncolors'] = nsignals
self._program.frag['get_color'] = colormap
def __init__(self):
self.shader = Function("""
void apply_alpha() {
// perception
const vec3 w = vec3(1, 1, 1);
float value = dot(gl_FragColor.rgb, w);
if ( value == 0) {
gl_FragColor.a = 0;
}
}
""")
def __init__(self, *args, **kwargs):
kwargs.update(width = 40)
visuals.LineVisual.__init__(self, *args, **kwargs)
self.unfreeze()
try:
colormap = get_colormap(self._color)
color = Function(colormap.glsl_map)
except KeyError:
color = Color(self._color).rgba
self.non_selected_color = color
self.freeze()
def symbol(self, symbol):
if symbol == self._symbol:
return
self._symbol = symbol
if symbol is None:
self._marker_fun = None
else:
_check_valid('symbol', symbol, marker_types)
self._marker_fun = Function(_marker_dict[symbol])
self._marker_fun['v_size'] = self._v_size_var
self.shared_program.frag['marker'] = self._marker_fun
self.update()
def __init__(self, shading='flat', enabled=True, light_dir=(10, 5, -5),
light_color=(1, 1, 1, 1),
ambient_color=(.3, .3, .3, 1),
diffuse_color=(1, 1, 1, 1),
specular_color=(1, 1, 1, 1),
shininess=100):
self._shading = shading
self._enabled = enabled
self._light_dir = light_dir
self._light_color = Color(light_color)
self._ambient_color = Color(ambient_color)
self._diffuse_color = Color(diffuse_color)
self._specular_color = Color(specular_color)
self._shininess = shininess
vfunc = Function(shading_vertex_template)
ffunc = Function(shading_fragment_template)
self._normals = VertexBuffer(np.zeros((0, 3), dtype=np.float32))
vfunc['normal'] = self._normals
super().__init__(vcode=vfunc, fcode=ffunc)
def __init__(self, texture, transform, scale):
self.fshader = Function("""
void apply_texture_mask() {
vec4 tex_pos = $transform(gl_FragCoord);
tex_pos /= tex_pos.w;
vec4 mask = texture2D($texture, tex_pos.xy);
mask.w = 1.0;
gl_FragColor = gl_FragColor * mask;
}
""")
self.fshader['texture'] = texture
self.scale_tr = STTransform(scale=scale) * STTransform(translate=(0.5,
0.5))
self.fshader['transform'] = self.scale_tr * transform
def test_example2():
""" Demonstrate how a transform would work.
"""
vert_template = Function("""
void main(void)
{
gl_Position = $position;
}
""")
transformScale = Function("""
vec4 transform_scale(vec4 pos)
{
pos.xyz *= $scale;
return pos;
}
""")
class Transform(object):
def __init__(self):
# Equivalent methods to create new function object
self.func = Function(transformScale)
self.func['scale'] = 'uniform float'
#self.func = Function(transformScale)
def set_scale(self, scale):
self.func['scale'].value = scale
transforms = [Transform(), Transform(), Transform()]
code = Function(vert_template)
ob = Variable('attribute vec3 a_position')
for trans in transforms:
ob = trans.func(ob)
code['position'] = ob
print(code)
def __init__(self, texture, texcoords, enabled=True):
"""Apply a texture on a mesh.
Parameters
----------
texture : (M, N) or (M, N, C) array
The 2D texture image.
texcoords : (N, 2) array
The texture coordinates.
enabled : bool
Whether the display of the texture is enabled.
"""
vfunc = Function("""
void pass_coords() {
$v_texcoords = $texcoords;
}
""")
ffunc = Function("""
void apply_texture() {
if ($enabled == 1) {
gl_FragColor *= texture2D($u_texture, $texcoords);
}
}
""")
self._texcoord_varying = Varying('v_texcoord', 'vec2')
vfunc['v_texcoords'] = self._texcoord_varying
ffunc['texcoords'] = self._texcoord_varying
self._texcoords_buffer = VertexBuffer(
np.zeros((0, 2), dtype=np.float32)
)
vfunc['texcoords'] = self._texcoords_buffer
super().__init__(vcode=vfunc, vhook='pre', fcode=ffunc)
self.enabled = enabled
self.texture = texture
self.texcoords = texcoords
def __init__(self):
self.shader = Function("""
void screen_filter() {
float f = gl_FragCoord.x * 0.4 + gl_FragCoord.y;
f = mod(f, 20);
if( f < 5.0 ) {
discard;
}
if( f < 20.0 ) {
gl_FragColor.g = gl_FragColor.g + 0.05 * (20-f);
}
}
""")
def method(self, method):
# Check and save
known_methods = list(frag_dict.keys())
if method not in known_methods:
raise ValueError('Volume render method should be in %r, not %r' %
(known_methods, method))
self._method = method
# Get rid of specific variables - they may become invalid
if 'u_threshold' in self.shared_program:
self.shared_program['u_threshold'] = None
self.shared_program.frag = frag_dict[method]
self.shared_program.frag['sampler_type'] = self._tex.glsl_sampler_type
self.shared_program.frag['sample'] = self._tex.glsl_sample
self.shared_program.frag['cmap'] = Function(self._cmap.glsl_map)
self.update()
def method(self, method):
# Check and save
known_methods = list(frag_dict.keys())
if method not in known_methods:
raise ValueError('Volume render method should be in %r, not %r' %
(known_methods, method))
self._method = method
self.shared_program.frag = frag_dict[method]
self.shared_program.frag['sampler_type'] = self._tex.glsl_sampler_type
self.shared_program.frag['sample'] = self._tex.glsl_sample
self.shared_program.frag['cmap'] = Function(self._cmap.glsl_map)
self.shared_program['texture2D_LUT'] = (self.cmap.texture_lut() if (
hasattr(self.cmap, 'texture_lut')) else None)
if 'u_threshold' in self.shared_program:
self.shared_program['u_threshold'] = self.threshold
self.update()
def _build_color_transform(grayscale: bool, clim, gamma, cmap):
if grayscale:
fclim = Function(_apply_clim_float)
fgamma = Function(_apply_gamma_float)
fun = FunctionChain(
None, [Function(_c2l), fclim, fgamma,
Function(cmap.glsl_map)])
else:
fclim = Function(_apply_clim)
fgamma = Function(_apply_gamma)
fun = FunctionChain(None,
[Function(_null_color_transform), fclim, fgamma])
fclim['clim'] = clim
fgamma['gamma'] = gamma
return fun
def _build_color_transform(data, clim, gamma, cmap):
if data.ndim == 2 or data.shape[2] == 1:
fclim = Function(_apply_clim_float)
fgamma = Function(_apply_gamma_float)
fun = FunctionChain(
None, [Function(_c2l), fclim, fgamma,
Function(cmap.glsl_map)])
else:
fclim = Function(_apply_clim)
fgamma = Function(_apply_gamma)
fun = FunctionChain(None,
[Function(_null_color_transform), fclim, fgamma])
fclim['clim'] = clim
fgamma['gamma'] = gamma
return fun
def _build_interpolation(self):
# assumes 'nearest' interpolation
interpolation = self._interpolation
if interpolation != 'nearest':
raise NotImplementedError(
"MultiChannelImageVisual only supports 'nearest' interpolation."
)
texture_interpolation = 'nearest'
self._data_lookup_fn = Function(_rgb_texture_lookup)
self.shared_program.frag['get_data'] = self._data_lookup_fn
if self._texture.interpolation != texture_interpolation:
self._texture.interpolation = texture_interpolation
self._data_lookup_fn['texture_r'] = self._texture.textures[0]
self._data_lookup_fn['texture_g'] = self._texture.textures[1]
self._data_lookup_fn['texture_b'] = self._texture.textures[2]
self._need_interpolation_update = False
def test_function_changed():
ch = []
class C(object):
def _dep_changed(self, dep, **kwargs):
ch.append(dep)
ch_obj = C()
def assert_changed(*objs):
assert set(ch) == set(objs)
while ch:
ch.pop()
fun1 = Function('void main(){$var1; $var2;}')
fun1._dependents[ch_obj] = None
fun1['var1'] = 'x'
fun1['var2'] = 'y'
assert_changed(fun1)
fun1['var1'] = 'z'
assert_changed(fun1)
# same value; should result in no change events
fun1['var1'] = 'z'
assert_changed()
fun1['var1'] = 0.5
var1 = fun1['var1']
var1._dependents[ch_obj] = None
assert_changed(fun1)
var1.name = 'xxx'
assert_changed(fun1, var1)
# changing type requires code change
var1.value = 7
assert_changed(fun1, var1)
# changing value (but not type) requires no code changes
var1.value = 6
assert_changed()
# test variable disconnect
fun1['var1'] = Variable('var1', 7)
var2 = fun1['var1']
var2._dependents[ch_obj] = None
#assert_changed(fun1)
# var2 is now connected
var2.value = (1, 2, 3, 4)
assert_changed(fun1, var2)
# ..but var1 no longer triggers fun1.changed
assert_changed()
var1.value = 0.5
assert_changed(var1)
# test expressions
fun2 = Function('float fn(float x){return $var1 + x;}')
fun3 = Function('float fn(float x){return $var1 + x;}')
exp1 = fun2(fun3(0.5))
fun1['var2'] = exp1
assert_changed(fun1)
fun2._dependents[ch_obj] = None
fun3._dependents[ch_obj] = None
exp1._dependents[ch_obj] = None
fun2['var1'] = 'x'
assert_changed(fun1, fun2, exp1)
fun3['var1'] = 'x'
assert_changed(fun1, fun3, exp1)
# test disconnect
fun1['var2'] = fun2
assert_changed(fun1)
# triggers change
fun2['var1'] = 0.9
assert_changed(fun1, fun2, exp1)
# no longer triggers change
fun3['var1'] = 0.9
assert_changed(fun3, exp1)
def test_function_basics():
# Test init fail
assert_raises(TypeError, Function) # no args
assert_raises(ValueError, Function, 3) # need string
# Test init success 1
fun = Function('void main(){}')
assert_equal(fun.name, 'main')
assert len(fun.template_vars) == 0
# Test init success with template vars
fun = Function('void main(){$foo; $bar;}')
assert_equal(fun.name, 'main')
assert len(fun.template_vars) == 2
assert_in('foo', fun.template_vars)
assert_in('bar', fun.template_vars)
# Test setting verbatim expressions
assert_raises(KeyError, fun.__setitem__, 'bla', '33') # no such template
fun['foo'] = '33'
fun['bar'] = 'bla bla'
assert_is(type(fun['foo']), TextExpression)
assert_equal(fun['foo'].expression(None), '33')
assert_is(type(fun['bar']), TextExpression)
assert_equal(fun['bar'].expression(None), 'bla bla')
# Test setting call expressions
fun = Function('void main(){\n$foo;\n$bar;\n$spam(XX);\n$eggs(YY);\n}')
trans = Function('float transform_scale(float x) {return x+1.0;}')
assert_raises(TypeError, trans) # requires 1 arg
assert_raises(TypeError, trans, '1', '2')
fun['foo'] = trans('2')
fun['bar'] = trans('3')
fun['spam'] = trans
fun['eggs'] = trans
#
for name in ['foo', 'bar']:
assert_is(type(fun[name]), FunctionCall)
assert_equal(fun[name].function, trans)
assert_in(trans, fun.dependencies())
for name in ['spam', 'eggs']:
assert_equal(fun[name], trans)
#
text = fun.compile()
assert_in('\ntransform_scale(2);\n', text)
assert_in('\ntransform_scale(3);\n', text)
assert_in('\ntransform_scale(XX);\n', text)
assert_in('\ntransform_scale(YY);\n', text)
# test pre/post assignments
fun = Function('void main() {some stuff;}')
fun['pre'] = '__pre__'
fun['post'] = '__post__'
text = fun.compile()
assert text == 'void main() {\n __pre__\nsome stuff;\n __post__\n}\n'
# Test variable expressions
fun = Function('void main(){$foo; $bar;}')
fun['foo'] = Variable('uniform float bla')
fun['bar'] = Variable('attribute float bla')
assert_is(type(fun['foo']), Variable)
assert_is(type(fun['bar']), Variable)
assert_in(fun['foo'], fun.dependencies())
assert_in(fun['bar'], fun.dependencies())
# Test special variables
fun = Function('void main(){$foo; $bar;}')
variable = Variable('attribute vec3 v_pos')
varying = Variable('varying vec3 color')
# These do not work due to index
assert_raises(TypeError, fun.__setitem__, 3, 3) # not a string
assert_raises(KeyError, fun.__setitem__, 'xxx', 3) # unknown template var
assert_raises(TypeError, fun.__setitem__, variable, 3) # only varyings
# These work
fun['gl_PointSize'] = '3.0'
fun[varying] = variable
# And getting works
assert_equal(fun['gl_PointSize'].text, '3.0')
assert_equal(fun[varying], variable)
),
}
PROJECTIONS['lcc'] = (
lcc_init,
PROJECTIONS['lcc'][1],
PROJECTIONS['lcc'][1],
PROJECTIONS['lcc'][3],
PROJECTIONS['lcc'][3],
)
# Misc GLSL functions used in one or more mapping functions above
adjlon_func = Function("""
float adjlon(float lon) {
if (abs(lon) <= M_PI) return (lon);
lon += M_PI; // adjust to 0..2pi rad
lon -= M_TWOPI * floor(lon / M_TWOPI); // remove integral # of 'revolutions'
lon -= M_PI; // adjust back to -pi..pi rad
return( lon );
}
""")
pj_msfn = Function("""
float pj_msfn(float sinphi, float cosphi, float es) {
return (cosphi / sqrt (1. - es * sinphi * sinphi));
}
""")
def pj_msfn_py(sinphi, cosphi, es):
return cosphi / np.sqrt(1. - es * sinphi * sinphi)
Mayo systems electrophysiology lab
Mayo Clinic
200 1st St SW
Rochester, MN
United States
"""
from vispy import gloo, visuals
import OpenGL.GL as GL
from vispy.scene.visuals import create_visual_node
from vispy.visuals.shaders import Function
import numpy as np
vec1to4 = Function("""
in int gl_VertexID;
vec4 vec1to4(float inp) {
return vec4(gl_VertexID, inp, 0, 1);
}
""")
vec2to4 = Function("""
//in int gl_VertexID;
vec4 vec2to4(vec2 inp) {
return vec4(inp, 0, 1);
}
""")
vec3to4 = Function("""
//in int gl_VertexID;
vec4 vec3to4(vec3 inp) {
return vec4(inp, 1);
}