def on_draw(self, event): blending_mode = blending_modes[self.blending_mode_index] render.set_blending(blending_mode) gloo.set_clear_color((0.30, 0.30, 0.35, 1.00)) gloo.clear(color=True, depth=True) w, h = self.physical_size if self.model is None: aspect = w / h v = views[self.view_index] if v == "perspective": self.model, self.view, self.projection = render.create_transform_perspective(aspect=aspect) else: self.model, self.view, self.projection = render.create_transform_ortho(aspect=aspect, view=v, fake_ortho=True) rotation = self.rotation_index if self.run_phi: self.phi += 0.2 actual_model = render.apply_model_rotation(self.model, rotation=0, phi=self.phi) current_variant = self.variants[self.variant_index] current_mode = modes[self.mode_index] self.glblock.render(current_variant, actual_model, self.view, self.projection, rotation=rotation, mode=current_mode) v = lambda *a: np.array(a, dtype=np.float32) render.draw_line(v(0, 0, 0), v(10, 0, 0), actual_model, self.view, self.projection, color=(1, 0, 0, 1)) render.draw_line(v(0, 0, 0), v(0, 10, 0), actual_model, self.view, self.projection, color=(0, 1, 0, 1)) render.draw_line(v(0, 0, 0), v(0, 0, 10), actual_model, self.view, self.projection, color=(0, 0, 1, 1))
def __init__(self, parent=None): scene.SceneCanvas.__init__(self, parent=parent) self.parent = parent self.has_redrawn = True self.data = None self.data_changed = False self.data_program = gloo.Program(data_vert, data_frag) path = os.path.dirname(os.path.realpath(__file__)) path = os.path.join(path, 'colormaps/transform/Seismic.npy') self.colormap = Colormap(path) self.colormap_program = gloo.Program(colormap_vert, colormap_frag) # horizontal / vertical / diagonal self.line_type = None # x for a vertical line, y for a horizontal line self.line_coord = None # start and end points self.line_positions = [(0, 0), (0, 0)] self.linecut_program = gloo.Program(linecut_vert, linecut_frag) self.linecut_program['a_position'] = self.line_positions gloo.set_clear_color((1, 1, 1, 1))
def draw_depth(self): program = gloo.Program(_depth_vertex_code, _depth_fragment_code) program.bind(self.vertex_buffer) program['u_mv'] = _compute_model_view(self.mat_model, self.mat_view) program['u_mvp'] = _compute_model_view_proj(self.mat_model, self.mat_view, self.mat_proj) # Texture where we render the scene render_tex = gloo.Texture2D(shape=self.shape + (4, ), format=gl.GL_RGBA, internalformat=gl.GL_RGBA32F) # Frame buffer object fbo = gloo.FrameBuffer(render_tex, gloo.RenderBuffer(self.shape, format='depth')) with fbo: gloo.set_state(depth_test=True) gloo.set_state(cull_face=True) gloo.set_cull_face('back') # Back-facing polygons will be culled gloo.set_clear_color((0.0, 0.0, 0.0, 0.0)) gloo.clear(color=True, depth=True) gloo.set_viewport(0, 0, *self.size) program.draw('triangles', self.index_buffer) # Retrieve the contents of the FBO texture self.depth = self.read_fbo_color_rgba32f(fbo) self.depth = self.depth[:, :, 0] # Depth is saved in the first channel
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=((W * 5), (H * 5))) self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.texture = gloo.Texture2D(I, interpolation='linear') self.program['u_texture'] = self.texture self.program.bind(gloo.VertexBuffer(data)) self.view = np.eye(4, dtype=np.float32) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.program['u_model'] = self.model self.program['u_view'] = self.view self.projection = ortho(0, W, 0, H, -1, 1) self.program['u_projection'] = self.projection gloo.set_clear_color('white') self._timer = app.Timer('auto', connect=self.update, start=True) self.sim_is_initialized = False self.sim = None self.show()
def __init__(self, **kwargs): app.Canvas.__init__(self, **kwargs) self.geometry = 0, 0, 400, 400 mesh = create_sphere(10, 10, radius=2.) vertices = mesh.get_vertices() tris = mesh.get_faces() data=vertices[:, 2] self.filled_buf = gloo.IndexBuffer(tris) self.program = ModularProgram(VERT_CODE, FRAG_CODE) colormap = get_colormap('autumn') self.color = Function(colormap.glsl_map) self.program.frag['color'] = self.color('floor(v_value*10.+0.5)/10.') # Set attributes self.program['a_position'] = gloo.VertexBuffer(vertices) self.program['a_value'] = gloo.VertexBuffer(normalize(data, data.min(), data.max())) # Handle transformations self.init_transforms() gloo.set_clear_color((1, 1, 1, 1)) gloo.set_state(depth_test=True) self._timer = app.Timer('auto', connect=self.update_transforms) self._timer.start()
def __init__(self, size, cam): app.Canvas.__init__(self, show=False, size=size) self.shape = (size[1], size[0]) self.yz_flip = np.eye(4, dtype=np.float32) self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1 self.set_cam(cam) # Set up shader programs self.program_col = gloo.Program(_vertex_code_colored, _fragment_code_colored) self.program_bbox = gloo.Program(_vertex_code_colored, _fragment_code_bbox) self.program_tex = gloo.Program(_vertex_code_textured, _fragment_code_textured) self.program_bg = gloo.Program(_vertex_code_background, _fragment_code_background) # Texture where we render the color/depth and its FBO self.col_tex = gloo.Texture2D(shape=self.shape + (3,)) self.fbo = gloo.FrameBuffer(self.col_tex, gloo.RenderBuffer(self.shape)) self.fbo.activate() gloo.set_state(depth_test=True, blend=False, cull_face=True) gl.glEnable(gl.GL_LINE_SMOOTH) gloo.set_clear_color((0.0, 0.0, 0.0)) gloo.set_viewport(0, 0, *self.size) # Set up background render quad in NDC quad = [[-1, -1], [1, -1], [1, 1], [-1, 1]] tex = [[0, 1], [1, 1], [1, 0], [0, 0]] vertices_type = [('a_position', np.float32, 2), ('a_texcoord', np.float32, 2)] collated = np.asarray(list(zip(quad, tex)), vertices_type) self.bg_vbuffer = gloo.VertexBuffer(collated) self.bg_ibuffer = gloo.IndexBuffer([0, 1, 2, 0, 2, 3])
def __init__(self, size, cam): config = dict(red_size=8, green_size=8, blue_size=8, alpha_size=8, depth_size=24, stencil_size=0, double_buffer=True, stereo=False, samples=0) app.Canvas.__init__(self, show=False, size=size, config=config) self.shape = (size[1], size[0]) self.yz_flip = np.eye(4, dtype=np.float32) self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1 self.set_cam(cam) # Set up shader programs self.program_col = gloo.Program(_vertex_code_colored, _fragment_code_colored) self.program_tex = gloo.Program(_vertex_code_textured, _fragment_code_textured) # Texture where we render the color/depth and its FBO self.col_tex = gloo.Texture2D(shape=self.shape + (3, )) self.fbo = gloo.FrameBuffer(self.col_tex, gloo.RenderBuffer(self.shape)) self.fbo.activate() gloo.set_state(depth_test=True, blend=False, cull_face=True) gl.glEnable(gl.GL_LINE_SMOOTH) gloo.set_clear_color((0.0, 0.0, 0.0)) gloo.set_viewport(0, 0, *self.size)
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, keys='interactive') self.size = W * 5, H * 5 self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.texture = gloo.Texture3D(I, interpolation='nearest', wrapping='clamp_to_edge') self.program['u_texture'] = self.texture self.program['i'] = 0.0 self.program.bind(gloo.VertexBuffer(data)) self.view = np.eye(4, dtype=np.float32) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.program['u_model'] = self.model self.program['u_view'] = self.view self.projection = ortho(0, W, 0, H, -1, 1) self.program['u_projection'] = self.projection self.i = 0 gloo.set_clear_color('white') self._timer = app.Timer('auto', connect=self.on_timer, start=True)
def __init__(self): app.Canvas.__init__(self, size=(1024, 1024), title='Skybox example', keys='interactive') self.cubeSize = 10 self.pressed = False self.azimuth = pi / 2.0 self.elevation = pi / 2.0 self.distanceMin = 1 self.distanceMax = 50 self.distance = 30 self.sensitivity = 5.0 self.view = getView(self.azimuth, self.elevation, self.distance) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.program = gloo.Program(vertex_shader, fragment_shader, count=24) self.program['a_position'] = faces*self.cubeSize self.program['a_texcoord'] = faces self.program['a_texture'] = gloo.TextureCube(texture, interpolation='linear') self.program['u_model'] = self.model self.program['u_view'] = self.view gloo.set_viewport(0, 0, *self.physical_size) self.projection = perspective(60.0, self.size[0] / float(self.size[1]), 1.0, 100.0) self.program['u_projection'] = self.projection gl.glEnable(gl.GL_DEPTH_TEST) gloo.set_clear_color('black') self.show()
def __init__(self): app.Canvas.__init__(self, keys='interactive') self.size = 800, 600 self.vertices, self.filled, self.outline = cube() self.filled_buf = gloo.IndexBuffer(self.filled) self.outline_buf = gloo.IndexBuffer(self.outline) self.program = gloo.Program(vert, frag) self.program.bind(gloo.VertexBuffer(self.vertices)) self.view = np.eye(4, dtype=np.float32) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) translate(self.view, 0, 0, -5) self.program['u_model'] = self.model self.program['u_view'] = self.view self.theta = 0 self.phi = 0 gloo.set_clear_color('white') gloo.set_state('opaque') gloo.set_polygon_offset(1, 1) self._timer = app.Timer('auto', connect=self.on_timer, start=True)
def __init__(self, *args, **kwargs): app.Canvas.__init__(self, *args, **kwargs) self.program = gloo.Program(self.read_shader('1.vert'), self.read_shader('3.frag')) # Fill screen with single quad, fragment shader does all the real work self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)] self._starttime = time.time() self.program['time'] = 0 self.program['cameraPos'] = (0.0, 3.0, -6.0) self.program['cameraLookat'] = (0.0, -0.85, 0.5) self.program['lightDir'] = normalize(np.array((-1, -1, -1))) # needs to be normalized self.program['lightColour'] = (1.4, 3.0, 0.3) self.program['diffuse'] = (0.27, 0.27, 0.27) self.program['ambientFactor'] = 0.45 self.program['rotateWorld'] = True self.program['scale'] = 1.5 self.program['offset'] = 1.8 self.program['cubeWidth'] = 1 self.program['angleA'] = 1 self.program['angleB'] = 1 self.apply_zoom() gloo.set_clear_color(color='black') self._timer = app.Timer('auto', connect=self.update, start=True) self.show()
def __init__(self, emulate3d=True): app.Canvas.__init__(self, keys='interactive', size=((W*5), (H*5))) if emulate3d: tex_cls = gloo.TextureEmulated3D else: tex_cls = gloo.Texture3D self.texture = tex_cls(img_array, interpolation='nearest', wrapping='clamp_to_edge') self.program = ModularProgram(VERT_SHADER, FRAG_SHADER) self.program.frag['sampler_type'] = self.texture.glsl_sampler_type self.program.frag['sample'] = self.texture.glsl_sample self.program['u_texture'] = self.texture self.program['i'] = 0.0 self.program.bind(gloo.VertexBuffer(data)) self.view = np.eye(4, dtype=np.float32) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.program['u_model'] = self.model self.program['u_view'] = self.view self.projection = ortho(0, W, 0, H, -1, 1) self.program['u_projection'] = self.projection self.i = 0 gloo.set_clear_color('white') self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.show()
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 600)) self.vertices, self.filled, self.outline = cube() self.filled_buf = gloo.IndexBuffer(self.filled) self.outline_buf = gloo.IndexBuffer(self.outline) self.program = gloo.Program(vert, frag) self.program.bind(gloo.VertexBuffer(self.vertices)) self.view = translate((0, 0, -5)) self.model = np.eye(4, dtype=np.float32) gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1]) self.projection = perspective(45.0, self.size[0] / float(self.size[1]), 2.0, 10.0) self.program['u_projection'] = self.projection self.program['u_model'] = self.model self.program['u_view'] = self.view self.theta = 0 self.phi = 0 gloo.set_clear_color('white') gloo.set_state('opaque') gloo.set_polygon_offset(1, 1) self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.show()
def draw_color(self): program = gloo.Program(_color_vertex_code, _color_fragment_code) program.bind(self.vertex_buffer) program['u_light_eye_pos'] = [0, 0, 0] program['u_light_ambient_w'] = self.ambient_weight program['u_mv'] = _compute_model_view(self.mat_model, self.mat_view) # program['u_nm'] = compute_normal_matrix(self.model, self.view) program['u_mvp'] = _compute_model_view_proj(self.mat_model, self.mat_view, self.mat_proj) # Texture where we render the scene render_tex = gloo.Texture2D(shape=self.shape + (4, )) # Frame buffer object fbo = gloo.FrameBuffer(render_tex, gloo.RenderBuffer(self.shape)) with fbo: gloo.set_state(depth_test=True) gloo.set_state(cull_face=True) gloo.set_cull_face('back') # Back-facing polygons will be culled gloo.set_clear_color(self.bg_color) gloo.clear(color=True, depth=True) gloo.set_viewport(0, 0, *self.size) program.draw('triangles', self.index_buffer) # Retrieve the contents of the FBO texture self.rgb = gloo.read_pixels( (0, 0, self.size[0], self.size[1]))[:, :, :3] self.rgb = np.copy(self.rgb)
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 draw_distortion(self, *Contexts): '''Distorter.draw(list_of_drawables) Draw the drawables to the right and left-eye render buffers, then apply the distortion and display these buffers to the screen TODO: How can we globally handle view? Should we even bother trying to find the 'right' way to do this? ''' gloo.set_clear_color('black') gloo.set_state(depth_test=True) with self.left_eye: gloo.clear(color=True, depth=True) for context in Contexts: context.translate(0, self.IPD / 2, 0) context.set_projection(self.L_projection) context.draw() with self.right_eye: gloo.clear(color=True, depth=True) for context in Contexts: context.translate(0, -self.IPD / 2, 0) context.set_projection(self.R_projection) context.draw() gloo.clear(color=True, depth=True) self.left_eye_program.draw('triangles', self.left_eye_indices) self.right_eye_program.draw('triangles', self.right_eye_indices)
def __init__(self, parent=None): scene.SceneCanvas.__init__(self, parent=parent) self.parent = parent self.has_redrawn = True self.data = None self.program = gloo.Program(vert, frag) self.colormap = ColorMap('colormaps/transform/Seismic.ppm') self.program_cm = gloo.Program(cm_vert, cm_frag) #self. self.line_type = None self.line_coord = 0 self.line_positions = [(0, 0), (0, 0)] self.program_line = gloo.Program(basic_vert, basic_frag) self.program_line['a_position'] = self.line_positions gloo.set_clear_color((1, 1, 1, 1)) canvas_size = (1000, 800) graph_size = (900, 700) margin_x = (canvas_size[0]-graph_size[0]) / 2. margin_y = (canvas_size[1]-graph_size[1]) / 2. pos_xax = np.array([[margin_x, canvas_size[1]-margin_y], [canvas_size[0]-margin_x, canvas_size[1]-margin_y]]) self.axis_x = AxisVisual(pos_xax, (0, 100), (0., 1.)) self.tr_sys = visuals.transforms.TransformSystem(self)
def __init__(self): app.Canvas.__init__(self, size=(1024, 1024), title='Skybox example', keys='interactive') self.cubeSize = 10 self.pressed = False self.azimuth = pi / 2.0 self.elevation = pi / 2.0 self.distanceMin = 1 self.distanceMax = 50 self.distance = 30 self.sensitivity = 5.0 self.view = getView(self.azimuth, self.elevation, self.distance) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.program = gloo.Program(vertex_shader, fragment_shader, count=24) self.program['a_position'] = faces * self.cubeSize self.program['a_texcoord'] = faces self.program['a_texture'] = gloo.TextureCube(texture, interpolation='linear') self.program['u_model'] = self.model self.program['u_view'] = self.view gloo.set_viewport(0, 0, *self.physical_size) self.projection = perspective(60.0, self.size[0] / float(self.size[1]), 1.0, 100.0) self.program['u_projection'] = self.projection gl.glEnable(gl.GL_DEPTH_TEST) gloo.set_clear_color('black') self.show()
def __init__(self,): app.Canvas.__init__(self) self.size = 800, 600 # fovy, zfar params self.fovy = 45.0 self.zfar = 10.0 width, height = self.size self.aspect = width / float(height) self.program = gloo.Program(vert, frag) self.view = np.eye(4, dtype=np.float32) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) translate(self.view, 0, 0, -5.0) self.program['u_model'] = self.model self.program['u_view'] = self.view self.theta = 0 self.phi = 0 self.visible = True self._timer = app.Timer(1.0 / 60) self._timer.connect(self.on_timer) self._timer.start() # --------------------------------- gloo.set_clear_color((1, 1, 1, 1)) gloo.set_state('opaque') gloo.set_polygon_offset(1, 1)
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=((W * 5), (H * 5))) self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.texture = gloo.Texture2D(I, interpolation='linear', internalformat='r32f') self.program['u_texture'] = self.texture self.program.bind(gloo.VertexBuffer(data)) self.view = np.eye(4, dtype=np.float32) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.program['u_model'] = self.model self.program['u_view'] = self.view self.projection = ortho(0, W, 0, H, -1, 1) self.program['u_projection'] = self.projection gloo.set_clear_color('white') self._timer = app.Timer('auto', connect=self.update, start=True) self.show()
def __init__(self,controller, **kwargs): app.Canvas.__init__(self, **kwargs) self._controller = controller self.geometry = 0, 0, 400, 400 self.program = gloo.Program("shaders/raytracingalgo.vertexshader", "shaders/raytracingalgo.fragmentshader") self.program['a_position'] = [(-1., -1.), (-1., +1.),(+1., -1.), (+1., +1.)] self.program['sphere_position_0'] = (.75, .1, 1.) self.program['sphere_radius_0'] = .6 self.program['sphere_color_0'] = (1., 1., 1.) self.program['sphere_position_1'] = (-.75, .1, 2.25) self.program['sphere_radius_1'] = .6 self.program['sphere_color_1'] = (1., 1., 1.) self.program['plane_position'] = (0., -.5, 0.) self.program['plane_normal'] = (0., 1., 0.) self.program['light_intensity'] = 1. self.program['light_specular'] = (1., 50.) self.program['light_position'] = (5., 5., -10.) self.program['light_color'] = (1., 1., 1.) self.program['ambient'] = .05 self.program['O'] = (0., 0., -1.) gloo.set_clear_color((1, 1, 1, 1)) gloo.set_state(depth_test=True) #self.program.draw('triangle_strip') #self.active = True self._timer = app.Timer('auto', connect=self.timedUpdate, start=True) self._fps = 1 self._timerfps = 24 self._softFPS = []
def __init__(self, *args, **kwargs): app.Canvas.__init__(self, *args, **kwargs) self.program = gloo.Program(self.read_shader('1.vert'), self.read_shader('1.frag')) # Fill screen with single quad, fragment shader does all the real work self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)] self._starttime = time.time() self.program['time'] = 0 self.program['cameraPos'] = (0.0, 3.0, -6.0) self.program['cameraLookat'] = (0.0, -0.85, 0.5) self.program['lightDir'] = (-1.4, 0.8, -1.0) # needs to be normalized self.program['lightColour'] = (3.0, 1.4, 0.3) self.program['diffuse'] = (0.3, 0.3, 0.3) self.program['ambientFactor'] = 0.35 self.program['rotateWorld'] = 1 # self.program['ao'] = True # self.program['shadows'] = True # self.program['antialias'] = False # mutually exclusive with dof self.apply_zoom() gloo.set_clear_color(color='black') self._timer = app.Timer('auto', connect=self.update, start=True) self.show()
def __init__(self,): app.Canvas.__init__(self) self.size = 800, 600 # fovy, zfar params self.fovy = 45.0 self.zfar = 10.0 width, height = self.size self.aspect = width / float(height) self.program = gloo.Program(vert, frag) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) self.view = translate((0, 0, -5.0)) self.program['u_model'] = self.model self.program['u_view'] = self.view self.theta = 0 self.phi = 0 self.visible = True self._timer = app.Timer(1.0 / 60) self._timer.connect(self.on_timer) self._timer.start() # --------------------------------- gloo.set_clear_color((1, 1, 1, 1)) gloo.set_state('opaque') gloo.set_polygon_offset(1, 1)
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 600)) self.vertices, self.filled, self.outline = cube() self.filled_buf = gloo.IndexBuffer(self.filled) self.outline_buf = gloo.IndexBuffer(self.outline) self.program = gloo.Program(vert, frag) self.program.bind(gloo.VertexBuffer(self.vertices)) self.view = translate((0, 0, -5)) self.model = np.eye(4, dtype=np.float32) gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1]) self.projection = perspective(45.0, self.size[0] / float(self.size[1]), 2.0, 10.0) self.program['u_projection'] = self.projection self.program['u_model'] = self.model self.program['u_view'] = self.view self.theta = 0 self.phi = 0 self.transparency = 1 gloo.set_clear_color((0, 0, 0), 0.1) gloo.set_state('opaque') gloo.set_polygon_offset(1, 1) #self._timer = app.Timer('auto', connect=self.on_timer, start=True) #Siempre poner un timer asi se pone bien la funcion update!! solo en pyglet, en pyqt5 funciona joya!!! self._monitor = MidiMonitor(connect=self.on_midi) self.show()
def __init__(self, parent=None): scene.SceneCanvas.__init__(self, parent=parent) self.parent = parent self.has_redrawn = True self.data = None self.data_changed = False self.data_program = gloo.Program(data_vert, data_frag) path = os.path.dirname(os.path.realpath(__file__)) path = os.path.join(path, 'colormaps/transform/Seismic.npy') self.colormap = Colormap(path) self.colorbar_program = gloo.Program(colormap_vert, colormap_frag) # horizontal / vertical / diagonal self.line_type = None # x for a vertical line, y for a horizontal line self.line_coord = None # Start and end points for a linecut self.mouse_start = (0, 0) self.mouse_end = (0, 0) self.linecut_program = gloo.Program(linecut_vert, linecut_frag) self.linecut_program['a_position'] = [self.mouse_start, self.mouse_end] gloo.set_clear_color((1, 1, 1, 1))
def on_timer(self, event): # Animation speed based on global time. t = event.elapsed c = Color(self.color).rgb # Simple sinusoid wave animation. s = abs(0.5 + 0.5 * math.sin(t)) gloo.set_clear_color((c[0] * s, c[1] * s, c[2] * s, 1)) self.update()
def __init__(self): app.Canvas.__init__(self, size=(500, 500), keys='interactive') self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.program['u_tex1'] = gloo.Texture2D(im1, interpolation='linear') self.program['u_tex2'] = gloo.Texture2D(im2, interpolation='linear') self.program.bind(gloo.VertexBuffer(data)) gloo.set_clear_color('white')
def __init__(self, rows: int = 1, cols: int = cn.SENSOR_COUNT, length: int = 100, program: gloo.Program = None, show_grid=True, *args, **kwargs): """ Creates a canvas that displays multiple signals in a grid. :param rows: Row count in the grid. :param cols: Column count in the grid. :param length: Length of a single sequence. :param program: The gloo program being used. """ super().__init__(*args, size=cn.DEFAULT_WINDOW_SIZE, **kwargs) gloo.set_clear_color((1, 1, 1, 1)) gloo.set_viewport(0, 0, *self.physical_size) self.native.setMinimumSize(300, 150) self.rows: int = rows self.cols: int = cols self.length: int = length self.program: gloo.Program = program if program else gloo.Program( VERTEX_SHADER, FRAGMENT_SHADER) self.signal_values: np.ndarray = np.empty(0, dtype=np.float32) self.signal_colors: np.ndarray = np.empty((0, 3), dtype=np.float32) self.row_col_time_indices: np.ndarray = np.empty((0, 3), dtype=np.float32) self._update_program() self.program['u_scale'] = (1., 1.) self.program['u_size'] = (rows, cols) self.program['u_n'] = length self._timer: app.Timer = app.Timer(connect=self.update, start=True) self.connect(self.on_close) self.visuals = [] if show_grid: for i in range(cols - 1): self.visuals.append( InfiniteLineVisual((i + 1) / cols, color=(0, 0, 0, 1))) for i in range(rows - 1): self.visuals.append( InfiniteLineVisual((i + 1) / rows, vertical=False, color=(0, 0, 0, 1))) self.visuals.append( InfiniteLineVisual(cn.SENSOR_DRAW_COEFFICIENT[0], vertical=False, color=(0, 0, 0, 1)))
def on_draw(event): """ We create a callback function called when the canvas needs to be refreshed This on_draw function renders the entire scene. """ # First, we clear the window in white # (it is necessary to do that at every frame) gloo.set_clear_color((1.0, 1.0, 1.0, 1.0)) gloo.clear() program.draw('line_strip')
def draw_no_distortion(self, *Contexts): '''Distorter WITHOUT applying distortion or chromatic aberration corrections FOR DEBUG ''' gloo.set_clear_color('black') gloo.set_state(depth_test=True) gloo.clear(color=True, depth=True) for context in Contexts: context.set_projection(self.L_projection) context.draw()
def __init__(self): app.Canvas.__init__(self, keys='interactive') # Create program self._program = gloo.Program(VERT_SHADER, FRAG_SHADER) # Set uniform and attribute self._program['u_color'] = 0.2, 1.0, 0.4, 1 self._program['a_position'] = gloo.VertexBuffer(vPosition) gloo.set_clear_color('white')
def __init__(self, camera, mesh, vertex_shader=VERTEX_SHADER_BASIC, fragment_shader=FRAGMENT_SHADER_COLOR, clip_near=0.001, clip_far=100.0, background_color=(.0, .0, .0), ambient_light=0.15, directional_light_vector=[0., 0., 0.]): """ Initialize the mesh renderer :param camera: Camera instance :param mesh: Mesh containing vertices and faces (e.g. fom PyMesh) :param vertex_shader: Vertex shader code :param fragment_shader: Fragment shader code :param clip_near: Clip-near value (elements closer than this won't be rendered) :param clip_far: Clip-far value (elements farther than this won't be rendered) :param background_color: Background color :param ambient_light: Ambient light factor :param directional_light_vector: Vector of directional light """ # Initialize Vispy canvas: app.Canvas.__init__(self, show=False, size=camera.image_size) self.shape = (camera.image_size[1], camera.image_size[0]) self.camera = camera self.mesh = mesh self.background_color = background_color self.ambient_light = ambient_light self.directional_light_vector = np.asarray(directional_light_vector) self.clip_near = clip_near self.clip_far = clip_far # OpenGL shader program: self.gl_program = gloo.Program(vertex_shader, fragment_shader) # Matrix to convert to OpenGL camera system (flipping Y-Z axes): self.yz_flip = np.eye(4, dtype=np.float32) self.yz_flip[1, 1], self.yz_flip[2, 2] = -1, -1 # Model matrix (defining the mesh/model pose): self.model_matrix = np.eye(4, dtype=np.float32) # Projection matrix: self.projection_matrix = convert_hz_intrinsic_to_opengl_projection( camera.K, 0, 0, camera.image_size[0], camera.image_size[1], clip_near, clip_far, True) # Texture to render the image into:FBO self.image_texture = gloo.Texture2D(shape=self.shape + (3,)) # Corresponding FBO (frame buffer): self.fbo = gloo.FrameBuffer(self.image_texture, gloo.RenderBuffer(self.shape)) self.fbo.activate() # Drawing parameters (face culling, background color, viewport size, etc.): gloo.set_state(depth_test=True, blend=False, cull_face=False) gloo.set_clear_color(background_color) gloo.set_viewport(0, 0, *self.size)
def __init__(self): """ initialize the canvas """ app.Canvas.__init__(self, size=(512, 512), title='SR Voronoi Visualizer', keys='interactive') self.tri = 16 # 16 edges for each point self.shrinkage = width / 2 # define vertices, indices, color V, I, C = genVIC(pointz, self.tri, color) self.BarStart = V.shape[0] # set initial scale and center point self.centerpos = [0, 0] self.scale = 1 # hard-coded bar coordinates in the mean time self.BarCenter = [0.9, -0.9] self.BarDim = [ barWidth / pix2nm / self.shrinkage, 0.05 / np.sqrt(self.scale) ] bV, bI, bC = genScaleBar(self.BarDim, self.BarCenter) bI = bI + self.BarStart # bind to data V = np.vstack((V, bV)) I = np.vstack((I, bI)) C = np.vstack((C, bC)) # shader program tet = gloo.Program(vert=vertex, frag=fragment) #, count=V.shape[0]) self.I = gloo.IndexBuffer(I) self.V = gloo.VertexBuffer(V) self.C = gloo.VertexBuffer(C) tet['a_position'] = self.V tet['a_color'] = self.C # intialize transformation matrix self.view = np.eye(4, dtype=np.float32) self.model = np.eye(4, dtype=np.float32) self.projection = np.eye(4, dtype=np.float32) # set view self.view = translate((0, 0, -3)) tet['u_model'] = self.model tet['u_view'] = self.view tet['u_projection'] = self.projection # bind program self.program = tet # config and set viewport gloo.set_viewport(0, 0, *self.physical_size) gloo.set_clear_color('black') gloo.set_state('opaque') gloo.set_polygon_offset(1.0, 1.0) # bind a timer self.timer = app.Timer('auto', self.on_timer) self.timer.start() # show the canvas self.show()
def on_draw(self, event): # Image rect with self.framebuffer: set_clear_color('gray') clear(color=True, depth=True) set_state(depth_test=True) self.cube.draw('triangle_strip') set_clear_color('pink') clear(color=True) set_state(depth_test=True) self.quad.draw('triangle_strip')
def __init__(self): app.Canvas.__init__(self, keys='interactive', title = 'Hydra tracker') self._program = gloo.Program(VERT_SHADER, FRAG_SHADER) self._vbo = gloo.VertexBuffer(vertex_data) self._program['texture1'] = gloo.Texture2D(im1) self._program.bind(self._vbo) self._program_lines = gloo.Program(VERT_SHADER, FRAG_SHADER_LINES) self._program_lines.bind(self._vbo) gloo.set_clear_color('black') self._timer = app.Timer('auto', connect=self.update, start=True) self.show()
def __init__(self): app.Canvas.__init__(self, keys='interactive') # Create program self._program = gloo.Program(VERT_SHADER, FRAG_SHADER) # Set uniform and attribute self._program['u_color'] = 0.2, 1.0, 0.4, 1 self._program['a_position'] = gloo.VertexBuffer(vPosition) gloo.set_clear_color('white') self.show()
def on_draw(self, event): # Draw the same scene as as in hello_quad.py, but draw it to the FBO with self._fbo: gloo.set_clear_color((0.0, 0.0, 0.5, 1)) gloo.clear(color=True, depth=True) gloo.set_viewport(0, 0, *self.size) self._program1.draw('triangle_strip') # Now draw result to a full-screen quad # Init gloo.set_clear_color('white') gloo.clear(color=True, depth=True) self._program2.draw('triangle_strip')
def on_draw(self, event): """ canvas update callback """ gloo.set_clear_color((0.0, 0.0, 0.0, 1.0)) gloo.clear() # Filled cube gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True) self.program['u_color'] = [1.0, 1.0, 1.0, 0.8] self.program.draw('triangles', self.F) # draw outline gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True) self.program['u_color'] = [1.0, 1.0, 1.0, 1.0] self.program.draw('lines', self.E)
def __init__(self, data, theta=30.0, phi=90.0, z=6.0): """ initialize data for plotting Parameters ---------- data : array_like 3D data, Nx3 theta : float rotation around y axis phi : float rotation around z axis z : float view depth """ app.Canvas.__init__(self, size=(800, 400), title='plot3d', keys='interactive') # build shader program program = gloo.Program(vert=vertex, frag=fragment) # initialize 3D view view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) # update program program['u_model'] = model program['u_view'] = view program['u_projection'] = projection program['a_position'] = data # bind self.program = program self.theta = theta self.phi = phi self.z = z # config gloo.set_viewport(0, 0, *self.physical_size) gloo.set_clear_color('white') gloo.set_state('translucent') # config your lines gloo.set_line_width(2.0) # show the canvas self.show()
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=(800, 600)) rospy.init_node('imu_visualizer') # assert_node_alive('torso_arduino') rospy.Subscriber('imu/data_raw', Imu, self.on_imu) # Cleanup when termniating the node rospy.on_shutdown(self.shutdown) self.vertices, self.filled, self.outline = cube() self.filled_buf = gloo.IndexBuffer(self.filled) self.outline_buf = gloo.IndexBuffer(self.outline) self.program = gloo.Program(vert, frag) self.program.bind(gloo.VertexBuffer(self.vertices)) self.view = translate((0, 0, -5)) self.model = np.eye(4, dtype=np.float32) gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1]) self.projection = perspective(45.0, self.size[0] / float(self.size[1]), 2.0, 10.0) self.program['u_projection'] = self.projection self.program['u_model'] = self.model self.program['u_view'] = self.view self.yaw = 0 # yaw self.roll = 0 # roll self.pitch = 0 # pitch gloo.set_clear_color('white') # gloo.set_clear_color('black') gloo.set_state('opaque') gloo.set_polygon_offset(1, 1) self.first = True self.yaw0 = None self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.show() app.run() rospy.signal_shutdown("Shutting done.") self.shutdown() print('Node shutdown.')
def on_draw(self, event): # draw scene to FBO instead of output buffer with self._fbo: gloo.set_clear_color('black') gloo.clear(color=True, depth=True) gloo.set_viewport(0,0, *self.size) # render each of the modules for module in self.renderList: if(module.rendering): # make sure it's ready module.program.draw('triangle_strip') # draw the module # draw to full screen # gloo.set_clear_color('black') gloo.clear(color=True,depth=True) #self.left_eye_program_draw('triangles', self.left_eye_indices) self._program2.draw('triangle_strip')
def __init__(self, V, C, I, E, figsize=(512, 512), title='tetplot'): """ initialize the canvas """ app.Canvas.__init__(self, size=figsize, title=title, keys='interactive') # shader program tet = gloo.Program(vert=vertex, frag=fragment) # bind to data tet['a_position'] = V tet['a_color'] = C self.I = gloo.IndexBuffer(I) self.E = gloo.IndexBuffer(E) # intialize transformation matrix view = np.eye(4, dtype=np.float32) model = np.eye(4, dtype=np.float32) projection = np.eye(4, dtype=np.float32) tet['u_model'] = model tet['u_view'] = view tet['u_projection'] = projection # bind your program self.program = tet # config and set viewport gloo.set_viewport(0, 0, *self.physical_size) gloo.set_clear_color('white') gloo.set_state('translucent') gloo.set_polygon_offset(0.0, 0.0) # update parameters self.theta = 0.0 self.phi = 0.0 self.z = 5.0 # bind a timer self.timer = app.Timer('auto', self.on_timer) self.timer.start() # control plots gloo.set_line_width(1.0) # show the canvas self.show()
def __init__(self): app.Canvas.__init__(self, show=True, 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['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' set_clear_color('black')
def on_initialize(self, event): # 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) 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)
def __init__(self, *args, **kwargs): app.Canvas.__init__(self, *args, **kwargs) self.program = gloo.Program(self.read_shader('1.vert'), self.read_shader('skeleton_video.frag')) # Fill screen with single quad, fragment shader does all the real work self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)] self.program["frame"] = gloo.Texture2D(shape=(480, 640, 2), format='luminance_alpha') width, height = self.physical_size gloo.set_viewport(0, 0, width, height) self.program['resolution'] = [width, height] openni2.initialize() nite2.initialize() self.user_tracker = nite2.UserTracker(False) gloo.set_clear_color(color='black') self._timer = app.Timer('auto', connect=self.update, start=True) self.show()
def __init__(self, **kwargs): app.Canvas.__init__(self, **kwargs) self.geometry = 0, 0, 400, 400 self.program = gloo.Program(VERT_CODE, FRAG_CODE) # Set attributes self.program['a_position'] = gloo.VertexBuffer(positions) self.program['a_texcoord'] = gloo.VertexBuffer(texcoords) self.program['u_texture'] = gloo.Texture2D(load_crate()) # Handle transformations self.init_transforms() gloo.set_clear_color((1, 1, 1, 1)) gloo.set_state(depth_test=True) self._timer = app.Timer('auto', connect=self.update_transforms) self._timer.start()
def __init__(self): app.Canvas.__init__(self, keys='interactive') # Create program self._program = gloo.Program(VERT_SHADER, FRAG_SHADER) # Create vertex buffer self._vbo = gloo.VertexBuffer(vertex_data) # Set uniforms, samplers, attributes # We create one VBO with all vertex data (array of structures) # and create two views from it for the attributes. self._program['texture1'] = gloo.Texture2D(im1) self._program.bind(self._vbo) # This does: #self._program['a_position'] = self._vbo['a_position'] #self._program['a_texcoords'] = self._vbo['a_texcoords'] gloo.set_clear_color('white') self._timer = app.Timer('auto', connect=self.update, start=True)