def __init__(self):
app.Canvas.__init__(self,
title='Rain [Move mouse]',
size=(512, 512),
keys='interactive')
# Build data
# --------------------------------------
n = 500
self.data = np.zeros(n, [('a_position', np.float32, 2),
('a_fg_color', np.float32, 4),
('a_size', np.float32, 1)])
self.index = 0
self.program = Program(vertex, fragment)
self.vdata = VertexBuffer(self.data)
self.program.bind(self.vdata)
self.program['u_antialias'] = 1.00
self.program['u_linewidth'] = 1.00
self.program['u_model'] = np.eye(4, dtype=np.float32)
self.program['u_view'] = np.eye(4, dtype=np.float32)
self.activate_zoom()
gloo.set_clear_color('white')
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer = app.Timer('auto', self.on_timer, start=True)
self.show()
def setupCanvas(self):
#Create the camera
self.__camera = Cam3D.Camera([0, -200, 150], [0, 0, 0], [0, 0, 1],
45.0,
self.size[0] / float(self.size[1]),
0.01,
1000.0,
is_2d=False)
#Build and setup the glprogram for rendering the models
self.program_solids = Program(vertex, fragment)
self.program_solids['model'] = vut.rotx(90)
self.program_solids['model'] = np.eye(4, dtype=np.float32)
self.program_solids['view'] = self.__camera.view
self.program_solids['u_alpha'] = np.float32(0.6)
# build and setup glprogram for rendering the points
self.program_points = gloo.Program(vert, frag)
self.program_points['u_linewidth'] = 1.0
self.program_points['u_antialias'] = 1.0
self.program_points['u_model'] = np.eye(4, dtype=np.float32)
self.program_points['u_view'] = self.__camera.view
self.program_points['u_size'] = 0.3 + 0.8 / self.__camera.zoom_factor
#Some aditional drawing variables/setups
self.__draw_model_transparent = False
self.context.set_clear_color(Color([0.7, 0.7, 0.7, 1.0]))
self.__theta = 0
self.__phi = 0
self.timer = app.Timer('auto', self.on_timer, start=True)
self.activate_zoom()
def __init__(self):
app.Canvas.__init__(self)
# This size is used for comparison with agg (via matplotlib)
self.size = 512, 512 + 2 * 32
self.title = "Markers demo [press space to change marker]"
self.vbo = VertexBuffer(data)
self.view = np.eye(4, dtype=np.float32)
self.model = np.eye(4, dtype=np.float32)
self.projection = ortho(0, self.size[0], 0, self.size[1], -1, 1)
self.programs = [
Program(markers.vert, markers.frag + markers.tailed_arrow),
Program(markers.vert, markers.frag + markers.disc),
Program(markers.vert, markers.frag + markers.diamond),
Program(markers.vert, markers.frag + markers.square),
Program(markers.vert, markers.frag + markers.cross),
Program(markers.vert, markers.frag + markers.arrow),
Program(markers.vert, markers.frag + markers.vbar),
Program(markers.vert, markers.frag + markers.hbar),
Program(markers.vert, markers.frag + markers.clobber),
Program(markers.vert, markers.frag + markers.ring)
]
for program in self.programs:
program.set_vars(self.vbo,
u_antialias=u_antialias,
u_size=1,
u_model=self.model,
u_view=self.view,
u_projection=self.projection)
self.index = 0
self.program = self.programs[self.index]
def __init__(self):
app.Canvas.__init__(self, size=(512, 512), keys='interactive')
self.image = Program(image_vertex, image_fragment, 4)
self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
self.image['vmin'] = +0.0
self.image['vmax'] = +1.0
self.image['cmap'] = 0 # Colormap index to use
self.image['colormaps'] = colormaps
self.image['n_colormaps'] = colormaps.shape[0]
self.image['image'] = idxs.astype('float32')
self.image['image'].interpolation = 'linear'
set_viewport(0, 0, *self.physical_size)
self.lines = Program(lines_vertex, lines_fragment)
self.lines["position"] = np.zeros((4 + 4 + 514 + 514, 2), np.float32)
color = np.zeros((4 + 4 + 514 + 514, 4), np.float32)
color[1:1 + 2, 3] = 0.25
color[5:5 + 2, 3] = 0.25
color[9:9 + 512, 3] = 0.5
color[523:523 + 512, 3] = 0.5
self.lines["color"] = color
set_state(clear_color='white',
blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.show()
def __init__(self):
app.Canvas.__init__(self,
size=(512, 512),
title='Colored cube',
keys='interactive')
# Build cube data
V, I, _ = create_cube()
vertices = VertexBuffer(V)
self.indices = IndexBuffer(I)
# Build program
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
translate(view, 0, 0, -5)
self.program['model'] = model
self.program['view'] = view
self.phi, self.theta = 0, 0
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)
self.timer = app.Timer('auto', self.on_timer, start=True)
def __init__ (self, channels=10,timepoints=10000,srate=1017.25):
super(TSV_TEST_GLOO, self).__init__()
self.n_channels = channels
self.n_timepoints = timepoints
self.srate = srate
self.magrin = 10
self.ticksize = 10
self.height = 0.0
self.width = 0.0
self._is_init = False
self.is_on_draw = False
self._init_data()
# Build program & data
# ----------------------------------------
self.data_pgr = Program(vertex, fragment, count=timepoints)
#self.data_pgr'color'] = [ (1,0,0,1), (0,1,0,1), (0,0,1,1), (1,1,0,1) ]
#self.data_pgr['position'] = [ (-1,-1), (-1,+1), (+1,-1), (+1,+1) ]
#self.program['scale'] = 1.0
self.xgrid_pgr = Program(grid_vertex, grid_fragment)
self.xgrid_pgr['position'] = self.init_xgrid()
self.xgrid_pgr['color'] = np.array([0.0,0.0,0.0,1.0],dtype=np.float32)
self.ygrid_pgr = Program(grid_vertex, grid_fragment)
self.ygrid_pgr['position'] = self.init_ygrid()
self.ygrid_pgr['color'] = np.array([0.50,0.50,0.50,1.0],dtype=np.float32)
def __init__(self):
app.Canvas.__init__(self, title='Grayscott Reaction-Diffusion',
size=(512, 512), keys='interactive')
self.scale = 4
self.comp_size = (256, 256)
comp_w, comp_h = self.comp_size
dt = 1.0
dd = 1.5
species = {
# name : [r_u, r_v, f, k]
'Bacteria 1': [0.16, 0.08, 0.035, 0.065],
'Bacteria 2': [0.14, 0.06, 0.035, 0.065],
'Coral': [0.16, 0.08, 0.060, 0.062],
'Fingerprint': [0.19, 0.05, 0.060, 0.062],
'Spirals': [0.10, 0.10, 0.018, 0.050],
'Spirals Dense': [0.12, 0.08, 0.020, 0.050],
'Spirals Fast': [0.10, 0.16, 0.020, 0.050],
'Unstable': [0.16, 0.08, 0.020, 0.055],
'Worms 1': [0.16, 0.08, 0.050, 0.065],
'Worms 2': [0.16, 0.08, 0.054, 0.063],
'Zebrafish': [0.16, 0.08, 0.035, 0.060]
}
P = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
P[:, :] = species['Unstable']
UV = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
UV[:, :, 0] = 1.0
r = 32
UV[comp_h / 2 - r:comp_h / 2 + r,
comp_w / 2 - r:comp_w / 2 + r, 0] = 0.50
UV[comp_h / 2 - r:comp_h / 2 + r,
comp_w / 2 - r:comp_w / 2 + r, 1] = 0.25
UV += np.random.uniform(0.0, 0.01, (comp_h, comp_w, 4))
UV[:, :, 2] = UV[:, :, 0]
UV[:, :, 3] = UV[:, :, 1]
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["params"] = P
self.compute["texture"] = UV
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dt'] = dt
self.compute['dx'] = 1.0 / comp_w
self.compute['dy'] = 1.0 / comp_h
self.compute['dd'] = dd
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
RenderBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
self._timer = app.Timer('auto', connect=self.update, start=True)
def test_context_sharing():
"""Test context sharing"""
with Canvas() as c1:
vert = VertexShader("uniform vec4 pos;"
"void main (void) {gl_Position = pos;}")
frag = FragmentShader("uniform vec4 pos;"
"void main (void) {gl_FragColor = pos;}")
program = Program(vert, frag)
program['pos'] = [1, 2, 3, 4]
program.activate() # should print
def check():
program.activate()
check_error()
with Canvas() as c2:
# pyglet always shares
if 'pyglet' not in c2.app.backend_name.lower():
assert_raises(RuntimeError, check)
if c1.app.backend_name.lower() in ('glut',):
assert_raises(RuntimeError, Canvas, context=c1.context)
else:
with Canvas(context=c1.context) as c2:
assert c1.context is c2.context # Same context object
check()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, size=(512, 512), title='Rotating quad',
keys='interactive')
self.timer = app.Timer('auto', self.on_timer)
# Build program & data
self.program = Program(vertex, fragment, count=4)
self.program['color'] = [(1, 0, 0, 1), (0, 1, 0, 1),
(0, 0, 1, 1), (1, 1, 0, 1)]
self.program['position'] = [(-1, -1), (-1, +1),
(+1, -1), (+1, +1)]
self.program['theta'] = 0.0
gloo.set_viewport(0, 0, *self.physical_size)
self.clock = 0
self.timer.start()
self.show()
def on_draw(self, event):
gloo.set_clear_color('white')
gloo.clear(color=True)
self.program.draw('triangle_strip')
def on_resize(self, event):
gloo.set_viewport(0, 0, *event.physical_size)
def on_timer(self, event):
self.clock += 0.001 * 1000.0 / 60.
self.program['theta'] = self.clock
self.update()
class Canvas(app.Canvas):
def __init__(self):
self.image = Program(img_vertex, img_fragment, 4)
self.image["position"] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image["texcoord"] = (0, 0), (0, +1), (+1, 0), (+1, +1)
self.image["vmin"] = +0.1
self.image["vmax"] = +0.9
self.image["cmap"] = 0 # Colormap index to use
self.image["colormaps"] = colormaps
self.image["colormaps"].interpolation = "linear"
self.image["colormaps_shape"] = colormaps.shape[1], colormaps.shape[0]
self.image["image"] = I
self.image["image"].interpolation = "linear"
self.image["image_shape"] = I.shape[1], I.shape[0]
app.Canvas.__init__(self, show=True, size=(512, 512), keys="interactive")
def on_initialize(self, event):
set_clear_color("black")
def on_resize(self, event):
width, height = event.size
set_viewport(0, 0, *event.size)
def on_draw(self, event):
clear(color=True, depth=True)
self.image.draw("triangle_strip")
def test_context_sharing():
"""Test context sharing"""
with Canvas() as c1:
vert = "attribute vec4 pos;\nvoid main (void) {gl_Position = pos;}"
frag = "void main (void) {gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);}"
program = Program(vert, frag)
program['pos'] = [(1, 2, 3, 1), (4, 5, 6, 1)]
program.draw('points')
def check():
# Do something to program and see if it worked
program['pos'] = [(1, 2, 3, 1), (4, 5, 6, 1)] # Do command
program.draw('points')
check_error()
# Check while c1 is active
check()
# Check while c2 is active (with different context)
with Canvas() as c2:
# pyglet always shares
if 'pyglet' not in c2.app.backend_name.lower():
assert_raises(Exception, check)
# Check while c2 is active (with *same* context)
with Canvas(shared=c1.context) as c2:
assert c1.context.shared is c2.context.shared # same object
check()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self)
# Create program
self._program = Program(VERT_SHADER, FRAG_SHADER)
# Set uniforms and samplers
self._program['a_position'] = VertexBuffer(positions)
self._program['a_texcoord'] = VertexBuffer(texcoords)
#
self._program['u_texture1'] = Texture2D(im1)
self._program['u_texture2'] = Texture2D(im2)
self._program['u_texture3'] = Texture2D(im3)
def on_initialize(self, event):
gl.glClearColor(1,1,1,1)
def on_resize(self, event):
width, height = event.size
gl.glViewport(0, 0, width, height)
def on_paint(self, event):
# Clear
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Draw shape with texture, nested context
self._program.draw(gl.GL_TRIANGLE_STRIP)
def initialize_renderer():
"""Initialize the OpenGL renderer.
For an OpenGL based renderer this sets up the viewport and creates
the shader programs.
"""
global fbuffer
global fbuffer_prog
global default_prog
fbuffer = FrameBuffer()
vertices = np.array(
[[-1.0, -1.0], [+1.0, -1.0], [-1.0, +1.0], [+1.0, +1.0]], np.float32)
texcoords = np.array([[0.0, 0.0], [1.0, 0.0], [0.0, 1.0], [1.0, 1.0]],
dtype=np.float32)
fbuf_vertices = VertexBuffer(data=vertices)
fbuf_texcoords = VertexBuffer(data=texcoords)
fbuffer_prog = Program(src_fbuffer.vert, src_fbuffer.frag)
fbuffer_prog['texcoord'] = fbuf_texcoords
fbuffer_prog['position'] = fbuf_vertices
default_prog = Program(src_default.vert, src_default.frag)
reset_view()
def __init__(self):
app.Canvas.__init__(self,
size=(512, 512),
title='Textured cube',
keys='interactive')
self.timer = app.Timer('auto', self.on_timer)
# Build cube data
V, I, _ = create_cube()
vertices = VertexBuffer(V)
self.indices = IndexBuffer(I)
# Build program
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
view = translate((0, 0, -5))
model = np.eye(4, dtype=np.float32)
self.program['model'] = model
self.program['view'] = view
self.program['texture'] = checkerboard()
self.activate_zoom()
self.phi, self.theta = 0, 0
# OpenGL initalization
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)
self.timer.start()
self.show()
def __init__(self):
self.use_shaders = True
app.Canvas.__init__(self, size=(512, 512), keys='interactive')
# Note: read as bytes, then decode; py2.6 compat
with open(op.join(this_dir, 'vertex_vispy.glsl'), 'rb') as fid:
vert = fid.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_seed.glsl'), 'rb') as f:
frag_seed = f.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_flood.glsl'), 'rb') as f:
frag_flood = f.read().decode('ASCII')
with open(op.join(this_dir, 'fragment_display.glsl'), 'rb') as f:
frag_display = f.read().decode('ASCII')
self.programs = [
Program(vert, frag_seed),
Program(vert, frag_flood),
Program(vert, frag_display)
]
# Initialize variables
# using two FBs slightly faster than switching on one
self.fbo_to = [FrameBuffer(), FrameBuffer()]
self._setup_textures('shape1.tga')
vtype = np.dtype([('position', 'f4', 2), ('texcoord', 'f4', 2)])
vertices = np.zeros(4, dtype=vtype)
vertices['position'] = [[-1., -1.], [-1., 1.], [1., -1.], [1., 1.]]
vertices['texcoord'] = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]]
vertices = VertexBuffer(vertices)
for program in self.programs:
program.bind(vertices)
self._timer = app.Timer('auto', self.update, start=True)
self.show()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self,
size=(512, 512),
title='Rotating quad',
keys='interactive')
self.timer = app.Timer('auto', self.on_timer)
# Build program & data
self.program = Program(vertex, fragment, count=4)
self.program['color'] = [(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1),
(1, 1, 0, 1)]
self.program['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.program['theta'] = 0.0
self.clock = 0
self.timer.start()
def on_draw(self, event):
gloo.set_clear_color('white')
gloo.clear(color=True)
self.program.draw('triangle_strip')
def on_resize(self, event):
gloo.set_viewport(0, 0, *event.size)
def on_timer(self, event):
self.clock += 0.001 * 1000.0 / 60.
self.program['theta'] = self.clock
self.update()
def set_shaders(self, vertex_shader=None, fragment_shader=None):
#
vs = vertex_shader if vertex_shader else self._vertex_shader
fs = fragment_shader if fragment_shader else self._fragment_shader
self._program = Program(vs, fs, count=4)
#
self._data = np.zeros(4,
dtype=[('a_position', np.float32, 2),
('a_texcoord', np.float32, 2)])
#
self._data['a_texcoord'] = np.array([[0., 1.], [1., 1.], [0., 0.],
[1., 0.]])
#
self._program['u_model'] = np.eye(4, dtype=np.float32)
self._program['u_view'] = np.eye(4, dtype=np.float32)
#
self._coordinate = [0, 0]
self._origin = [0, 0]
#
self._program['texture'] = np.zeros((self._height, self._width),
dtype='uint8')
#
self.apply_magnification()
def __init__(self): super().__init__(src_fbuffer, src_default) self.normal_prog = Program(src_normal.vert, src_normal.frag) self.phong_prog = Program(src_phong.vert, src_phong.frag) self.lookat_matrix = np.identity(4) self.material = BasicMaterial(self.fill_color) # Camera position self.camera_pos = np.zeros(3) # Blinn-Phong Parameters self.ambient = np.array([0.2]*3) self.diffuse = np.array([0.6]*3) self.specular = np.array([0.8]*3) self.shininess = 8 # Lights self.MAX_LIGHTS_PER_CATEGORY = 8 self.ambient_light_color = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 3, np.float32) self.directional_light_dir = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 3, np.float32) self.directional_light_color = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 3, np.float32) self.directional_light_specular = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 3, np.float32) self.point_light_color = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 3, np.float32) self.point_light_pos = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 3, np.float32) self.point_light_specular = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 3, np.float32) self.const_falloff = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 1, np.float32) self.linear_falloff = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 1, np.float32) self.quadratic_falloff = GlslList(self.MAX_LIGHTS_PER_CATEGORY, 1, np.float32) self.curr_linear_falloff, self.curr_quadratic_falloff, self.curr_constant_falloff = 0.0, 0.0, 0.0 self.light_specular = np.array([0.0]*3)
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self)
# Create program
self._program = Program(VERT_SHADER, FRAG_SHADER)
# Set uniforms and samplers
self._program['a_position'] = VertexBuffer(positions)
self._program['a_texcoord'] = VertexBuffer(texcoords)
#
self._program['u_texture1'] = Texture2D(im1)
self._program['u_texture2'] = Texture2D(im2)
self._program['u_texture3'] = Texture2D(im3)
def on_initialize(self, event):
gl.glClearColor(1, 1, 1, 1)
def on_resize(self, event):
width, height = event.size
gl.glViewport(0, 0, width, height)
def on_paint(self, event):
# Clear
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
# Draw shape with texture, nested context
self._program.draw(gl.GL_TRIANGLE_STRIP)
class Canvas(app.Canvas):
def __init__(self):
self.image = Program(img_vertex, img_fragment, 4)
self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
self.image['vmin'] = +0.1
self.image['vmax'] = +0.9
self.image['cmap'] = 0 # Colormap index to use
self.image['colormaps'] = colormaps
self.image['colormaps'].interpolation = 'linear'
self.image['colormaps_shape'] = colormaps.shape[1], colormaps.shape[0]
self.image['image'] = I.astype('float32')
self.image['image'].interpolation = 'linear'
app.Canvas.__init__(self, show=True, size=(512, 512),
keys='interactive')
def on_initialize(self, event):
set_clear_color('black')
def on_resize(self, event):
width, height = event.size
set_viewport(0, 0, *event.size)
def on_draw(self, event):
clear(color=True, depth=True)
self.image.draw('triangle_strip')
def on_initialize(self, event):
# Build cube data
V, F, O = create_cube()
vertices = VertexBuffer(V)
self.faces = IndexBuffer(F)
self.outline = IndexBuffer(O)
# Build view, model, projection & normal
# --------------------------------------
self.view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
translate(self.view, 0, 0, -5)
normal = np.array(np.matrix(np.dot(self.view, model)).I.T)
# Build program
# --------------------------------------
self.program = Program(vertex, fragment)
self.program.bind(vertices)
self.program["u_light_position"] = 2, 2, 2
self.program["u_light_intensity"] = 1, 1, 1
self.program["u_model"] = model
self.program["u_view"] = self.view
self.program["u_normal"] = normal
self.phi, self.theta = 0, 0
# OpenGL initalization
# --------------------------------------
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True,
polygon_offset=(1, 1),
blend_func=('src_alpha', 'one_minus_src_alpha'),
line_width=0.75)
self.timer.start()
def __init__(self):
app.Canvas.__init__(self, size=(512, 512),
keys='interactive')
self.image = Program(image_vertex, image_fragment, 4)
self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
self.image['vmin'] = +0.0
self.image['vmax'] = +1.0
self.image['cmap'] = 0 # Colormap index to use
self.image['colormaps'] = colormaps
self.image['n_colormaps'] = colormaps.shape[0]
self.image['image'] = I.astype('float32')
self.image['image'].interpolation = 'linear'
set_viewport(0, 0, *self.physical_size)
self.lines = Program(lines_vertex, lines_fragment)
self.lines["position"] = np.zeros((4+4+514+514, 2), np.float32)
color = np.zeros((4+4+514+514, 4), np.float32)
color[1:1+2, 3] = 0.25
color[5:5+2, 3] = 0.25
color[9:9+512, 3] = 0.5
color[523:523+512, 3] = 0.5
self.lines["color"] = color
set_state(clear_color='white', blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.show()
def on_initialize(self, event):
self.rho = 0.0
# Build cube data
# --------------------------------------
self.checker = Program(cube_vertex, cube_fragment)
self.checker['texture'] = checkerboard()
self.checker['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.checker['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
# sheet, indices = make_sheet((960, 1080))
# sheet_buffer = VertexBuffer(sheet)
left_eye = Texture2D((960, 1080, 3), interpolation='linear')
self.left_eye_buffer = FrameBuffer(left_eye, RenderBuffer((960, 1080)))
# Build program
# --------------------------------------
self.view = np.eye(4, dtype=np.float32)
self.program = Program(vertex, fragment)
distortion_buffer = VertexBuffer(make_distortion())
self.program.bind(distortion_buffer)
self.program['rotation'] = self.view
self.program['texture'] = left_eye
# OpenGL and Timer initalization
# --------------------------------------
set_state(clear_color=(.3, .3, .35, 1), depth_test=True)
self.timer = app.Timer('auto', connect=self.on_timer, start=True)
self._set_projection(self.size)
def __init__(self):
app.Canvas.__init__(self, size=(512, 512),
keys='interactive')
self.image = Program(img_vertex, img_fragment, 4)
self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
#self.image['vmin'] = +0.1
#self.image['vmax'] = +0.9
self.image['vmin'] = 0.1
self.image['vmax'] = 1.0
self.image['cmap'] = 1 # Colormap index to use
self.image['colormaps'] = colormaps
self.image['colormaps'].interpolation = 'linear'
self.image['colormaps_shape'] = colormaps.shape[1], colormaps.shape[0]
self.image['image'] = I.astype('float32')
self.image['image'].interpolation = 'linear'
set_clear_color('black')
self.timer = app.Timer(0.25, self.on_timer)
self.timer.start()
self.show()
def on_initialize(self, event):
# Build program & data
self.program = Program(vertex, fragment, count=4)
self.program['color'] = [(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1),
(1, 1, 0, 1)]
self.program['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.clock = 0
self.timer.start()
def __init__(self):
app.Canvas.__init__(self, title="Grayscott Reaction-Diffusion", size=(512, 512), keys="interactive")
self.scale = 4
self.comp_size = self.size
comp_w, comp_h = self.comp_size
dt = 1.0
dd = 1.5
species = {
# name : [r_u, r_v, f, k]
"Bacteria 1": [0.16, 0.08, 0.035, 0.065],
"Bacteria 2": [0.14, 0.06, 0.035, 0.065],
"Coral": [0.16, 0.08, 0.060, 0.062],
"Fingerprint": [0.19, 0.05, 0.060, 0.062],
"Spirals": [0.10, 0.10, 0.018, 0.050],
"Spirals Dense": [0.12, 0.08, 0.020, 0.050],
"Spirals Fast": [0.10, 0.16, 0.020, 0.050],
"Unstable": [0.16, 0.08, 0.020, 0.055],
"Worms 1": [0.16, 0.08, 0.050, 0.065],
"Worms 2": [0.16, 0.08, 0.054, 0.063],
"Zebrafish": [0.16, 0.08, 0.035, 0.060],
}
P = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
P[:, :] = species["Unstable"]
UV = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
UV[:, :, 0] = 1.0
r = 32
UV[comp_h / 2 - r : comp_h / 2 + r, comp_w / 2 - r : comp_w / 2 + r, 0] = 0.50
UV[comp_h / 2 - r : comp_h / 2 + r, comp_w / 2 - r : comp_w / 2 + r, 1] = 0.25
UV += np.random.uniform(0.0, 0.01, (comp_h, comp_w, 4))
UV[:, :, 2] = UV[:, :, 0]
UV[:, :, 3] = UV[:, :, 1]
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["params"] = P
self.compute["texture"] = UV
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute["dt"] = dt
self.compute["dx"] = 1.0 / comp_w
self.compute["dy"] = 1.0 / comp_h
self.compute["dd"] = dd
self.compute["pingpong"] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render["pingpong"] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"], RenderBuffer(self.comp_size))
set_state(depth_test=False, clear_color="black")
self._timer = app.Timer("auto", connect=self.update, start=True)
self.show()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self,
size=(750, 750),
title='Textured cube',
keys='interactive')
self.timer = app.Timer('auto', self.on_timer)
self.counter = 0
# Build cube data
V, I, _ = create_cube()
vertices = VertexBuffer(V)
self.indices = IndexBuffer(I)
# Build program
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
view = translate((0, 0, -5))
model = np.eye(4, dtype=np.float32)
self.program['model'] = model
self.program['view'] = view
self.program['texture'] = cam # checkerboard()
self.activate_zoom()
self.phi, self.theta = 0, 0
# OpenGL initalization
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)
self.timer.start()
self.show()
def on_draw(self, event):
gloo.clear(color=True, depth=True)
self.program.draw('triangles', self.indices)
def on_resize(self, event):
self.activate_zoom()
def activate_zoom(self):
gloo.set_viewport(0, 0, *self.physical_size)
projection = perspective(45.0, self.size[0] / float(self.size[1]), 2.0,
10.0)
self.program['projection'] = projection
def on_timer(self, event):
self.counter += 1
print("on_timer", self.counter)
self.theta += .5
self.phi += .5
self.program['model'] = np.dot(rotate(self.theta, (0, 1, 0)),
rotate(self.phi, (0, 1, 0)))
# self.program['texture'] = im if self.counter % 200 else checkerboard()
self.update()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self,
title='Rain [Move mouse]',
size=(512, 512),
keys='interactive')
# Build data
# --------------------------------------
n = 500
self.data = np.zeros(n, [('a_position', np.float32, 2),
('a_fg_color', np.float32, 4),
('a_size', np.float32, 1)])
self.index = 0
self.program = Program(vertex, fragment)
self.vdata = VertexBuffer(self.data)
self.program.bind(self.vdata)
self.program['u_antialias'] = 1.00
self.program['u_linewidth'] = 1.00
self.program['u_model'] = np.eye(4, dtype=np.float32)
self.program['u_view'] = np.eye(4, dtype=np.float32)
self.activate_zoom()
gloo.set_clear_color('white')
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer = app.Timer('auto', self.on_timer, start=True)
self.show()
def on_draw(self, event):
gloo.clear()
self.program.draw('points')
def on_resize(self, event):
self.activate_zoom()
def activate_zoom(self):
gloo.set_viewport(0, 0, *self.physical_size)
projection = ortho(0, self.size[0], 0, self.size[1], -1, +1)
self.program['u_projection'] = projection
def on_timer(self, event):
self.data['a_fg_color'][..., 3] -= 0.01
self.data['a_size'] += 1.0
self.vdata.set_data(self.data)
self.update()
def on_mouse_move(self, event):
x, y = event.pos
h = self.size[1]
self.data['a_position'][self.index] = x, h - y
self.data['a_size'][self.index] = 5
self.data['a_fg_color'][self.index] = 0, 0, 0, 1
self.index = (self.index + 1) % 500
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, title='Rain [Move mouse]',
size=(512, 512), keys='interactive')
# Build data
# --------------------------------------
n = 500
self.data = np.zeros(n, [('a_position', np.float32, 2),
('a_fg_color', np.float32, 4),
('a_size', np.float32, 1)])
self.index = 0
self.program = Program(vertex, fragment)
self.vdata = VertexBuffer(self.data)
self.program.bind(self.vdata)
self.program['u_antialias'] = 1.00
self.program['u_linewidth'] = 1.00
self.program['u_model'] = np.eye(4, dtype=np.float32)
self.program['u_view'] = np.eye(4, dtype=np.float32)
self.activate_zoom()
gloo.set_clear_color('white')
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer = app.Timer('auto', self.on_timer, start=True)
self.show()
def on_draw(self, event):
gloo.clear()
self.program.draw('points')
def on_resize(self, event):
self.activate_zoom()
def activate_zoom(self):
gloo.set_viewport(0, 0, *self.physical_size)
projection = ortho(0, self.size[0], 0,
self.size[1], -1, +1)
self.program['u_projection'] = projection
def on_timer(self, event):
self.data['a_fg_color'][..., 3] -= 0.01
self.data['a_size'] += 1.0
self.vdata.set_data(self.data)
self.update()
def on_mouse_move(self, event):
x, y = event.pos
h = self.size[1]
self.data['a_position'][self.index] = x, h - y
self.data['a_size'][self.index] = 5
self.data['a_fg_color'][self.index] = 0, 0, 0, 1
self.index = (self.index + 1) % 500
def on_initialize(self, event):
self.scale = 4
self.comp_size = (256, 256)
comp_w, comp_h = self.comp_size
dt = 1.0
dd = 1.5
species = {
# name : [r_u, r_v, f, k]
'Bacteria 1': [0.16, 0.08, 0.035, 0.065],
'Bacteria 2': [0.14, 0.06, 0.035, 0.065],
'Coral': [0.16, 0.08, 0.060, 0.062],
'Fingerprint': [0.19, 0.05, 0.060, 0.062],
'Spirals': [0.10, 0.10, 0.018, 0.050],
'Spirals Dense': [0.12, 0.08, 0.020, 0.050],
'Spirals Fast': [0.10, 0.16, 0.020, 0.050],
'Unstable': [0.16, 0.08, 0.020, 0.055],
'Worms 1': [0.16, 0.08, 0.050, 0.065],
'Worms 2': [0.16, 0.08, 0.054, 0.063],
'Zebrafish': [0.16, 0.08, 0.035, 0.060]
}
P = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
P[:, :] = species['Unstable']
UV = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
UV[:, :, 0] = 1.0
r = 32
UV[comp_h / 2 - r:comp_h / 2 + r, comp_w / 2 - r:comp_w / 2 + r,
0] = 0.50
UV[comp_h / 2 - r:comp_h / 2 + r, comp_w / 2 - r:comp_w / 2 + r,
1] = 0.25
UV += np.random.uniform(0.0, 0.01, (comp_h, comp_w, 4))
UV[:, :, 2] = UV[:, :, 0]
UV[:, :, 3] = UV[:, :, 1]
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["params"] = P
self.compute["texture"] = UV
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dt'] = dt
self.compute['dx'] = 1.0 / comp_w
self.compute['dy'] = 1.0 / comp_h
self.compute['dd'] = dd
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
DepthBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
def on_initialize(self, event):
self.scale = 4
self.comp_size = (256, 256)
comp_w, comp_h = self.comp_size
dt = 1.0
dd = 1.5
species = {
# name : [r_u, r_v, f, k]
'Bacteria 1': [0.16, 0.08, 0.035, 0.065],
'Bacteria 2': [0.14, 0.06, 0.035, 0.065],
'Coral': [0.16, 0.08, 0.060, 0.062],
'Fingerprint': [0.19, 0.05, 0.060, 0.062],
'Spirals': [0.10, 0.10, 0.018, 0.050],
'Spirals Dense': [0.12, 0.08, 0.020, 0.050],
'Spirals Fast': [0.10, 0.16, 0.020, 0.050],
'Unstable': [0.16, 0.08, 0.020, 0.055],
'Worms 1': [0.16, 0.08, 0.050, 0.065],
'Worms 2': [0.16, 0.08, 0.054, 0.063],
'Zebrafish': [0.16, 0.08, 0.035, 0.060]
}
P = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
P[:, :] = species['Unstable']
UV = np.zeros((comp_h, comp_w, 4), dtype=np.float32)
UV[:, :, 0] = 1.0
r = 32
UV[comp_h / 2 - r:comp_h / 2 + r,
comp_w / 2 - r:comp_w / 2 + r, 0] = 0.50
UV[comp_h / 2 - r:comp_h / 2 + r,
comp_w / 2 - r:comp_w / 2 + r, 1] = 0.25
UV += np.random.uniform(0.0, 0.01, (comp_h, comp_w, 4))
UV[:, :, 2] = UV[:, :, 0]
UV[:, :, 3] = UV[:, :, 1]
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["params"] = P
self.compute["texture"] = UV
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dt'] = dt
self.compute['dx'] = 1.0 / comp_w
self.compute['dy'] = 1.0 / comp_h
self.compute['dd'] = dd
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
DepthBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
def __init__(self):
app.Canvas.__init__(self,
size=(512, 512),
title='Textured quad',
keys='interactive')
# Build program & data
self.program = Program(vertex, fragment, count=4)
self.program['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.program['texcoord'] = [(0, 0), (1, 0), (0, 1), (1, 1)]
self.program['texture'] = checkerboard()
def test_use_texture3D():
"""Test using a 3D texture"""
vals = [0, 200, 100, 0, 255, 0, 100]
d, h, w = len(vals), 3, 5
data = np.zeros((d, h, w), np.float32)
VERT_SHADER = """
attribute vec2 a_pos;
varying vec2 v_pos;
void main (void)
{
v_pos = a_pos;
gl_Position = vec4(a_pos, 0., 1.);
}
"""
FRAG_SHADER = """
uniform sampler3D u_texture;
varying vec2 v_pos;
uniform float i;
void main()
{
gl_FragColor = texture3D(u_texture,
vec3((v_pos.y+1.)/2., (v_pos.x+1.)/2., i));
gl_FragColor.a = 1.;
}
"""
# populate the depth "slices" with different gray colors in the bottom left
for ii, val in enumerate(vals):
data[ii, :2, :3] = val / 255.
with Canvas(size=(100, 100)) as c:
if not has_pyopengl():
t = Texture3D(data)
assert_raises(ImportError, t.glir.flush, c.context.shared.parser)
return
program = Program(VERT_SHADER, FRAG_SHADER)
program['a_pos'] = [[-1., -1.], [1., -1.], [-1., 1.], [1., 1.]]
tex = Texture3D(data, interpolation='nearest')
assert_equal(tex.width, w)
assert_equal(tex.height, h)
assert_equal(tex.depth, d)
program['u_texture'] = tex
for ii, val in enumerate(vals):
set_viewport(0, 0, w, h)
clear(color='black')
iii = (ii + 0.5) / float(d)
print(ii, iii)
program['i'] = iii
program.draw('triangle_strip')
out = _screenshot()[:, :, 0].astype(int)[::-1]
expected = np.zeros_like(out)
expected[:2, :3] = val
assert_allclose(out, expected, atol=1./255.)
def __init__(self):
app.Canvas.__init__(self,
title="Conway game of life",
size=(512, 512),
keys='interactive')
# Build programs
# --------------
self.comp_size = self.size
size = self.comp_size + (4, )
Z = np.zeros(size, dtype=np.float32)
Z[...] = np.random.randint(0, 2, size)
Z[:256, :256, :] = 0
gun = """
........................O...........
......................O.O...........
............OO......OO............OO
...........O...O....OO............OO
OO........O.....O...OO..............
OO........O...O.OO....O.O...........
..........O.....O.......O...........
...........O...O....................
............OO......................"""
x, y = 0, 0
for i in range(len(gun)):
if gun[i] == '\n':
y += 1
x = 0
elif gun[i] == 'O':
Z[y, x] = 1
x += 1
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["texture"] = Z
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dx'] = 1.0 / size[1]
self.compute['dy'] = 1.0 / size[0]
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
RenderBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def test_use_texture3D():
"""Test using a 3D texture"""
vals = [0, 200, 100, 0, 255, 0, 100]
d, h, w = len(vals), 3, 5
data = np.zeros((d, h, w), np.float32)
VERT_SHADER = """
attribute vec2 a_pos;
varying vec2 v_pos;
void main (void)
{
v_pos = a_pos;
gl_Position = vec4(a_pos, 0., 1.);
}
"""
FRAG_SHADER = """
uniform sampler3D u_texture;
varying vec2 v_pos;
uniform float i;
void main()
{
gl_FragColor = texture3D(u_texture,
vec3((v_pos.y+1.)/2., (v_pos.x+1.)/2., i));
gl_FragColor.a = 1.;
}
"""
# populate the depth "slices" with different gray colors in the bottom left
for ii, val in enumerate(vals):
data[ii, :2, :3] = val / 255.
with Canvas(size=(100, 100)) as c:
if not has_pyopengl():
t = Texture3D(data)
assert_raises(ImportError, t.glir.flush, c.context.shared.parser)
return
program = Program(VERT_SHADER, FRAG_SHADER)
program['a_pos'] = [[-1., -1.], [1., -1.], [-1., 1.], [1., 1.]]
tex = Texture3D(data, interpolation='nearest')
assert_equal(tex.width, w)
assert_equal(tex.height, h)
assert_equal(tex.depth, d)
program['u_texture'] = tex
for ii, val in enumerate(vals):
set_viewport(0, 0, w, h)
clear(color='black')
iii = (ii + 0.5) / float(d)
print(ii, iii)
program['i'] = iii
program.draw('triangle_strip')
out = _screenshot()[:, :, 0].astype(int)[::-1]
expected = np.zeros_like(out)
expected[:2, :3] = val
assert_allclose(out, expected, atol=1. / 255.)
def __init__(self):
app.Canvas.__init__(self,
size=(512, 512),
title='Colored quad',
keys='interactive')
# Build program & data
self.program = Program(vertex, fragment, count=4)
self.program['color'] = [(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1),
(1, 1, 0, 1)]
self.program['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
def __init__(self):
app.Canvas.__init__(self)
# Time
self._t = time.time()
self._pos = 0.0, 0.0
self._button = None
# Create program
self.program = Program(VERT_SHADER, FRAG_SHADER)
self.program['color'] = VertexBuffer(particles['color'], client=True)
self.program['size'] = VertexBuffer(particles['size'], client=True)
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, size=(512, 512),
keys='interactive')
self.image = Program(img_vertex, img_fragment, 4)
self.image['position'] = (-1, -1), (-1, +1), (+1, -1), (+1, +1)
self.image['texcoord'] = (0, 0), (0, +1), (+1, 0), (+1, +1)
#self.image['vmin'] = +0.1
#self.image['vmax'] = +0.9
self.image['vmin'] = 0.1
self.image['vmax'] = 1.0
self.image['cmap'] = 1 # Colormap index to use
self.image['colormaps'] = colormaps
self.image['colormaps'].interpolation = 'linear'
self.image['colormaps_shape'] = colormaps.shape[1], colormaps.shape[0]
self.image['image'] = I.astype('float32')
self.image['image'].interpolation = 'linear'
set_clear_color('black')
self.timer = app.Timer(0.25, self.on_timer)
self.timer.start()
self.show()
def on_resize(self, event):
width, height = event.physical_size
set_viewport(0, 0, *event.physical_size)
def on_draw(self, event):
clear(color=True, depth=True)
self.image.draw('triangle_strip')
def on_timer(self, event):
#self.clock += 0.001 * 1000.0 / 60.
#self.program['theta'] = self.clock
global I
psi=iterate(psi)
I=abs(psi[0])
self.I = I
#print psi
self.image['image'] = I.astype('float32')
self.update()
#self.timer.stop()
def on_key_press(self, ev):
if ev.key.name == 'Space':
if self.timer.running:
self.timer.stop()
else:
self.timer.start()
def __init__(self):
app.Canvas.__init__(self,
size=(800, 800),
title='Colored quad',
keys='interactive')
self.program = Program(vertex, fragment, count=4)
self.program['color'] = [(1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 1, 1),
(1, 1, 0, 1)]
self.program['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
gloo.set_viewport(0, 0, *self.physical_size)
self.show()
def __init__(self):
app.Canvas.__init__(self, title="Conway game of life",
size=(512, 512), keys='interactive')
# Build programs
# --------------
self.comp_size = self.size
size = self.comp_size + (4,)
Z = np.zeros(size, dtype=np.float32)
Z[...] = np.random.randint(0, 2, size)
Z[:256, :256, :] = 0
gun = """
........................O...........
......................O.O...........
............OO......OO............OO
...........O...O....OO............OO
OO........O.....O...OO..............
OO........O...O.OO....O.O...........
..........O.....O.......O...........
...........O...O....................
............OO......................"""
x, y = 0, 0
for i in range(len(gun)):
if gun[i] == '\n':
y += 1
x = 0
elif gun[i] == 'O':
Z[y, x] = 1
x += 1
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["texture"] = Z
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dx'] = 1.0 / size[1]
self.compute['dy'] = 1.0 / size[0]
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
RenderBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
self._timer = app.Timer('auto', connect=self.update, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self)
# Create program
self._program = Program(VERT_SHADER, FRAG_SHADER)
# Set uniforms and samplers
self._program['a_position'] = VertexBuffer(positions)
self._program['a_texcoord'] = VertexBuffer(texcoords)
#
self._program['u_texture1'] = Texture2D(im1)
self._program['u_texture2'] = Texture2D(im2)
self._program['u_texture3'] = Texture2D(im3)
def reset_view(self):
self.viewport = (
0,
0,
int(builtins.width * builtins.pixel_x_density),
int(builtins.height * builtins.pixel_y_density),
)
self.texture_viewport = (
0,
0,
builtins.width,
builtins.height,
)
gloo.set_viewport(*self.viewport) # pylint: disable=no-member
cz = (builtins.height / 2) / math.tan(math.radians(30))
self.projection_matrix = matrix.perspective_matrix(
math.radians(60),
builtins.width / builtins.height,
0.1 * cz,
10 * cz
)
self.modelview_matrix = matrix.translation_matrix(-builtins.width / 2,
builtins.height / 2,
-cz)
self.modelview_matrix = self.modelview_matrix.dot(
matrix.scale_transform(1, -1, 1))
self.transform_matrix = np.identity(4)
self.default_prog['modelview'] = self.modelview_matrix.T.flatten()
self.default_prog['projection'] = self.projection_matrix.T.flatten()
self.texture_prog['modelview'] = self.modelview_matrix.T.flatten()
self.texture_prog['projection'] = self.projection_matrix.T.flatten()
self.line_prog = Program(src_line.vert, src_line.frag)
self.line_prog['modelview'] = self.modelview_matrix.T.flatten()
self.line_prog['projection'] = self.projection_matrix.T.flatten()
self.line_prog["height"] = builtins.height
self.fbuffer_tex_front = Texture2D(
(builtins.height, builtins.width, 3))
self.fbuffer_tex_back = Texture2D((builtins.height, builtins.width, 3))
for buf in [self.fbuffer_tex_front, self.fbuffer_tex_back]:
self.fbuffer.color_buffer = buf
with self.fbuffer:
self.clear()
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, size=(512, 512), title='Textured cube',
keys='interactive')
self.timer = app.Timer('auto', self.on_timer)
# Build cube data
V, I, _ = create_cube()
vertices = VertexBuffer(V)
self.indices = IndexBuffer(I)
# Build program
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
view = translate((0, 0, -5))
model = np.eye(4, dtype=np.float32)
self.program['model'] = model
self.program['view'] = view
self.program['texture'] = checkerboard()
self.activate_zoom()
self.phi, self.theta = 0, 0
# OpenGL initalization
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)
self.timer.start()
self.show()
def on_draw(self, event):
gloo.clear(color=True, depth=True)
self.program.draw('triangles', self.indices)
def on_resize(self, event):
self.activate_zoom()
def activate_zoom(self):
gloo.set_viewport(0, 0, *self.physical_size)
projection = perspective(45.0, self.size[0] / float(self.size[1]),
2.0, 10.0)
self.program['projection'] = projection
def on_timer(self, event):
self.theta += .5
self.phi += .5
self.program['model'] = np.dot(rotate(self.theta, (0, 0, 1)),
rotate(self.phi, (0, 1, 0)))
self.update()
def __init__(self):
vertices, indices, _ = create_cube()
vertices = VertexBuffer(vertices)
self.indices = IndexBuffer(indices)
self.program = Program(self.cube_vertex, self.cube_fragment)
self.model = np.eye(4)
self.view = np.eye(4)
self.program.bind(vertices)
self.program['texture'] = utils.checkerboard()
self.program['texture'].interpolation = 'linear'
self.program['model'] = self.model
self.program['view'] = self.view
class GpaphicBlueprint:
def __init__(self):
self.kind = ''
self._color = (0, 0, 0)
self._program = None
self._indices = None
self._mesh = None
def getProgram(self):
return self._program
def getIndices(self):
return self._indices
def setColor(self, newColor):
'''
Mit dieser Methode koennen andere Klassen die Farb-Uniform des _programs setzen.
Parameter: newColor
Rueckgabewerte: -
'''
self._color = newColor
self._program['color'] = self._color
def buildProgram(self):
'''
In dieser Methode wird das Programm samt Indices einer Kugel errechnet. Das Ganze wird mithilfe der
Bibliothek vispy.gloo gemacht.
Parameter: -
Rueckgabewerte: -
'''
vertices = np.zeros(self._mesh.getVertices().shape[0],
[("position", np.float32, 3)])
vertices["position"] = self._mesh.getVertices()
vertices = VertexBuffer(vertices)
indices = self._mesh.getIndices()
self._indices = IndexBuffer(indices)
self._program = Program(vertex, fragment)
self._program.bind(vertices)
self._program['color'] = self._color
self._program['model'] = None
self._program['view'] = None
self._program['drawHorizon'] = -3
def on_initialize(self, event):
# Build cube data
# --------------------------------------
texcoord = [(0, 0), (0, 1), (1, 0), (1, 1)]
vertices = [(-2, -1, 0), (-2, +1, 0), (+2, -1, 0), (+2, +1, 0)]
vertices = VertexBuffer(vertices)
camera_pitch = 0.0 # Degrees
self.rotate = [camera_pitch, 0, 0]
self.translate = [0, 0, -3]
# Build program
# --------------------------------------
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
scale(model, 1, 1, 1)
self.phi = 0
self.cube = Program(cube_vertex, cube_fragment)
self.cube['position'] = vertices
# 4640 x 2256
imtex = cv2.imread(os.path.join(img_path, 'stage.jpg'))
self.cube['texcoord'] = texcoord
self.cube["texture"] = np.uint8(np.clip(imtex + np.random.randint(-60, 20, size=imtex.shape), 0, 255)) + 5
self.cube["texture"].interpolation = 'linear'
self.cube['model'] = model
self.cube['view'] = view
color = Texture2D((640, 640, 3), interpolation='linear')
self.framebuffer = FrameBuffer(color, RenderBuffer((640, 640)))
self.quad = Program(quad_vertex, quad_fragment)
self.quad['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.quad['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.quad['texture'] = color
self.objects = [self.cube]
# OpenGL and Timer initalization
# --------------------------------------
set_state(clear_color=(.3, .3, .35, 1), depth_test=True)
self.timer = app.Timer('auto', connect=self.on_timer, start=True)
self.pub_timer = app.Timer(0.1, connect=self.send_ros_img, start=True)
self._set_projection(self.size)
class Canvas(app.Canvas):
def __init__(self):
app.Canvas.__init__(self, size=(512, 512), title='Textured cube',
close_keys='escape')
self.timer = app.Timer(1./60., self.on_timer)
def on_initialize(self, event):
# Build cube data
V, I, _ = cube()
vertices = VertexBuffer(V)
self.indices = IndexBuffer(I)
# Build program
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
translate(view, 0, 0, -5)
self.program['model'] = model
self.program['view'] = view
self.program['texture'] = checkerboard()
self.phi, self.theta = 0, 0
# OpenGL initalization
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)
self.timer.start()
def on_draw(self, event):
gloo.clear(color=True, depth=True)
self.program.draw('triangles', self.indices)
def on_resize(self, event):
gloo.set_viewport(0, 0, *event.size)
projection = perspective(45.0, event.size[0] / float(event.size[1]),
2.0, 10.0)
self.program['projection'] = projection
def on_timer(self, event):
self.theta += .5
self.phi += .5
model = np.eye(4, dtype=np.float32)
rotate(model, self.theta, 0, 0, 1)
rotate(model, self.phi, 0, 1, 0)
self.program['model'] = model
self.update()
def on_initialize(self, event):
# Build cube data
V, F, O = create_cube()
vertices = VertexBuffer(V)
self.faces = IndexBuffer(F)
self.outline = IndexBuffer(O)
# Build view, model, projection & normal
# --------------------------------------
self.view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
translate(self.view, 0, 0, -5)
normal = np.array(np.matrix(np.dot(self.view, model)).I.T)
# Build program
# --------------------------------------
self.program = Program(vertex, fragment)
self.program.bind(vertices)
self.program["u_light_position"] = 2, 2, 2
self.program["u_light_intensity"] = 1, 1, 1
self.program["u_model"] = model
self.program["u_view"] = self.view
self.program["u_normal"] = normal
self.phi, self.theta = 0, 0
# OpenGL initalization
# --------------------------------------
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True,
polygon_offset=(1, 1),
blend_func=('src_alpha', 'one_minus_src_alpha'),
line_width=0.75)
self.timer.start()
def __init__(self):
app.Canvas.__init__(self, title='Rain [Move mouse]',
size=(512, 512), keys='interactive')
# Build data
# --------------------------------------
n = 500
self.data = np.zeros(n, [('a_position', np.float32, 2),
('a_fg_color', np.float32, 4),
('a_size', np.float32, 1)])
self.index = 0
self.program = Program(vertex, fragment)
self.vdata = VertexBuffer(self.data)
self.program.bind(self.vdata)
self.program['u_antialias'] = 1.00
self.program['u_linewidth'] = 1.00
self.program['u_model'] = np.eye(4, dtype=np.float32)
self.program['u_view'] = np.eye(4, dtype=np.float32)
self.activate_zoom()
gloo.set_clear_color('white')
gloo.set_state(blend=True,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer = app.Timer('auto', self.on_timer, start=True)
self.show()
def __init__(self):
app.Canvas.__init__(self, size=(512, 512), title='Textured cube',
keys='interactive')
self.timer = app.Timer('auto', self.on_timer)
# Build cube data
V, I, _ = create_cube()
vertices = VertexBuffer(V)
self.indices = IndexBuffer(I)
# Build program
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
translate(view, 0, 0, -5)
self.program['model'] = model
self.program['view'] = view
self.program['texture'] = checkerboard()
self.phi, self.theta = 0, 0
# OpenGL initalization
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)
self.timer.start()
def on_initialize(self, event):
# Build cube data
V, I, O = create_cube()
vertices = VertexBuffer(V)
self.faces = IndexBuffer(I)
self.outline = IndexBuffer(O)
# Build program
# --------------------------------------
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
# --------------------------------------
view = np.eye(4, dtype=np.float32)
model = np.eye(4, dtype=np.float32)
translate(view, 0, 0, -5)
self.program['u_model'] = model
self.program['u_view'] = view
self.phi, self.theta = 0, 0
# OpenGL initalization
# --------------------------------------
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True,
polygon_offset=(1, 1), line_width=0.75,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer.start()
def __init__(self):
app.Canvas.__init__(self, size=(512, 512), title='Colored cube',
keys='interactive')
# Build cube data
V, I, _ = create_cube()
vertices = VertexBuffer(V)
self.indices = IndexBuffer(I)
# Build program
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
view = translate((0, 0, -5))
model = np.eye(4, dtype=np.float32)
self.program['model'] = model
self.program['view'] = view
self.phi, self.theta = 0, 0
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True)
self.activate_zoom()
self.timer = app.Timer('auto', self.on_timer, start=True)
self.show()
def __init__(self, *args, **kwargs):
'''Drawable(*args, **kwargs) -> Drawable
Everything is tracked internally, different drawables will handle things differently
Inherit from this for all drawables.
Inheriting:
You must define a make_mesh, make_shaders, and draw method.
If you do not make shaders, you will get a default
If you do not make a mesh, you'll get a square that takes up the screen
'''
self.model = np.eye(4)
self.view = np.eye(4)
self.projection = np.eye(4)
self.mesh = self.make_mesh()
self.vert_shader, self.frag_shader = self.make_shaders()
self.program = Program(self.vert_shader, self.frag_shader)
self.program.bind(VertexBuffer(self.mesh))
if hasattr(self, make_texture):
self.texture = self.make_texture()
assert isinstance(self.texture, Texture2D), "Texture passed is not a texture!"
self.program['texture'] = self.texture
cube["texture"].interpolation = 'linear'
def on_initialize(self, event):
# Build program & data
self.program = Program(vertex, fragment, count=4)
self.program['position'] = [(-1, -1), (-1, +1),
(+1, -1), (+1, +1)]
self.program['texcoord'] = [(0, 0), (1, 0), (0, 1), (1, 1)]
self.program['texture'] = checkerboard()
def __init__(self):
app.Canvas.__init__(self, size=(512, 512), title='Rotating cube',
keys='interactive')
self.timer = app.Timer('auto', self.on_timer)
# Build cube data
V, I, outline = create_cube()
vertices = VertexBuffer(V)
self.faces = IndexBuffer(I)
self.outline = IndexBuffer(outline)
# Build program
# --------------------------------------
self.program = Program(vertex, fragment)
self.program.bind(vertices)
# Build view, model, projection & normal
# --------------------------------------
view = translate((0, 0, -5))
model = np.eye(4, dtype=np.float32)
self.program['u_model'] = model
self.program['u_view'] = view
self.phi, self.theta = 0, 0
self.activate_zoom()
# OpenGL initialization
# --------------------------------------
gloo.set_state(clear_color=(0.30, 0.30, 0.35, 1.00), depth_test=True,
polygon_offset=(1, 1), line_width=0.75,
blend_func=('src_alpha', 'one_minus_src_alpha'))
self.timer.start()
self.show()
def on_initialize(self, event):
# Build program & data
self.program = Program(vertex, fragment, count=4)
self.program['color'] = [(1, 0, 0, 1), (0, 1, 0, 1),
(0, 0, 1, 1), (1, 1, 0, 1)]
self.program['position'] = [(-1, -1), (-1, +1),
(+1, -1), (+1, +1)]
def __init__(self):
'''Map drawable - contains the goddamn map
'''
self.projection = np.eye(4)
self.view = np.eye(4)
self.model = scale(np.eye(4), 0.6)
orientation_vector = (0, 1, 0)
unit_orientation_angle = np.array(orientation_vector) / np.linalg.norm(orientation_vector)
rotate(self.model, -30, *unit_orientation_angle)
translate(self.model, -2.2, -2.4, -9)
height, width = 5.0, 5.0 # Meters
# Add texture coordinates
# Rectangle of height height
self.vertices = np.array([
[-width / 2, -height / 2, 0],
[ width / 2, -height / 2, 0],
[ width / 2, height / 2, 0],
[-width / 2, height / 2, 0],
], dtype=np.float32)
self.tex_coords = np.array([
[0, 1],
[1, 1],
[1, 0],
[0, 0],
], dtype=np.float32)
self.indices = IndexBuffer([
0, 1, 2,
2, 3, 0,
])
###### TESTING
self.position_lla = self.ecef2llh((738575.65, -5498374.10, 3136355.42))
###### TESTING
self.map, self.ranges = self.cache_map(self.position_lla[:2])
self.map, self.ranges = self.get_map(self.position_lla[:2])
self.program = Program(self.frame_vertex_shader, self.frame_frag_shader)
default_map_transform = np.eye(4)
self.program['vertex_position'] = self.vertices
self.program['default_texcoord'] = self.tex_coords
self.program['zoom'] = 1
self.program['view'] = self.view
self.program['model'] = self.model
self.program['projection'] = self.projection
self.program['map_transform'] = default_map_transform
self.program['map_center'] = self.position_lla[:2]
self.program['map_texture'] = self.map
self.program['corners'] = self.ranges
self.program['user_position'] = self.position_lla[:2]
self.program['hide'] = 0
class Example(Drawable):
'''Draw a cube'''
cube_vertex = """
#version 120
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
attribute vec3 position;
attribute vec2 texcoord;
varying vec2 v_texcoord;
void main()
{
gl_Position = projection * view * model * vec4(position, 1.0);
v_texcoord = texcoord;
}
"""
cube_fragment = """
#version 120
uniform sampler2D texture;
varying vec2 v_texcoord;
void main()
{
float r = texture2D(texture, v_texcoord).r;
gl_FragColor = vec4(0, r, r, 1);
}
"""
def __init__(self):
vertices, indices, _ = create_cube()
vertices = VertexBuffer(vertices)
self.indices = IndexBuffer(indices)
self.program = Program(self.cube_vertex, self.cube_fragment)
self.model = np.eye(4)
self.view = np.eye(4)
self.program.bind(vertices)
self.program['texture'] = utils.checkerboard()
self.program['texture'].interpolation = 'linear'
self.program['model'] = self.model
self.program['view'] = self.view
def draw(self):
self.program.draw('triangles', self.indices)
def on_initialize(self, event):
# Build programs
# --------------
self.comp_size = (512, 512)
size = self.comp_size + (4,)
Z = np.zeros(size, dtype=np.float32)
Z[...] = np.random.randint(0, 2, size)
Z[:256, :256, :] = 0
gun = """
........................O...........
......................O.O...........
............OO......OO............OO
...........O...O....OO............OO
OO........O.....O...OO..............
OO........O...O.OO....O.O...........
..........O.....O.......O...........
...........O...O....................
............OO......................"""
x, y = 0, 0
for i in range(len(gun)):
if gun[i] == '\n':
y += 1
x = 0
elif gun[i] == 'O':
Z[y, x] = 1
x += 1
self.pingpong = 1
self.compute = Program(compute_vertex, compute_fragment, 4)
self.compute["texture"] = Z
self.compute["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.compute["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.compute['dx'] = 1.0 / size[1]
self.compute['dy'] = 1.0 / size[0]
self.compute['pingpong'] = self.pingpong
self.render = Program(render_vertex, render_fragment, 4)
self.render["position"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.render["texcoord"] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.render["texture"] = self.compute["texture"]
self.render['pingpong'] = self.pingpong
self.fbo = FrameBuffer(self.compute["texture"],
DepthBuffer(self.comp_size))
set_state(depth_test=False, clear_color='black')
