def __enter__(self): # Save viewport for final rendering self._viewport = gl.glGetIntegerv(gl.GL_VIEWPORT) # Prepare framebuffer for "original" rendering gl.glViewport(0, 0, self.width, self.height) self._framebuffers[0].activate()
def draw_depth(shape, vertex_buffer, index_buffer, mat_model, mat_view, mat_proj): program = gloo.Program(_depth_vertex_code, _depth_fragment_code) program.bind(vertex_buffer) program['u_mv'] = _compute_model_view(mat_model, mat_view) program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj) # Frame buffer object color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled gl.glClearColor(0.0, 0.0, 0.0, 0.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, shape[1], shape[0]) # Rendering program.draw(gl.GL_TRIANGLES, index_buffer) # Retrieve the contents of the FBO texture depth = np.zeros((shape[0], shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, depth) depth.shape = shape[0], shape[1], 4 depth = depth[::-1, :] depth = depth[:, :, 0] # Depth is saved in the first channel fbo.deactivate() return depth
def render_texture(self, texture): self.before_render(texture) #print("Rendering %s to texture" % repr(self)) fbo_size = None if self._force_size is not None: fbo_size = self._force_size elif texture is not None: h, w, _ = texture.shape fbo_size = w, h elif self.preferred_size is not None: fbo_size = self.preferred_size else: assert False, "A preferred size must be set if there is no input texture / no size forced" fbo = self.fbo(fbo_size) fbo.activate() gl.glViewport(0, 0, fbo_size[0], fbo_size[1]) gl.glClearColor(0.0, 0.0, 0.0, 0.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) self._transform_flipy = True self.render(texture, fbo_size) fbo.deactivate() self.after_render() return fbo.color[0]
def __exit__(self, type, value, traceback): # Done with "original" rendering self._framebuffers[0].deactivate() # Actual filtering starts here gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glDisable(gl.GL_DEPTH_TEST) # Apply all filters using ping-pong framebuffers index = 0 for i in range(len(self._programs)-1): program = self._programs[i] if i == 0: # special case for first rendering program['filtered'] = self._framebuffers[0].color[0] else: program['filtered'] = self._framebuffers[1+index].color[0] index = (index + 1) % 2 # ping-pong self._framebuffers[index+1].activate() self._programs[i].draw(gl.GL_TRIANGLE_STRIP) self._framebuffers[index+1].deactivate() # Final rendering (no transformation) at original viewport size program = self._programs[-1] program['filtered'] = self._framebuffers[index+1].color[0] gl.glViewport( *self._viewport ) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glDisable(gl.GL_DEPTH_TEST) program.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt): # window.clear() global rgb extent_shape = (int(shape[0] * ssaa), int(shape[1] * ssaa)) # Frame buffer object color_buf = np.zeros((extent_shape[0], extent_shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((extent_shape[0], extent_shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() # OpenGL setup gl.glEnable(gl.GL_DEPTH_TEST) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, extent_shape[1], extent_shape[0]) gl.glDisable(gl.GL_CULL_FACE) program.draw(gl.GL_TRIANGLES, I) rgb = np.zeros((extent_shape[0], extent_shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, extent_shape[1], extent_shape[0], gl.GL_RGBA, gl.GL_FLOAT, rgb) rgb.shape = extent_shape[0], extent_shape[1], 4 rgb = rgb[::-1, :] rgb = np.round(rgb[:, :, :3] * 255).astype( np.uint8) # Convert to [0, 255] import cv2 rgb = cv2.resize(rgb, shape, interpolation=cv2.INTER_AREA) fbo.deactivate()
def activate(self, clear=False): gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, 0) gl.glViewport(0, 0, self.width, self.height) if clear: # self._win.clear() gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glEnable(gl.GL_DEPTH_TEST) yield self
def on_resize(width, height): gl.glViewport(0, 0, width, height) C['projection'] = glm.ortho(0, width, 0, height, -1, +1) i = 0 for x in [0,width//2, width]: for y in [0,height//2, height]: C[i]['translate'] = x,y i += 1
def render_screen(self, texture, screen_size): self.before_render(texture) #print("Rendering %s to screen" % repr(self)) gl.glViewport(0, 0, screen_size[0], screen_size[1]) self._transform_flipy = False self.render(texture, screen_size) self.after_render()
def draw_color(shape, vertex_buffers, index_buffers, mat_models, mat_views, mat_projs, ambient_weight, light_color, bg_color): assert (len(vertex_buffers) == len(index_buffers)) assert (len(vertex_buffers) == len(mat_models)) assert (len(vertex_buffers) == len(mat_views)) assert (len(vertex_buffers) == len(mat_projs)) program = gloo.Program(_color_vertex_code, _color_fragment_code) # Frame buffer object color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() # OpenGL setup gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3]) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, shape[1], shape[0]) for i in xrange(len(vertex_buffers)): vertex_buffer = vertex_buffers[i] index_buffer = index_buffers[i] mat_model = mat_models[i] mat_view = mat_views[i] mat_proj = mat_projs[i] program.bind(vertex_buffer) program['u_light_eye_pos'] = [0, 0, 0] program['light_color'] = [ light_color[0], light_color[1], light_color[2] ] program['u_light_ambient_w'] = ambient_weight program['u_mv'] = _compute_model_view(mat_model, mat_view) program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj) # Rendering program.draw(gl.GL_TRIANGLES, index_buffer) # Retrieve the contents of the FBO texture rgb = np.zeros((shape[0], shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, rgb) rgb.shape = shape[0], shape[1], 4 rgb = rgb[::-1, :] rgb = np.round(rgb[:, :, :3] * 255).astype(np.uint8) # Convert to [0, 255] fbo.deactivate() return rgb
def initgl(self): if not self.pycuda_initialized: self.setup_gl(self.width, self.height) self.pycuda_initialized = True """Initalize gl states when the frame is created""" gl.glViewport(0, 0, self.width, self.height) gl.glClearColor(0.0, 0.0, 0.0, 0.0) self.dt_history = [1000 / 60] self.t0 = time.time() self.t_last = self.t0 self.nframes = 0
def activate(self): """prepare to draw: increment self.head, invalidate the cpu rep and activate the render target """ gl.glViewport(0, 0, *self.size) if self.n: # gl.glPushAttrib(gl.GL_VIEWPORT_BIT) self.head = (self.head + 1) % self.n self._state[self.head].activate() if not self.autoread: self.cpu_state = None
def on_draw(dt): simulation.on_draw(dt) GUI.on_draw(dt) render["texture"][:, gui_height:gui_height+cheight, 0] = simulation.cells render["texture"][:, :gui_height, 0] = GUI.pixels # gl.glDisable(gl.GL_BLEND) # gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glViewport(0, 0, window.width, window.height) render.draw(gl.GL_TRIANGLE_STRIP)
def draw_label(shape, vertex_buffers, index_buffers, mat_models, mat_views, mat_projs, labels): assert (len(vertex_buffers) == len(index_buffers)) assert (len(vertex_buffers) == len(mat_models)) assert (len(vertex_buffers) == len(mat_views)) assert (len(vertex_buffers) == len(mat_projs)) assert (labels is not None) assert (len(vertex_buffers) == len(labels)) program = gloo.Program(_label_vertex_code, _label_fragment_code) # Frame buffer object color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() # OpenGL setup gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled gl.glClearColor(0.0, 0.0, 0.0, 0.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, shape[1], shape[0]) for i in range(len(vertex_buffers)): vertex_buffer = vertex_buffers[i] index_buffer = index_buffers[i] mat_model = mat_models[i] mat_view = mat_views[i] mat_proj = mat_projs[i] label = labels[i] program.bind(vertex_buffer) program['u_mv'] = _compute_model_view(mat_model, mat_view) # program['u_nm'] = compute_normal_matrix(model, view) program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj) program['label'] = label # Rendering program.draw(gl.GL_TRIANGLES, index_buffer) # Retrieve the contents of the FBO texture label_map = np.zeros((shape[0], shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, label_map) label_map.shape = shape[0], shape[1], 4 label_map = label_map[::-1, :] label_map = label_map[:, :, 0] fbo.deactivate() return label_map
def activate(self, clear=False): self._framebuffer.activate() gl.glViewport(0, 0, self.width, self.height) if clear: # color_attachment_flags = [] # for i in range(len(self._color_attachments)): # color_attachment_flags.append(gl.GL_COLOR_ATTACHMENT0 + i) # gl.glDrawBuffers(np.array(color_attachment_flags, dtype=np.uint32)) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glEnable(gl.GL_DEPTH_TEST) yield self self._framebuffer.deactivate()
def render(self, size, render_func): fbo = self.get_fbo(size) fbo.activate() gl.glViewport(0, 0, size[0], size[1]) gl.glClearColor(0.0, 0.0, 0.0, 0.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) render_func() fbo.deactivate() return fbo.color[0]
def on_resize(w, h): if w > h: x = (w - h) / 2 y = 0 w = h else: x = 0 y = (h - w) / 2 h = w gl.glViewport(int(x), int(y), int(w), int(h)) window.dispatch_event('on_draw', 0.0) window.swap() return True
def on_resize(width, height): if width > height: x = (width - height) / 2 y = 0 w = h = height else: x = 0 y = (height - width) / 2 w = h = width gl.glViewport(int(x), int(y), int(w), int(h)) window.dispatch_event('on_draw', 0.0) window.swap() return True
def draw(self): # consume all segments present at start of drawing with self.target: gl.glViewport(0, 0, *self.target.size) gl.glClear(gl.GL_COLOR_BUFFER_BIT) n = self.segments.qsize() for _ in range(n): p, c, s = self.segments.get() self.data['a_position'][:] = p self.data['a_color'][:] = c self.data['a_size'][:] = s # gl.glClearColor(0,0,0,0.001) # gl.glEnable(gl.GL_BLEND) # gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) self.program.draw(gl.GL_POINTS)
def draw_depth(shape, vertex_buffer, index_buffer, mat_model, mat_view, mat_proj): assert type(mat_view) is list, 'Requires list of arrays.' program = gloo.Program(_depth_vertex_code, _depth_fragment_code) program.bind(vertex_buffer) # Frame buffer object color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() # OpenGL setup gl.glEnable(gl.GL_DEPTH_TEST) gl.glClearColor(0.0, 0.0, 0.0, 0.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, shape[1], shape[0]) for i in range(len(mat_view)): program['u_mv'] = _compute_model_view(mat_model, mat_view[i]) program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view[i], mat_proj) # Keep the back-face culling disabled because of objects which do not have # well-defined surface (e.g. the lamp from the dataset of Hinterstoisser) gl.glDisable(gl.GL_CULL_FACE) # gl.glEnable(gl.GL_CULL_FACE) # gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled # Rendering program.draw(gl.GL_TRIANGLES, index_buffer) # Retrieve the contents of the FBO texture depth = np.zeros((shape[0], shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, depth) depth.shape = shape[0], shape[1], 4 depth = depth[::-1, :] depth = depth[:, :, 0] # Depth is saved in the first channel fbo.deactivate() return depth
def on_draw(dt): gl.glViewport(0, 0, GridWidth, GridHeight) gl.glDisable(gl.GL_BLEND) Advect(Velocity.Ping, Velocity.Ping, Obstacles, Velocity.Pong, VelocityDissipation) Velocity.swap() Advect(Velocity.Ping, Temperature.Ping, Obstacles, Temperature.Pong, TemperatureDissipation) Temperature.swap() Advect(Velocity.Ping, Density.Ping, Obstacles, Density.Pong, DensityDissipation) Density.swap() ApplyBuoyancy(Velocity.Ping, Temperature.Ping, Density.Ping, Velocity.Pong) Velocity.swap() ApplyImpulse(Temperature.Ping, ImpulsePosition, ImpulseTemperature) ApplyImpulse(Density.Ping, ImpulsePosition, ImpulseDensity) ComputeDivergence(Velocity.Ping, Obstacles, Divergence) ClearSurface(Pressure.Ping, 0.0) for i in range(NumJacobiIterations): Jacobi(Pressure.Ping, Divergence, Obstacles, Pressure.Pong) Pressure.swap() SubtractGradient(Velocity.Ping, Pressure.Ping, Obstacles, Velocity.Pong) Velocity.swap() gl.glViewport(0, 0, window.width, window.height) gl.glClearColor(0, 0, 0, 1) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) prog_visualize['u_data'] = Density.Ping.texture prog_visualize['u_shape'] = Density.Ping.texture.shape[ 1], Density.Ping.texture.shape[0] prog_visualize['u_kernel'] = data.get("spatial-filters.npy") prog_visualize["Sampler"] = Density.Ping.texture prog_visualize["FillColor"] = 0.95, 0.925, 1.00 prog_visualize["Scale"] = 1.0 / window.width, 1.0 / window.height prog_visualize.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt): global pingpong pingpong = 1 - pingpong compute["pingpong"] = pingpong render["pingpong"] = pingpong gl.glDisable(gl.GL_BLEND) framebuffer.activate() gl.glViewport(0, 0, cwidth, cheight) compute.draw(gl.GL_TRIANGLE_STRIP) framebuffer.deactivate() gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glViewport(0, 0, window.width, window.height) render.draw(gl.GL_TRIANGLE_STRIP)
def draw_label(shape, vertex_buffer, index_buffer, texture, mat_model, mat_view, mat_proj, ambient_weight, bg_color, shading, inst_ids): assert type(mat_view) is list, 'Requires list of arrays.' program = gloo.Program(_label_vertex_code, _label_fragment_code) program.bind(vertex_buffer) # FBO color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() # OpenGL setup gl.glEnable(gl.GL_DEPTH_TEST) gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3]) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, shape[1], shape[0]) print('inst ids = ' + str(inst_ids)) for i in range(len(mat_view)): program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view[i], mat_proj) program['inst_id'] = inst_ids[ i] / 255. # input instance-id is mapped to range [0,1] gl.glDisable(gl.GL_CULL_FACE) program.draw(gl.GL_TRIANGLES, index_buffer) label = np.zeros((shape[0], shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, label) label.shape = shape[0], shape[1], 4 label = label[::-1, :] label = np.round(label[:, :, 0] * 255).astype( np.uint8) # Label is saved in the first channel fbo.deactivate() return label
def CreateObstacles(dest, width, height): dest.activate() gl.glViewport(0, 0, width, height) gl.glClearColor(0, 0, 0, 0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) T = np.ones((height, width, 3), np.float32).view(gloo.Texture2D) T[+1:-1, +1:-1] = 0.0 T[..., 0] += disc(shape=(GridHeight, GridWidth), center=(GridHeight / 2, GridWidth / 2), radius=32) T[..., 2] += -2 * disc(shape=(GridHeight, GridWidth), center=(GridHeight / 2, GridWidth / 2), radius=32) prog_fill["Sampler"] = T prog_fill.draw(gl.GL_TRIANGLE_STRIP) dest.deactivate()
def CreateObstacles(dest, width, height): dest.activate() gl.glViewport(0, 0, width, height) gl.glClearColor(0, 0, 0, 0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) T = np.ones((height,width,3), np.float32).view(gloo.Texture2D) T[+1:-1,+1:-1] = 0.0 T[...,0] += disc(shape = (GridHeight,GridWidth), center = (GridHeight/2,GridWidth/2), radius = 32) T[...,2] += -2*disc(shape = (GridHeight,GridWidth), center = (GridHeight/2,GridWidth/2), radius = 32) prog_fill["Sampler"] = T prog_fill.draw(gl.GL_TRIANGLE_STRIP) dest.deactivate()
def __init__(self, model, im_size, texture=None, bg_color=(0.0, 0.0, 0.0, 0.0), ambient_weight=0.5, shading='flat', mode='rgb+depth'): # Set texture / color of vertices texture_uv = np.zeros((model['pts'].shape[0], 2), np.float32) colors = np.ones((model['pts'].shape[0], 3), np.float32) * 0.5 # Set the vertex data vertices_type = [('a_position', np.float32, 3), ('a_normal', np.float32, 3), ('a_color', np.float32, colors.shape[1]), ('a_texcoord', np.float32, 2)] vertices = np.array( list(zip(model['pts'], model['normals'], colors, texture_uv)), vertices_type) # Create buffers self.vertex_buffer = vertices.view(gloo.VertexBuffer) self.index_buffer = model['faces'].flatten().astype(np.uint32).view( gloo.IndexBuffer) self.window = app.Window(visible=False) self.program = gloo.Program(_normal_vertex_code, _normal_fragment_code) self.program.bind(self.vertex_buffer) scale = max(im_size) shape = (scale, scale) color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() gl.glEnable(gl.GL_DEPTH_TEST) gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3]) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, shape[1], shape[0]) gl.glDisable(gl.GL_CULL_FACE)
def on_draw(dt): framebuffer.activate() gl.glViewport(0, 0, w, h) window.clear() scene.draw(gl.GL_TRIANGLE_STRIP) framebuffer.deactivate() gl.glViewport(0, 0, zoom * w, zoom * h) window.clear() output.draw(gl.GL_TRIANGLE_STRIP) image = np.zeros((window.height, window.width * 3), dtype=np.uint8) gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, image) image[...] = image[::-1, :] # filename = "triangle-sdf-filled.png" filename = "triangle-sdf-outlined.png" png.from_array(image, 'RGB').save(filename)
def on_draw(dt): gl.glViewport(0, 0, GridWidth, GridHeight) gl.glDisable(gl.GL_BLEND) Advect(Velocity.Ping, Velocity.Ping, Obstacles, Velocity.Pong, VelocityDissipation) Velocity.swap() Advect(Velocity.Ping, Temperature.Ping, Obstacles, Temperature.Pong, TemperatureDissipation) Temperature.swap() Advect(Velocity.Ping, Density.Ping, Obstacles, Density.Pong, DensityDissipation) Density.swap() ApplyBuoyancy(Velocity.Ping, Temperature.Ping, Density.Ping, Velocity.Pong) Velocity.swap() ApplyImpulse(Temperature.Ping, ImpulsePosition, ImpulseTemperature) ApplyImpulse(Density.Ping, ImpulsePosition, ImpulseDensity) ComputeDivergence(Velocity.Ping, Obstacles, Divergence) ClearSurface(Pressure.Ping, 0.0) for i in range(NumJacobiIterations): Jacobi(Pressure.Ping, Divergence, Obstacles, Pressure.Pong) Pressure.swap() SubtractGradient(Velocity.Ping, Pressure.Ping, Obstacles, Velocity.Pong) Velocity.swap() gl.glViewport(0,0,window.width,window.height) gl.glClearColor(0, 0, 0, 1) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) prog_visualize['u_data'] = Density.Ping.texture prog_visualize['u_shape'] = Density.Ping.texture.shape[1], Density.Ping.texture.shape[0] prog_visualize['u_kernel'] = data.get("spatial-filters.npy") prog_visualize["Sampler"] = Density.Ping.texture prog_visualize["FillColor"] = 0.95, 0.925, 1.00 prog_visualize["Scale"] = 1.0/window.width, 1.0/window.height prog_visualize.draw(gl.GL_TRIANGLE_STRIP)
def _draw_rgb(self, obj_id, mat_model, mat_view, mat_proj): """Renders an RGB image. :param obj_id: ID of the object model to render. :param mat_model: 4x4 ndarray with the model matrix. :param mat_view: 4x4 ndarray with the view matrix. :param mat_proj: 4x4 ndarray with the projection matrix. :return: HxWx3 ndarray with the rendered RGB image. """ # Update the OpenGL program. program = self.rgb_programs[obj_id] program['u_light_eye_pos'] = [0, 0, 0] # Camera origin. program['u_light_ambient_w'] = self.light_ambient_weight program['u_mv'] = _calc_model_view(mat_model, mat_view) program['u_nm'] = _calc_normal_matrix(mat_model, mat_view) program['u_mvp'] = _calc_model_view_proj(mat_model, mat_view, mat_proj) # OpenGL setup. gl.glEnable(gl.GL_DEPTH_TEST) gl.glClearColor(self.bg_color[0], self.bg_color[1], self.bg_color[2], self.bg_color[3]) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, self.width, self.height) # Keep the back-face culling disabled because of objects which do not have # well-defined surface (e.g. the lamp from the lm dataset). gl.glDisable(gl.GL_CULL_FACE) # Rendering. program.draw(gl.GL_TRIANGLES, self.index_buffers[obj_id]) # Get the content of the FBO texture. rgb = np.zeros((self.height, self.width, 4), dtype=np.float32) gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGBA, gl.GL_FLOAT, rgb) rgb.shape = (self.height, self.width, 4) rgb = rgb[::-1, :] rgb = np.round(rgb[:, :, :3] * 255).astype( np.uint8) # Convert to [0, 255]. return rgb
def draw_depth(self, shape, vertex_buffer, index_buffer, texture, mat_model, mat_view, mat_proj, ambient_weight, bg_color, shading): self.program['u_mv'] = _compute_model_view(mat_model, mat_view) self.program['u_mvp'] = _compute_model_view_proj( mat_model, mat_view, mat_proj) gl.glViewport(0, 0, shape[1], shape[0]) # Rendering self.program.draw(gl.GL_TRIANGLES, index_buffer) # Retrieve the contents of the FBO texture depth = np.zeros((shape[0], shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, depth) depth.shape = shape[0], shape[1], 4 depth = depth[::-1, :] depth = depth[:, :, 0] # Depth is saved in the first channel return depth
def on_draw(dt): surface_ref.set_array(Density.ping_array) kernel_function(np.int32(400), np.int32(400), block=(16,16,1), grid=((400+1)//16+1,(400+1)//16+1)) gl.glViewport(0,0,window.width,window.height) gl.glClearColor(0, 0, 0, 1) gl.glClear(gl.GL_COLOR_BUFFER_BIT) gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) global t t += dt prog_visualize['u_data'] = Density.Ping.texture prog_visualize['t'] = t prog_visualize['u_shape'] = Density.Ping.texture.shape[1], Density.Ping.texture.shape[0] prog_visualize['u_kernel'] = data.get("spatial-filters.npy") prog_visualize["Sampler"] = Density.Ping.texture prog_visualize["FillColor"] = 0.95, 0.925, 1.00 prog_visualize["Scale"] = 1.0/window.width, 1.0/window.height prog_visualize.draw(gl.GL_TRIANGLE_STRIP) Density.swap()
def on_draw(self, dt): self.last_view_matrix = self.get_next_view_matrix( self.n_frame, self.t_elapsed) self.last_frame = self.render_frame(self.last_view_matrix) if self.out_buffer_location == 'torch': cpy_tensor_to_texture(self.last_frame, self.screen_tex_cuda) self.window.clear() gl.glDisable(gl.GL_CULL_FACE) # ensure viewport size is correct (offline renderer could change it) gl.glViewport(0, 0, self.viewport_size[0], self.viewport_size[1]) self.screen_program.draw(gl.GL_TRIANGLE_STRIP) self.n_frame += 1 self.t_elapsed += dt if self.args.nearest_train: ni = nearest_train( self.scene_data['view_matrix'], np.linalg.inv(self.scene_data['model3d_origin']) @ self.last_view_matrix) label = self.scene_data['camera_labels'][ni] assert self.args.gt, 'you must define path to gt images' path = self.args.gt.replace('*', str(label)) if not os.path.exists(path): print(f'{path} NOT FOUND!') elif self.last_gt_image != path: self.last_gt_image = path img = cv2.imread(path) max_side = max(img.shape[:2]) s = 1024 / max_side img = cv2.resize(img, None, None, s, s) cv2.imshow('nearest train', img) cv2.waitKey(1)
def on_draw(dt): global framebuffer, offset_index offset_name = list(offsets.keys())[offset_index] offset = offsets[offset_name] gl.glViewport(0, 0, width, height) framebuffer_2.activate() window.clear() framebuffer_2.deactivate() for dx, dy in offset: framebuffer_1.activate() window.clear() scene["offset"] = (2 * dx - 1) / width, (2 * dy - 1) / height scene.draw(gl.GL_TRIANGLE_STRIP) # scene.draw(gl.GL_LINE_LOOP) framebuffer_1.deactivate() framebuffer_2.activate() gl.glEnable(gl.GL_BLEND) gl.glBlendFunc(gl.GL_CONSTANT_ALPHA, gl.GL_ONE) gl.glBlendColor(0, 0, 0, 1 / len(offset)) ssaa.draw(gl.GL_TRIANGLE_STRIP) gl.glDisable(gl.GL_BLEND) framebuffer_2.deactivate() gl.glViewport(0, 0, window.width, window.height) window.clear() final.draw(gl.GL_TRIANGLE_STRIP) gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer) framebuffer[...] = framebuffer[::-1, :] # filename = "triangle-ssaa-outlined-%s.png" % offset_name filename = "triangle-ssaa-filled-%s.png" % offset_name png.from_array(framebuffer, 'RGB').save(filename) offset_index += 1
def draw_color(shape, vertex_buffer, index_buffer, mat_model, mat_view, mat_proj, ambient_weight, bg_color): program = gloo.Program(_color_vertex_code, _color_fragment_code) program.bind(vertex_buffer) program['u_light_eye_pos'] = [0, 0, 0] program['u_light_ambient_w'] = ambient_weight program['u_mv'] = _compute_model_view(mat_model, mat_view) # program['u_nm'] = compute_normal_matrix(model, view) program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj) # Frame buffer object color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() # OpenGL setup gl.glEnable(gl.GL_DEPTH_TEST) gl.glEnable(gl.GL_CULL_FACE) gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3]) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, shape[1], shape[0]) # Rendering program.draw(gl.GL_TRIANGLES, index_buffer) # Retrieve the contents of the FBO texture rgb = np.zeros((shape[0], shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, rgb) rgb.shape = shape[0], shape[1], 4 rgb = rgb[::-1, :] rgb = np.round(rgb[:, :, :3] * 255).astype(np.uint8) # Convert to [0, 255] fbo.deactivate() return rgb
def _draw_depth(self, obj_id, mat_model, mat_view, mat_proj): """Renders a depth image. :param obj_id: ID of the object model to render. :param mat_model: 4x4 ndarray with the model matrix. :param mat_view: 4x4 ndarray with the view matrix. :param mat_proj: 4x4 ndarray with the projection matrix. :return: HxW ndarray with the rendered depth image. """ # Update the OpenGL program. program = self.depth_programs[obj_id] program['u_mv'] = _calc_model_view(mat_model, mat_view) program['u_mvp'] = _calc_model_view_proj(mat_model, mat_view, mat_proj) # OpenGL setup. gl.glEnable(gl.GL_DEPTH_TEST) gl.glClearColor(0.0, 0.0, 0.0, 0.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, self.width, self.height) # Keep the back-face culling disabled because of objects which do not have # well-defined surface (e.g. the lamp from the lm dataset). gl.glDisable(gl.GL_CULL_FACE) # Rendering. program.draw(gl.GL_TRIANGLES, self.index_buffers[obj_id]) # Get the content of the FBO texture. depth = np.zeros((self.height, self.width, 4), dtype=np.float32) gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGBA, gl.GL_FLOAT, depth) depth.shape = (self.height, self.width, 4) depth = depth[::-1, :] depth = depth[:, :, 0] # Depth is saved in the first channel return depth
def draw_color(shape, vertex_buffer, index_buffer, texture, mat_model, mat_view, mat_proj, ambient_weight, bg_color, shading): # Set shader for the selected shading if shading == 'flat': color_fragment_code = _color_fragment_flat_code else: # 'phong' color_fragment_code = _color_fragment_phong_code program = gloo.Program(_color_vertex_code, color_fragment_code) program.bind(vertex_buffer) program['u_light_eye_pos'] = [0, 0, 0] # Camera origin program['u_light_ambient_w'] = ambient_weight program['u_mv'] = _compute_model_view(mat_model, mat_view) program['u_nm'] = _compute_normal_matrix(mat_model, mat_view) program['u_mvp'] = _compute_model_view_proj(mat_model, mat_view, mat_proj) if texture is not None: program['u_use_texture'] = int(True) program['u_texture'] = texture else: program['u_use_texture'] = int(False) program['u_texture'] = np.zeros((1, 1, 4), np.float32) # Frame buffer object color_buf = np.zeros((shape[0], shape[1], 4), np.float32).view(gloo.TextureFloat2D) depth_buf = np.zeros((shape[0], shape[1]), np.float32).view(gloo.DepthTexture) fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf) fbo.activate() # OpenGL setup gl.glEnable(gl.GL_DEPTH_TEST) gl.glClearColor(bg_color[0], bg_color[1], bg_color[2], bg_color[3]) gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT) gl.glViewport(0, 0, shape[1], shape[0]) # gl.glEnable(gl.GL_BLEND) # gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA) # gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST) # gl.glHint(gl.GL_POLYGON_SMOOTH_HINT, gl.GL_NICEST) # gl.glDisable(gl.GL_LINE_SMOOTH) # gl.glDisable(gl.GL_POLYGON_SMOOTH) # gl.glEnable(gl.GL_MULTISAMPLE) # Keep the back-face culling disabled because of objects which do not have # well-defined surface (e.g. the lamp from the dataset of Hinterstoisser) gl.glDisable(gl.GL_CULL_FACE) # gl.glEnable(gl.GL_CULL_FACE) # gl.glCullFace(gl.GL_BACK) # Back-facing polygons will be culled # Rendering program.draw(gl.GL_TRIANGLES, index_buffer) # Retrieve the contents of the FBO texture rgb = np.zeros((shape[0], shape[1], 4), dtype=np.float32) gl.glReadPixels(0, 0, shape[1], shape[0], gl.GL_RGBA, gl.GL_FLOAT, rgb) rgb.shape = shape[0], shape[1], 4 rgb = rgb[::-1, :] rgb = np.round(rgb[:, :, :3] * 255).astype(np.uint8) # Convert to [0, 255] fbo.deactivate() return rgb
def on_resize(width, height): gl.glViewport(0, 0, width, height) cube['projection'] = glm.perspective(45.0, width / float(height), 2.0, 100.0) pixelate.viewport = 0, 0, width, height
def on_resize(width, height): gl.glViewport(0, 0, width, height) projection = glm.ortho(0, width, 0, height, -1, +1) program['u_projection'] = projection
def on_resize(width, height): gl.glViewport(0, 0, width, height) update_grid(width, height)
def on_resize(width, height): gl.glViewport(0, 0, width, height)
def on_resize(width, height): gl.glViewport(0, 0, width, height) C['projection'] = glm.ortho(0, width, 0, height, -1, +1) C['translate'] = width//2,height//2
def on_resize(width, height): gl.glViewport(0, 0, width, height) projection = glm.perspective(45.0, width / float(height), 1.0, 1000.0) program["u_projection"] = projection
def on_resize(width, height): gl.glViewport(0, 0, width, height) program["u_size"] = width, height
def on_resize(self, width, height): """" Default resize handler that set viewport """ gl.glViewport(0, 0, width, height) self.dispatch_event('on_draw', 0.0) self.swap()