def get_flow(self): self.render() with self._fbo2: flowx = gloo.read_pixels(out_type = np.float32) with self._fbo3: flowy = gloo.read_pixels(out_type = np.float32) return (flowx, flowy)
def get_flow(self): self.render() with self._fbo2: flowx = gloo.read_pixels(out_type = np.float32) with self._fbo3: flowy = gloo.read_pixels(out_type = np.float32) return (flowx, flowy)
def test_wrappers(): """Test gloo wrappers""" with Canvas(): gl.use_gl('desktop debug') gloo.clear('#112233') # make it so that there's something non-zero # check presets assert_raises(ValueError, gloo.set_state, preset='foo') for state in gloo.get_state_presets().keys(): gloo.set_state(state) assert_raises(ValueError, gloo.set_blend_color, (0., 0.)) # bad color assert_raises(TypeError, gloo.set_hint, 1, 2) # need strs assert_raises(TypeError, gloo.get_parameter, 1) # need str # this doesn't exist in ES 2.0 namespace assert_raises(ValueError, gloo.set_hint, 'fog_hint', 'nicest') # test bad enum assert_raises(RuntimeError, gloo.set_line_width, -1) # check read_pixels x = gloo.read_pixels() assert_true(isinstance(x, np.ndarray)) assert_true(isinstance(gloo.read_pixels((0, 0, 1, 1)), np.ndarray)) assert_raises(ValueError, gloo.read_pixels, (0, 0, 1)) # bad port y = gloo.read_pixels(alpha=False, out_type=np.ubyte) assert_equal(y.shape, x.shape[:2] + (3, )) assert_array_equal(x[..., :3], y) y = gloo.read_pixels(out_type='float') assert_allclose(x / 255., y) # now let's (indirectly) check our set_* functions viewport = (0, 0, 1, 1) blend_color = (0., 0., 0.) _funs = dict( viewport=viewport, # checked hint=('generate_mipmap_hint', 'nicest'), depth_range=(1., 2.), front_face='cw', # checked cull_face='front', line_width=1., polygon_offset=(1., 1.), blend_func=('zero', 'one'), blend_color=blend_color, blend_equation='func_add', scissor=(0, 0, 1, 1), stencil_func=('never', 1, 2, 'back'), stencil_mask=4, stencil_op=('zero', 'zero', 'zero', 'back'), depth_func='greater', depth_mask=True, color_mask=(True, True, True, True), sample_coverage=(0.5, True)) gloo.set_state(**_funs) gloo.clear((1., 1., 1., 1.), 0.5, 1) gloo.flush() gloo.finish() # check some results assert_array_equal(gloo.get_parameter('viewport'), viewport) assert_equal(gloo.get_parameter('front_face'), gl.GL_CW) assert_equal(gloo.get_parameter('blend_color'), blend_color + (1, ))
def test_wrappers(): """Test gloo wrappers""" with Canvas(): gl.use_gl('desktop debug') gloo.clear('#112233') # make it so that there's something non-zero # check presets assert_raises(ValueError, gloo.set_state, preset='foo') for state in gloo.get_state_presets().keys(): gloo.set_state(state) assert_raises(ValueError, gloo.set_blend_color, (0., 0.)) # bad color assert_raises(TypeError, gloo.set_hint, 1, 2) # need strs assert_raises(TypeError, gloo.get_parameter, 1) # need str # this doesn't exist in ES 2.0 namespace assert_raises(ValueError, gloo.set_hint, 'fog_hint', 'nicest') # test bad enum assert_raises(RuntimeError, gloo.set_line_width, -1) # check read_pixels x = gloo.read_pixels() assert_true(isinstance(x, np.ndarray)) assert_true(isinstance(gloo.read_pixels((0, 0, 1, 1)), np.ndarray)) assert_raises(ValueError, gloo.read_pixels, (0, 0, 1)) # bad port y = gloo.read_pixels(alpha=False, out_type=np.ubyte) assert_equal(y.shape, x.shape[:2] + (3,)) assert_array_equal(x[..., :3], y) y = gloo.read_pixels(out_type='float') assert_allclose(x/255., y) # now let's (indirectly) check our set_* functions viewport = (0, 0, 1, 1) blend_color = (0., 0., 0.) _funs = dict(viewport=viewport, # checked hint=('generate_mipmap_hint', 'nicest'), depth_range=(1., 2.), front_face='cw', # checked cull_face='front', line_width=1., polygon_offset=(1., 1.), blend_func=('zero', 'one'), blend_color=blend_color, blend_equation='func_add', scissor=(0, 0, 1, 1), stencil_func=('never', 1, 2, 'back'), stencil_mask=4, stencil_op=('zero', 'zero', 'zero', 'back'), depth_func='greater', depth_mask=True, color_mask=(True, True, True, True), sample_coverage=(0.5, True)) gloo.set_state(**_funs) gloo.clear((1., 1., 1., 1.), 0.5, 1) gloo.flush() gloo.finish() # check some results assert_array_equal(gloo.get_parameter('viewport'), viewport) assert_equal(gloo.get_parameter('front_face'), gl.GL_CW) assert_equal(gloo.get_parameter('blend_color'), blend_color + (1,))
def get_pixel_data(self): with self._fbo1: a = gloo.read_pixels()[:,:,0] with self._fbo2: b = gloo.read_pixels(out_type = np.float32)[:,:,0] with self._fbo3: c = gloo.read_pixels(out_type = np.float32)[:,:,0] with self._fbo4: d = gloo.read_pixels()[:,:,0] return (a, b, c, d)
def get_pixel_data(self): with self._fbo1: a = gloo.read_pixels()[:, :, 0] with self._fbo2: b = gloo.read_pixels(out_type=np.float32)[:, :, 0] with self._fbo3: c = gloo.read_pixels(out_type=np.float32)[:, :, 0] with self._fbo4: d = gloo.read_pixels()[:, :, 0] return (a, b, c, d)
def test_read_pixels(): """Test read_pixels to ensure that the image is not flipped""" # Create vertices vPosition = np.array( [ [-1, 1, 0.0], [0, 1, 0.5], # For drawing a square to top left [-1, 0, 0.0], [0, 0, 0.5] ], np.float32) VERT_SHADER = """ // simple vertex shader attribute vec3 a_position; void main (void) { gl_Position = vec4(a_position, 1.0); } """ FRAG_SHADER = """ // simple fragment shader void main() { gl_FragColor = vec4(1,1,1,1); } """ with Canvas() as c: c.set_current() gloo.set_viewport(0, 0, *c.size) gloo.set_state(depth_test=True) c._program = gloo.Program(VERT_SHADER, FRAG_SHADER) c._program['a_position'] = gloo.VertexBuffer(vPosition) gloo.clear(color='black') c._program.draw('triangle_strip') # Check if the return of read_pixels is the same as our drawing img = read_pixels(alpha=False) assert_equal(img.shape[:2], c.size[::-1]) top_left = sum(img[0, 0]) assert_true(top_left > 0) # Should be > 0 (255*4) # Sum of the pixels in top right + bottom left + bottom right corners corners = sum(img[0, -1] + img[-1, 0] + img[-1, -1]) assert_true(corners == 0) # Should be all 0 gloo.flush() gloo.finish() # Check that we can read the depth buffer img = read_pixels(mode='depth') assert_equal(img.shape[:2], c.size[::-1]) assert_equal(img.shape[2], 1) unique_img = np.unique(img) # we should have quite a few different depth values assert unique_img.shape[0] > 50 assert unique_img.max() == 255 assert unique_img.min() > 0
def render(self): with self._fboi: gloo.clear() self._programi.bind(self._vbo) self._programi.draw('triangles', self.indices_buffer) pixelsi = gloo.read_pixels(out_type=np.float32)[:, :, 0] with self._fboj: gloo.clear() self._programj.bind(self._vbo) self._programj.draw('triangles', self.indices_buffer) pixelsj = gloo.read_pixels(out_type=np.float32)[:, :, 0] return (pixelsi, pixelsj)
def paintEvent(self, event): self._vispy_canvas.events.draw(region=None) if IS_LINUX or IS_RPI: # Arg, cannot get GL to draw to the widget, so we take a # screenshot and draw that for now ... # Further, QImage keeps a ref to the data that we pass, so # we need to use a static buffer to prevent memory leakage from vispy import gloo import numpy as np if not hasattr(self, '_gl_buffer'): self._gl_buffer = np.ones((3000 * 3000 * 4), np.uint8) * 255 # Take screenshot and turn into RGB QImage im = gloo.read_pixels() sze = im.shape[0] * im.shape[1] self._gl_buffer[0:0+sze*4:4] = im[:, :, 2].ravel() self._gl_buffer[1:0+sze*4:4] = im[:, :, 1].ravel() self._gl_buffer[2:2+sze*4:4] = im[:, :, 0].ravel() img = QtGui.QImage(self._gl_buffer, im.shape[1], im.shape[0], QtGui.QImage.Format_RGB32) # Paint the image painter = QtGui.QPainter() painter.begin(self) rect = QtCore.QRect(0, 0, self.width(), self.height()) painter.drawImage(rect, img) painter.end()
def paintEvent(self, event): self._vispy_canvas.events.draw(region=None) if IS_LINUX or IS_RPI: # Arg, cannot get GL to draw to the widget, so we take a # screenshot and draw that for now ... # Further, QImage keeps a ref to the data that we pass, so # we need to use a static buffer to prevent memory leakage from vispy import gloo import numpy as np if not hasattr(self, '_gl_buffer'): self._gl_buffer = np.ones((3000 * 3000 * 4), np.uint8) * 255 # Take screenshot and turn into RGB QImage im = gloo.read_pixels() sze = im.shape[0] * im.shape[1] self._gl_buffer[0:0 + sze * 4:4] = im[:, :, 2].ravel() self._gl_buffer[1:0 + sze * 4:4] = im[:, :, 1].ravel() self._gl_buffer[2:2 + sze * 4:4] = im[:, :, 0].ravel() img = QtGui.QImage(self._gl_buffer, im.shape[1], im.shape[0], QtGui.QImage.Format_RGB32) # Paint the image painter = QtGui.QPainter() painter.begin(self) rect = QtCore.QRect(0, 0, self.width(), self.height()) painter.drawImage(rect, img) painter.end()
def on_mouse_press(self, event): pixs = gloo.read_pixels() # get pixels on screen # mouse click coordinates x = event.pos[0] y = event.pos[1] target = [] found = False for u in range(x-2, x+2): # try to find a fully-opaque pixel around click point if found: break for v in range(y - 2, y+2): if found: break if pixs[v][u][3] == 255 and tuple(pixs[v][u]) != (0,0,0,255): target = pixs[v][u] found = True print(v,u) if len(target) > 0: # get the nearest neighbor to the clicked color nearest = self.index.search(np.array([target]).astype('float32'), 1) nn = nearest[1][0][0] self.color(nn, revert = self.highlight.revert, depth=self.highlight.selectionDepth) # highlight
def cubemap_to_dual_paraboloid(cube_faces): _, height, width, n_channels = cube_faces.shape height, width = height * 2, width * 2 internal_format = 'rgba32f' if n_channels == 4 else 'rgb32f' with ContextProvider((height, width)): rendtex = gloo.Texture2D((height, width, n_channels), interpolation='linear', wrapping='repeat', internalformat=internal_format) framebuffer = gloo.FrameBuffer( rendtex, gloo.RenderBuffer((width, height, n_channels))) program = CubemapToDualParaboloidProgram().compile() program['u_cubemap'] = gloo.TextureCubeMap( cube_faces, internalformat=internal_format, mipmap_levels=8) results = [] for i in [0, 1]: with framebuffer: gloo.set_viewport(0, 0, width, height) program['u_hemisphere'] = i program.draw(gl.GL_TRIANGLE_STRIP) results.append( np.flipud( gloo.read_pixels(out_type=np.float32, format='rgb'))) return results[0], results[1]
def _init_radmap_shadows(self): shadow_dirs = find_shadow_sources(self.radiance_map.radiance_faces) logger.info("[shadows ON] Rendering {} shadow maps.".format( len(shadow_dirs))) with ContextProvider((1024, 1024)): for i, shadow_dir in enumerate(shadow_dirs): position = vector_utils.normalized(shadow_dir) up = np.roll(position, 1) * (1, 1, -1) camera = OrthographicCamera((200, 200), -150, 150, position=position, lookat=(0, 0, 0), up=up) rend_target = util.create_rend_target((1024, 1024)) draw_depth(camera, self.renderables, rend_target) with rend_target[0]: # gloo.read_pixels flips the output. depth = np.flipud( np.copy( gloo.read_pixels(format='depth', out_type=np.float32))) # Opengl ES doesn't support border clamp value # specification so hack it like this. depth[[0, -1], :] = 1.0 depth[:, [0, -1]] = 1.0 self.shadow_sources.append((camera, depth))
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 getpredimg(self): oldstate = self.state self.state = 'raw' self.draw(None) pixels = gloo.read_pixels() self.state = oldstate return pixels
def rendermask(self): with self._fbo4: gloo.clear() self._program_mask.draw('triangles', self.indices_buffer) pixels = gloo.read_pixels() pixels = cv2.cvtColor(pixels, cv2.COLOR_BGRA2RGBA) return pixels
def getpredimg(self): oldstate = self.state self.state = 'raw' self.draw(None) pixels = gloo.read_pixels() self.state = oldstate return pixels
def error(self, state, y_im, y_flow, y_m): state.refresh() state.render() with self._fbo1: pixels = gloo.read_pixels() with self._fbo2: fx = gloo.read_pixels(out_type = np.float32) with self._fbo3: fy = gloo.read_pixels(out_type = np.float32) with self._fbo4: m = gloo.read_pixels() e_im = np.sum(np.multiply(y_im-pixels[:,:,0], y_im-pixels[:,:,0])) e_fx = np.sum(np.multiply(y_flow[:,:,0]-fx[:,:,0], y_flow[:,:,0]-fx[:,:,0])) e_fy = np.sum(np.multiply(y_flow[:,:,1]+fy[:,:,0], y_flow[:,:,1]+fy[:,:,0])) e_m = np.sum(np.multiply(255*y_m-m[:,:,0], 255*y_m-m[:,:,0])) return e_im, e_fx, e_fy, e_m, fx, fy
def error(self, state, y_im, y_flow, y_m): state.refresh() state.render() with self._fbo1: pixels = gloo.read_pixels() with self._fbo2: fx = gloo.read_pixels(out_type = np.float32) with self._fbo3: fy = gloo.read_pixels(out_type = np.float32) with self._fbo4: m = gloo.read_pixels() e_im = np.sum(np.multiply(y_im-pixels[:,:,0], y_im-pixels[:,:,0])) e_fx = np.sum(np.multiply(y_flow[:,:,0]-fx[:,:,0], y_flow[:,:,0]-fx[:,:,0])) e_fy = np.sum(np.multiply(y_flow[:,:,1]+fy[:,:,0], y_flow[:,:,1]+fy[:,:,0])) e_m = np.sum(np.multiply(255*y_m-m[:,:,0], 255*y_m-m[:,:,0])) return e_im, e_fx, e_fy, e_m, fx, fy
def screenshot(self, saveall = False, basename = 'screenshot'): with self._fbo2: print 'saving flowx' pixels = gloo.read_pixels(out_type = np.float32)[:,:,0] #fn = './' + basename + '_flowx_' + strftime("%Y-%m-%d_%H:%M:%S", gmtime()) + '.png' fn = './' + basename + '_flowx.png' #print np.max(pixels) cv2.imwrite(fn, (255.*(pixels-np.min(pixels))/(np.max(pixels)-np.min(pixels))).astype(int)) with self._fbo3: print 'saving flowy' pixels = gloo.read_pixels(out_type = np.float32)[:,:,0] #fn = './' + basename + '_flowy_' + strftime("%Y-%m-%d_%H:%M:%S", gmtime()) + '.png' fn = './' + basename + '_flowy.png' cv2.imwrite(fn, (255.*(pixels-np.min(pixels))/(np.max(pixels)-np.min(pixels))).astype(int)) if not saveall: pixels = gloo.read_pixels() pixels = cv2.cvtColor(pixels, cv2.COLOR_BGRA2RGBA) #fn = './' + basename + '_' + self.state + '_' + strftime("%Y-%m-%d_%H:%M:%S", gmtime()) + '.png' fn = './' + basename + '_' + self.state + '.png' print 'Saving screenshot to ' + fn cv2.imwrite(fn, pixels) return None else: oldstate = self.state #self._updatemaskpalette(np.squeeze(self.randfacecolors[:,:,0])) self._updatemaskpalette(np.squeeze(self.hessfacecolors[:,:,1])) #change render mode, rerender, and save #for state in ['flow', 'raw', 'overlay', 'texture']: for state in ['raw', 'overlay', 'texture', 'mask', 'inverse']: print 'saving', state self.state = state self._updatemaskpalette(np.squeeze(self.hessfacecolors[:,:,1])) self.draw(None) pixels = gloo.read_pixels() pixels = cv2.cvtColor(pixels, cv2.COLOR_BGRA2RGBA) if state == 'overlay': overlay = pixels #fn = './' + basename + '_' + state + '_' + strftime("%Y-%m-%d_%H:%M:%S", gmtime()) + '.png' fn = './' + basename + '_' + state + '.png' #print 'Saving screenshot to ' + fn cv2.imwrite(fn, pixels) self.state = oldstate self.update() return overlay
def wireframe(self): oldstate = self.state self._updatemaskpalette(np.squeeze(self.hessfacecolors[:,:,1])) self.state = 'wireframe' self._updatemaskpalette(np.squeeze(self.hessfacecolors[:,:,1])) self.draw(None) pixels = gloo.read_pixels() pixels = cv2.cvtColor(pixels, cv2.COLOR_BGRA2RGBA) self.state = oldstate self.update() return pixels
def screenshot(self, saveall = False, basename = 'screenshot'): with self._fbo2: print 'saving flowx' pixels = gloo.read_pixels(out_type = np.float32)[:,:,0] fn = './' + basename + '_flowx_' + strftime("%Y-%m-%d_%H:%M:%S", gmtime()) + '.png' #print np.max(pixels) cv2.imwrite(fn, (255.*(pixels-np.min(pixels))/(np.max(pixels)-np.min(pixels))).astype(int)) with self._fbo3: print 'saving flowy' pixels = gloo.read_pixels(out_type = np.float32)[:,:,0] fn = './' + basename + '_flowy_' + strftime("%Y-%m-%d_%H:%M:%S", gmtime()) + '.png' cv2.imwrite(fn, (255.*(pixels-np.min(pixels))/(np.max(pixels)-np.min(pixels))).astype(int)) if not saveall: pixels = gloo.read_pixels() pixels = cv2.cvtColor(pixels, cv2.COLOR_BGRA2RGBA) fn = './' + basename + '_' + self.state + '_' + strftime("%Y-%m-%d_%H:%M:%S", gmtime()) + '.png' print 'Saving screenshot to ' + fn cv2.imwrite(fn, pixels) return None else: oldstate = self.state #self._updatemaskpalette(np.squeeze(self.randfacecolors[:,:,0])) self._updatemaskpalette(np.squeeze(self.hessfacecolors[:,:,1])) #change render mode, rerender, and save #for state in ['flow', 'raw', 'overlay', 'texture']: for state in ['raw', 'overlay', 'texture', 'mask']: print 'saving', state self.state = state self._updatemaskpalette(np.squeeze(self.hessfacecolors[:,:,1])) self.draw(None) pixels = gloo.read_pixels() pixels = cv2.cvtColor(pixels, cv2.COLOR_BGRA2RGBA) if state == 'overlay': overlay = pixels fn = './' + basename + '_' + state + '_' + strftime("%Y-%m-%d_%H:%M:%S", gmtime()) + '.png' #print 'Saving screenshot to ' + fn cv2.imwrite(fn, pixels) self.state = oldstate self.update() return overlay
def draw(self, camera_translation_vector, camera_rotation_matrix, return_depth=True): """ Render and return color and optionally depth images of the mesh, from the chosen viewpoint. :param camera_translation_vector: Camera position :param camera_rotation_matrix: Camera rotation :param return_depth: Flag to return depth modality :return: RGB image, opt. depth image """ # View matrix (defining the camera pose): view_matrix = np.eye(4, dtype=np.float32) view_matrix[:3, 3] = np.squeeze(camera_translation_vector) view_matrix[:3, :3] = camera_rotation_matrix # Converting it to OpenGL coordinate system: view_matrix = self.yz_flip.dot(view_matrix).T # Model-view matrix (projecting from object space to camera space): mv_matrix = np.dot(self.model_matrix, view_matrix) # Model-view-projection matrix (projecting from object space to image space): mvp_matrix = np.dot(mv_matrix, self.projection_matrix) # Clear previous content: gloo.clear(color=True, depth=True) # Bind mesh buffer to shader program: self.gl_program.bind(self.mesh.vertex_buffer) # Pass parameters to shader program: self.gl_program['u_mv'] = mv_matrix self.gl_program['u_mvp'] = mvp_matrix self.gl_program['u_light_eye_position'] = self.directional_light_vector self.gl_program['u_light_ambient'] = self.ambient_light # Render: self.gl_program.draw('triangles', self.mesh.index_buffer) # Fetch rendered content from FBO: bgr = np.copy(gloo.read_pixels((0, 0, self.shape[1], self.shape[0]))[..., :3]) rgb = bgr[..., ::-1] if return_depth: z_buffer = gl.glReadPixels(0, 0, self.shape[1], self.shape[0], gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT) # Convert buffer into array and flip axis: z_buffer = np.copy(np.frombuffer(z_buffer, np.float32)).reshape(self.shape + (1,))[::-1, :] # Convert buffer values into depth map: depth_coef = (self.clip_near * self.clip_far) / (self.clip_near - self.clip_far) z_offset = self.clip_far / (self.clip_near - self.clip_far) background_mask = z_buffer == 1. depth = depth_coef / (z_buffer + z_offset) depth[background_mask] = 0. return rgb, depth else: return rgb
def _draw_layers(self, layers=None): with self._fbo: gloo.clear(color=True, depth=True) gloo.set_viewport(0, 0, *self._size) gloo.set_state(depth_test=False) for image in self._get_layers(layers): if image and image.is_visible(): image.draw() self._image = gloo.read_pixels((0, 0, *self._size), True) if self._save_png: self._png = _make_png(self.screenshot, self._compression)
def test_read_pixels(): """Test read_pixels to ensure that the image is not flipped""" # Create vertices vPosition = np.array( [ [-1, 1], [0, 1], # For drawing a square to top left [-1, 0], [0, 0] ], np.float32) VERT_SHADER = """ // simple vertex shader attribute vec2 a_position; void main (void) { gl_Position = vec4(a_position, 0., 1.0); } """ FRAG_SHADER = """ // simple fragment shader void main() { gl_FragColor = vec4(1,1,1,1); } """ with Canvas() as c: gloo.set_viewport(0, 0, *c.size) c._program = gloo.Program(VERT_SHADER, FRAG_SHADER) c._program['a_position'] = gloo.VertexBuffer(vPosition) gloo.clear(color='black') c._program.draw('triangle_strip') # Check if the return of read_pixels is the same as our drawing img = read_pixels(format='rgb') assert_equal(img.shape[:2], c.size[::-1]) top_left = sum(img[0, 0]) assert_true(top_left > 0) # Should be > 0 (255*4) # Sum of the pixels in top right + bottom left + bottom right corners corners = sum(img[0, -1] + img[-1, 0] + img[-1, -1]) assert_true(corners == 0) # Should be all 0 gloo.flush() gloo.finish()
def test_read_pixels(): """Test read_pixels to ensure that the image is not flipped""" # Create vertices vPosition = np.array([[-1, 1], [0, 1], # For drawing a square to top left [-1, 0], [0, 0]], np.float32) VERT_SHADER = """ // simple vertex shader attribute vec2 a_position; void main (void) { gl_Position = vec4(a_position, 0., 1.0); } """ FRAG_SHADER = """ // simple fragment shader void main() { gl_FragColor = vec4(1,1,1,1); } """ with Canvas() as c: gloo.set_viewport(0, 0, *c.size) c._program = gloo.Program(VERT_SHADER, FRAG_SHADER) c._program['a_position'] = gloo.VertexBuffer(vPosition) gloo.clear(color='black') c._program.draw('triangle_strip') # Check if the return of read_pixels is the same as our drawing img = read_pixels(alpha=False) assert_equal(img.shape[:2], c.size[::-1]) top_left = sum(img[0, 0]) assert_true(top_left > 0) # Should be > 0 (255*4) # Sum of the pixels in top right + bottom left + bottom right corners corners = sum(img[0, -1] + img[-1, 0] + img[-1, -1]) assert_true(corners == 0) # Should be all 0 gloo.flush() gloo.finish()
def cubemap_to_panorama(cube_faces): _, height, width, n_channels = cube_faces.shape height, width = height, width * 2 internal_format = 'rgba32f' if n_channels == 4 else 'rgb32f' with ContextProvider((height, width)): rendtex = gloo.Texture2D((height, width, n_channels), interpolation='linear', wrapping='repeat', internalformat=internal_format) framebuffer = gloo.FrameBuffer( rendtex, gloo.RenderBuffer((height, width, n_channels))) program = CubemapToPanoramaProgram().compile() program['u_cubemap'] = gloo.TextureCubeMap( cube_faces, internalformat=internal_format, mipmap_levels=8) with framebuffer: gloo.set_viewport(0, 0, width, height) program.draw(gl.GL_TRIANGLE_STRIP) result = gloo.read_pixels(out_type=np.float32, format='rgb') return result
def panorama_to_cubemap(panorama, cube_size=256): program = PanoramaToCubemapProgram().compile() height, width = cube_size, cube_size n_channels = 3 internal_format = 'rgb32f' with ContextProvider((height, width)): rendtex = gloo.Texture2D((height, width, n_channels), interpolation='linear', wrapping='repeat', internalformat=internal_format) framebuffer = gloo.FrameBuffer( rendtex, gloo.RenderBuffer((width, height, n_channels))) gloo.set_viewport(0, 0, width, height) program['u_panorama'] = gloo.Texture2D(panorama.transpose((1, 0, 2)), internalformat=internal_format) results = np.zeros((6, height, width, n_channels), dtype=np.float32) for i in range(6): program['u_cube_face'] = i with framebuffer: program.draw(gl.GL_TRIANGLE_STRIP) results[i] = gloo.read_pixels(out_type=np.float32, format='rgb') return results
def retrieve_bounding_boxes(self): self.bounding_boxes = gloo.read_pixels( (0, 0, self.size[0], self.size[1]))[:, :, :3] self.bounding_boxes = np.copy(self.bounding_boxes)
for j in range(i+1,N): if Jv[i,j]: Q = Q + [[i,j]] Q = np.array(Q) ################################################################################ ################################################################################ ################################################################################ kf = IteratedKalmanFilter(distmesh, frame, flowframe, cuda = cuda, sparse = sparse) self = kf.state.renderer #Test labels with self._fbo4: m = gloo.read_pixels() np.max(m[:,:,2]) np.sum(m[:,:,2] == 255) np.unique(m[:,:,2]) kf.state.E[0] kf.state.labels np.unique(m[:,:,1]) self = kf.state Hz = np.zeros((self.size(),1)) Hz_components = np.zeros((self.size(),4)) self.refresh() self.render() self.renderer.initjacobian(frame, flowframe, mask) idx = 0 e = np.array(self.E[0])
def update_plot(): global current_net global global_step global level_step_counter global layout global last_positions global pos_max global pos_min while True: position_change = torch.mean( torch.norm(current_net.positions - last_positions, 2, dim=1)) last_positions = current_net.positions.clone() if position_change < 0.001 and level_step_counter > 200: level_step_counter = 0 if global_step > 0: current_net = current_net.give_positions_to_parent( perturbation=0.1) if current_net is None: break last_positions = current_net.positions.clone() layout = NetworkForceLayout(current_net, spring_optimal_distance=1., attraction_normalization=0., repulsion=1., step_size=0.05, step_discount_factor=0.95, centering=25., drag=0.1, noise=0.1, mac=0.5, num_dim=2, force_limit=1., distance_exponent=2.) layout.simulation_step() positions = layout.x.cpu().numpy()[np.newaxis, :].copy() n_pos_max = np.max(positions) n_pos_min = np.min(positions) pos_max = range_gamma * n_pos_max + (1 - range_gamma) * pos_max pos_min = range_gamma * n_pos_min + (1 - range_gamma) * pos_min positions -= pos_min positions /= (pos_max - pos_min) edges = np.zeros((current_net.num_connections * 3, 3), dtype=np.float32) edges[0::3, :2] = positions[0, current_net.connections[:, 0], :] edges[1::3, :2] = positions[0, current_net.connections[:, 1], :] edges[2::3, :] = float('nan') edges[0::3, 2] = 1. edges[1::3, 2] = 1. edges = pd.DataFrame(data=edges) edges.columns = ['x', 'y', 'val'] edges_lines = canvas.line(edges, 'x', 'y', agg=ds.sum('val')).values.astype(np.float32) edges_lines[edges_lines != edges_lines] = 0. edges_lines = pow(edges_lines / edges_lines.max(), 0.25) #edges_lines = gaussian_filter(edges_lines, sigma=0.8) viz.set_new_node_positions( positions, new_weights=current_net.weights[None, :].numpy()) viz.edge_textures = edges_lines[np.newaxis, :, :] viz.update() img = gloo.read_pixels(alpha=False) level_step_counter += 1 global_step += 1
def write_frame(self): if self.video_writer is not None: img = gloo.read_pixels(alpha=False) self.video_writer.append_data(img)
def retrieve_color(self, fbo): self.rgb = gloo.read_pixels( (0, 0, self.size[0], self.size[1]))[:, :, :3] self.rgb = np.copy(self.rgb)
def retrieve_segmentation(self, fbo): # Retrieve the contents of the FBO texture self.segmentation = gloo.read_pixels( (0, 0, self.size[0], self.size[1]))[:, :, :3] self.segmentation = np.copy(self.segmentation)