def __init__(self, surface, sky="fluffy_clouds.png", bed="seabed.png"): app.Canvas.__init__(self, size=(600, 600), title="Water surface simulator 2") self.surface = surface self.sky = io.read_png(sky) self.bed = io.read_png(bed) self.program = gloo.Program(VS, FS_triangle) self.program_point = gloo.Program(VS, FS_point) pos = self.surface.position() self.program["a_position"] = pos self.program_point["a_position"] = pos self.program['u_sky_texture'] = gloo.Texture2D(self.sky, wrapping='repeat', interpolation='linear') self.program['u_bed_texture'] = gloo.Texture2D(self.bed, wrapping='repeat', interpolation='linear') self.program_point["u_eye_height"] = self.program["u_eye_height"] = 3 self.program["u_alpha"] = 0.9 self.program["u_bed_depth"] = 1 self.triangles = gloo.IndexBuffer(self.surface.triangulation()) self.are_points_visible = False self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.activate_zoom() self.show()
def __init__(self, size=(1600, 900), no_distort=False): '''Distorter object: Applies distortion to Contexts and drawables - size (X, Y): Size of monitor - distortion (Bool): Apply distortion or not? ''' self.size = size self.left_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3, )) self.right_eye_tex = gloo.Texture2D(shape=(4096, 4096) + (3, )) self.left_eye = gloo.FrameBuffer(self.left_eye_tex, gloo.RenderBuffer(self.size)) self.right_eye = gloo.FrameBuffer(self.right_eye_tex, gloo.RenderBuffer(self.size)) self.left_eye_program, self.left_eye_indices = Mesh.make_eye( self.left_eye_tex, 'left') self.right_eye_program, self.right_eye_indices = Mesh.make_eye( self.right_eye_tex, 'right') self.IPD = 0.0647 # Interpupilary distance in m # Male: 64.7 mm # Female: 62.3 mm self.L_projection = parameters.projection_left.T self.R_projection = parameters.projection_right.T self.no_distort = no_distort if self.no_distort: self.projection = perspective(30.0, 1920 / float(1080), 2.0, 10.0) self.draw = self.draw_no_distortion else: self.draw = self.draw_distortion
def init_BufX(self): # Create texture to render to # Create FBO, attach the color buffer and depth buffer self._texX = [] self._fboX = [] self._BufX = [] self._texX.append([]) self._fboX.append([]) self._texX.append([]) self._fboX.append([]) for i in range(4): self._texX[0].append( gloo.Texture2D(shape=self._render_size[::-1] + (4, ), format='rgba', interpolation='linear', wrapping='repeat', internalformat='rgba32f')) self._fboX[0].append( gloo.FrameBuffer( self._texX[0][i], gloo.RenderBuffer(shape=self._render_size[::-1]))) self._texX[1].append( gloo.Texture2D(shape=self._render_size[::-1] + (4, ), format='rgba', interpolation='linear', wrapping='repeat', internalformat='rgba32f')) self._fboX[1].append( gloo.FrameBuffer( self._texX[1][i], gloo.RenderBuffer(shape=self._render_size[::-1]))) self._BufX.append( gloo.Program(vertex, fragment_template % error_shader))
def __init__(self): app.Canvas.__init__(self, keys='interactive', size=((512), (512))) self.program = gloo.Program(VERT_SHADER, FRAG_SHADER) self.texture = gloo.Texture2D(I, interpolation='nearest') # using internalformat 'r16f' as discussed in issue #1017 self.kernel = gloo.Texture2D(kernel, interpolation='nearest', internalformat='r16f') self.program['u_texture'] = self.texture self.program['u_kernel'] = self.kernel self.program['u_shape'] = I.shape[1], I.shape[0] self.program['u_interpolation'] = 16 self.names = names self.title = 'Spatial Filtering using %s Filter' % \ self.names[int(self.program['u_interpolation'])] self.program.bind(gloo.VertexBuffer(data)) self.context.set_clear_color('white') self.context.set_viewport(0, 0, 512, 512) self.show()
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))
def __init__(self, shadertoy=None, slowDown=1.0, saveVideo=0, texture=0): global mReadVideo self.cap = None global cap self.cap = 1 if mReadVideo: ret, frame = cap.read(0) #self.frame) #global if ret: cv2.imshow("cap", frame) #pass #use global cap #self.cap = cv2.VideoCapture(mVideoPath) #self.cap.set(cv2.CAP_PROP_POS_FRAMES, 900) #etc. #cap = cv2.VideoCapture(mVideoPath) #self.cap.set(cv2.CAP_PROP_POS_FRAMES, 900) #etc. print(self.cap) app.Canvas.__init__(self, keys='interactive') self.texture = texture if shadertoy is None: shadertoy = """ void main(void) { vec2 uv = gl_FragCoord.xy / iResolution.xy; gl_FragColor = vec4(uv,0.5+0.5*sin(iGlobalTime),1.0); }""" self.save = saveVideo if texture: # Create program self.program = gloo.Program(VERT_SHADER, fragment % shadertoy) # Set uniforms and samplers self.program['a_position'] = gloo.VertexBuffer( positions) #VertexBuffer(positions) self.program['a_texcoord'] = gloo.VertexBuffer( texcoords) #VertexBuffer(texcoords) # self.program['u_texture1'] = gloo.Texture2D(im1) self.program['u_texture2'] = gloo.Texture2D(im2) self.program['u_texture3'] = gloo.Texture2D(im3) else: self.program = gloo.Program(vertex, fragment % shader) self.mSlowDown = slowDown #adjust iTime when rendering is slow 30-7-2019 self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)] self.program['iMouse'] = 0, 0, 0, 0 self.program['iSampleRate'] = 44100. for i in range(4): self.program['iChannelTime[%d]' % i] = 0. self.program['iGlobalTime'] = 0. self.activate_zoom() self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.frame = 0 #+++ self.frameTime = [] #+++ push tuples (frame, time), compute framerate self.show()
def on_timer(self, event): global mReadImages, mReadVideo, cap global frameArr, mFrames if self.texture: #Change on each frame 3-8-2019 if mReadImages: print("self.texture?, frame", self.frame) path = mRootPath + str(self.frame % 8) + ".png" print(path) #im = io.read_png(path) #mRootPath + str(self.frame%8)+".png") im = io.imread(path) #mRootPath + str(self.frame%8)+".png") #imread requires PIL or imageio #directly write video frames from opencv numpy arrays? self.program['u_texture1'] = gloo.Texture2D(im) if mReadVideo: #read video try: if (self.cap): #cv2.waitKey(35) print("mReadVideo?") #cap.set(cv2.CAP_PROP_POS_FRAMES, 0) #ret, frame = self.cap.read(0) #ret, frame = self.cap.read(self.frame) ret, frame = cap.read() #self.frame) #global if ret: cv2.imshow("cap", frame) if ret: self.program['u_texture1'] = gloo.Texture2D(frame) else: print("ret=?, frame=?", ret, frame) self.program['u_texture1'] = gloo.Texture2D( frameArr[self.frame % mFrames]) except (e): print(e) #print("slef.save=", self.save) #sleep(5) if self.save: #True: #self.save==1: print("IN slef.save=", self.save) i = self.render() #without OK? io.write_png(str(self.frame) + ".png", i) #no such: io.write_jpg(str(self.frame)+".jpg", i); #self.mSlowDown = 1; #if not self.mSlowDown: self.mSlowDown = 1 self.program['iTime'] = event.elapsed * self.mSlowDown self.program['iGlobalTime'] = event.elapsed self.program['iDate'] = get_idate() # used in some shadertoy exs #self.update() self.frame += 1 #24-11-2018 print(self.frame) self.frameTime.append((self.frame, event.elapsed)) if (self.frame % frame_divider == 0): ln = len(self.frameTime) fr1, t1 = self.frameTime[ln - 1] fr2, t2 = self.frameTime[ln - 2] fps = (fr1 - fr2) / (t1 - t2) #print({:04.2f} fps, end=", "); print(" %0.2f" % fps, end=", ") sys.stdout.flush() self.update()
def update_frame(self, y_im, y_flow, y_m): self.current_frame = y_im self.current_texture = gloo.Texture2D(y_im) self.current_flowx = y_flow[:,:,0] self.current_fx_texture = gloo.Texture2D(y_flow[:,:,0], format="luminance", internalformat="r32f") self.current_flowy = y_flow[:,:,1] self.current_fy_texture = gloo.Texture2D(y_flow[:,:,1], format="luminance", internalformat="r32f") self.current_mask = 255*y_m self.current_mask_texture = gloo.Texture2D(255*y_m)
def __init__(self, surface, sky="textures/fluffy_clouds.png", bed="textures/sand.png"): # self.method = RungeKutta() self.method = Euler() self.surface = surface self.sky = io.read_png(sky) self.bed = io.read_png(bed) app.Canvas.__init__(self, size=(400, 400), title="water") self.program = gloo.Program(vertex_shader, fragment_shader) self.program_point = gloo.Program(vertex_shader, point_fragment_shader) pos = self.surface.position() self.camera_height = 1.0 self.program["a_position"] = pos self.program_point["a_position"] = pos self.program['u_sky_texture'] = gloo.Texture2D(self.sky, wrapping='repeat', interpolation='linear') self.program['u_bed_texture'] = gloo.Texture2D(self.bed, wrapping='repeat', interpolation='linear') self.program_point['u_camera_height'] = self.program[ 'u_camera_height'] = self.camera_height self.program_point["u_eye_height"] = self.program["u_eye_height"] = 1 self.program["u_alpha"] = 0.9 self.program["u_bed_depth"] = 2 self.program["u_sun_direction"] = normalize([0, 1, 0.1]) self.program["u_sun_diffused_color"] = [1, 0.8, 1] self.program["u_sun_reflected_color"] = [1, 0.8, 0.6] self.program["u_water_ambient_color"] = [0.1, 0.2, 0.2] self.program["u_water_depth_color"] = [0, 0.1, 0.1] self.triangles = gloo.IndexBuffer(self.surface.triangulation()) self.h_description = None self.camera = np.array([0, 0, 1]) self.up = np.array([0, 1, 0]) self.set_camera() self.are_points_visible = False self.drag_start = None self.diffused_flag = True self.reflected_flag = True self.bed_flag = True self.stop_flag = False self.depth_flag = True self.sky_flag = True self.apply_flags() self._timer = app.Timer('auto', connect=self.on_timer, start=True) self.activate_zoom() self.show()
def create_rend_target(size): shape = (size[1], size[0]) rendtex = gloo.Texture2D((*shape, 4), interpolation='linear', internalformat='rgba32f') depthtex = gloo.Texture2D((*shape, 1), format='depth_component', internalformat='depth_component32_oes') framebuffer = gloo.FrameBuffer(rendtex, depthtex) return framebuffer, rendtex, depthtex
def __init__(self, field, spacing=10, segments=3, seg_len=0.5, color=(1, 1, 1, 0.3)): self._time = 0.0 self._last_time = ptime.time() rows = int(field.shape[0] / spacing) cols = int(field.shape[1] / spacing) index = np.empty((rows * cols, int(segments) * 2, 2), dtype=np.float32) # encodes starting position within vector field index[:, :, 0] = np.arange(rows * cols)[:, np.newaxis] # encodes distance along length of line index[:, ::2, 1] = np.arange(segments)[np.newaxis, :] index[:, 1::2, 1] = np.arange(segments)[np.newaxis, :] + 1 self._index = gloo.VertexBuffer(index) if not isinstance(color, np.ndarray): color = np.array([[list(color)]], dtype='float32') self._color = gloo.Texture2D(color) offset = np.random.uniform(256, size=(rows, cols, 3)).astype(np.ubyte) self._offset = gloo.Texture2D(offset, format='rgb') self._field = gloo.Texture2D(field, format='rg', internalformat='rg32f', interpolation='linear') self._field_shape = field.shape[:2] visuals.Visual.__init__(self, vcode=self.vertex, fcode=self.fragment) self.timer = app.Timer(interval='auto', connect=self.update_time, start=False) self.freeze() self.shared_program['field'] = self._field self.shared_program['field_shape'] = self._field.shape[:2] self.shared_program['shape'] = (rows, cols) self.shared_program['index'] = self._index self.shared_program['spacing'] = spacing self.shared_program['t'] = self._time self.shared_program['offset'] = self._offset self.shared_program['speed'] = 1 self.shared_program['color'] = self._color self.shared_program['seg_len'] = seg_len self.shared_program['nseg'] = segments self.shared_program['n_iter'] = 1 self.shared_program['attractor'] = (0, 0) self.shared_program['time'] = 0 self._draw_mode = 'lines' self.set_gl_state('translucent', depth_test=False) self.timer.start()
def generate_image(img_def): c = context.FakeCanvas() img = _load_img(img_def['background']['path']) h, w, _ = img.shape render_fbo = gloo.FrameBuffer(gloo.Texture2D(img), gloo.RenderBuffer( (h, w))) program = gloo.Program(_vert_std, _frag_tex) program['a_pos'] = _unit_square() program['a_tex_coord'] = _unit_square() gloo.set_state(blend=True, blend_func=('one', 'one_minus_src_alpha'), depth_test=True, depth_func='always') with render_fbo: gloo.set_viewport(0, 0, w, h) gloo.set_clear_depth(0) gloo.clear(depth=True, color=False) instances = img_def['instances'] # The unsigned byte depth buffer extraction sets a limit of 255 instances. # Can be extracted as short if necessary. assert (len(instances) <= 255) for i, inst in enumerate(instances): img = _load_img(inst['path']) ih, iw, _ = img.shape x, y, s, r = (inst[k] for k in ['x', 'y', 's', 'r']) program['u_tex'] = gloo.Texture2D(img, interpolation='linear') program['u_mvp'] = \ transforms.translate((-0.5, -0.5, 0)) @ \ transforms.scale((s * iw, s * ih, 1)) @ \ transforms.rotate(r, (0, 0, 1)) @ \ transforms.translate((x, y, -i-1)) @ \ transforms.ortho(0, w, 0, h, 0, 255) program.draw() rgb = render_fbo.read(alpha=False) depth = gl.glReadPixels(0, 0, w, h, gl.GL_DEPTH_COMPONENT, gl.GL_UNSIGNED_BYTE) if not isinstance(depth, np.ndarray): depth = np.frombuffer(depth, np.uint8) depth = np.flip(depth.reshape(h, w), axis=0) masks = np.empty((h, w, len(instances)), np.bool) for i in range(len(instances)): masks[:, :, i] = depth == i + 1 return rgb, depth, masks
def __init__(self, im, conf, roi, logger): vispy.set_log_level('DEBUG') try: vispy.use(app='glfw', gl='gl+') except RuntimeError as e: pass app.Canvas.__init__(self, keys = 'interactive', size = (conf['ipmWidth'], conf['ipmHeight']), position = (0,0), title = 'IPM', show = False, resizable = False) self._rendertex = gloo.Texture2D(shape=(self.size[1], self.size[0], 4)) self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer((self.size[1], self.size[0]))) try: fragmentShaderSourceString = open(FRAGMENT_SHADER_FILENAME).read() except: logger.fatal("%s does not exist !", FRAGMENT_SHADER_FILENAME) sys.exit() try: vertexShaderSourceString = open(VERTEX_SHADER_FILENAME).read() except: logger.fatal("%s does not exist !", VERTEX_SHADER_FILENAME) sys.exit() self.program = gloo.Program(vertexShaderSourceString, fragmentShaderSourceString) self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)] gloo.set_viewport(0, 0, *self.size) tex = gloo.Texture2D(im) tex.interpolation = 'linear' tex.wrapping = 'repeat' self.program['iChannel'] = tex if len(im.shape) == 3: self.program['iChannelResolution'] = (im.shape[1], im.shape[0], im.shape[2]) else: self.program['iChannelResolution'] = (im.shape[1], im.shape[0], 1) self.program['iResolution'] = (self.size[0], self.size[1], 0.) self.getUniforms(conf, roi) self.update() app.run() return self
def set_channel_input(self, img, i=0): tex = gloo.Texture2D(img) tex.interpolation = 'linear' tex.wrapping = 'repeat' self.program['iChannel%d' % i] = tex width, height = img.size self.program['iChannelResolution[%d]' % i] = (width, height, 0.)
def __init__(self,ens_n): app.Canvas.__init__(self,keys='interactive', size=(800, 600)) # Create program self._program = gloo.Program(VERT_SHADER, FRAG_SHADER) self._program.bind(gloo.VertexBuffer(data)) self._program['s_texture'] = gloo.Texture2D(im1) self.transp=np.load('my_spks.npy') self.pos=((np.load('pos.npy')[:10000])*2)-1 self.i=0 self.ens_n=ens_n self.ensemble=np.load('U.npy')[:10000,ens_n] # Create first explosion self._new_explosion() # Enable blending gloo.set_state(blend=True, clear_color='black', blend_func=('src_alpha', 'one')) gloo.set_viewport(0, 0, self.physical_size[0], self.physical_size[1]) self._timer = app.Timer('auto', connect=self.update, start=True) self.i=0 global i i=0
def setField(self, field): self.field = field self.field = gloo.Texture2D(self.field, format='rg', internalformat='rg32f', interpolation='linear') self.shared_program['field'] = self.field
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): 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, texdata, parent, overlay=False): self._parent2 = parent self.overlay = overlay #just set a dummy value self._shape = (10.0, 22500) self.tex = gloo.Texture2D(texdata, format='luminance', internalformat='r32f', interpolation="linear") self.get_data = visuals.shaders.Function(norm_luminance) self.get_data['vmin'] = -80 self.get_data['vmax'] = -40 self.get_data['texture'] = self.tex self.bb = Rect((0, 0, 1, 1)) scene.Image.__init__(self, method='subdivide', grid=(1000, 1), parent=parent) #set in the main program self.shared_program.frag['get_data'] = self.get_data #needs no external color map if self.overlay == "r": self.set_gl_state('additive') self.shared_program.frag[ 'color_transform'] = visuals.shaders.Function(r_cmap) elif self.overlay == "g": self.set_gl_state('additive') self.shared_program.frag[ 'color_transform'] = visuals.shaders.Function(g_cmap)
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__(self): app.Canvas.__init__( self, keys='interactive', size=(800,600), config=dict(samples=4) ) self.V, self.F = create_sphere() self.program = gloo.Program(VSHADER, FSHADER) self.program.bind(self.V) self.program['u_sampler'] = gloo.Texture2D( io.read_png('earth.png'), interpolation='linear') self.th, self.ph = 0., 0. self.delta = 5. self.fov = 80. self.view = lookat(self.th, self.ph) self.model = rotate(180., (1,0,0)) gloo.set_state(depth_test=True) self.set_viewport() self.show()
def test_text(): """Test basic text support""" # test a simple cases data = ( np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0]]) * 255).astype(np.uint8) expd = ( np.array([ [8, 5, 4, 4, 4, 4, 4, 5, 8], [5, 2, 1, 1, 1, 1, 1, 2, 5], [4, 1, 0, 0, 0, 0, 0, 1, 4], [4, 1, 0, -1, -4, -1, 0, 1, 4], # XXX artifact [4, 1, 0, -1, -4, -1, 0, 1, 4], [4, 1, 0, -1, -4, -1, 0, 1, 4] ])) expd = 0.5 - (np.sqrt(np.abs(expd)) * np.sign(expd)) / 256. * 8 expd = np.round(256 * expd).astype(np.int) with Canvas(size=(100, 100)): tex = gloo.Texture2D(shape=data.shape + (3, ), dtype=np.ubyte, format='rgb') SDFRenderer().render_to_texture(data, tex, (0, 0), data.shape[::-1]) gloo.set_viewport(0, 0, *data.shape[::-1]) gloo.util.draw_texture(tex) result = gloo.util._screenshot()[:, :, 0].astype(np.int) print(result) print(expd) assert_allclose(result, expd, atol=1)
def __init__(self, size, num_points: int, center, color, radius): '''[summary] Arguments: size {[type]} -- size of the rendered image num_points {int} -- number of valid depth values center {[type]} -- the (x, y) coordinate of each valid depth value color {[type]} -- encode the 16bit depth value to (R, G) channels, corresponding to 'center' ''' # We hide the canvas upon creation. app.Canvas.__init__(self, show=False, size=size) self._t0 = time() # Texture where we render the scene. self._rendertex = gloo.Texture2D(shape=size[::-1] + (4, )) # FBO. self._fbo = gloo.FrameBuffer(self._rendertex, gloo.RenderBuffer(size[::-1])) # Regular program that will be rendered to the FBO. V = np.zeros(num_points, [("center", np.float32, 2), ("color", np.float32, 3), ("radius", np.float32, 1)]) V["center"] = center V["color"] = color V["radius"] = radius self.program = gloo.Program(vertex, fragment) self.program.bind(gloo.VertexBuffer(V)) self.program['resolution'] = self.size # We manually draw the hidden canvas. self.update()
def __init__(self, canvas=None, _protocol=None): if canvas is None: canvas = gloo.context.FakeCanvas() self.canvas: app.Canvas = canvas self.parameters: Dict[str, Any] = dict() self.custom_programs: Dict[str, gloo.Program] = dict() self.data_appendix: Dict[str, Any] = dict() self.transform_uniforms = dict() self.protocol: protocol.AbstractProtocol = _protocol self._buffer_shape = (calib.CALIB_DISP_WIN_SIZE_HEIGHT, calib.CALIB_DISP_WIN_SIZE_WIDTH) self._out_texture = gloo.Texture2D(self._buffer_shape + (3, ), format='rgb') self._out_fb = gloo.FrameBuffer(self._out_texture) self.frame = self._out_fb # Create display program: renders the out texture from FB to screen self.square = [[-1, -1], [-1, 1], [1, -1], [1, 1]] self._display_prog = gloo.Program(self._vertex_display, self._frag_display, count=4) self._display_prog['a_position'] = self.square self._display_prog['u_texture'] = self._out_texture # Get all visual parameters self.static_parameters: List[Parameter] = [] self.variable_parameters: List[Parameter] = [] self.trigger_functions: List[Callable] = [] self._collect_parameters() self.is_active = True gloo.set_state(depth_test=True)
def load_faces(model, element): # order of minecraft directions to order of cube sides mc_to_opengl = [ "east", # pos x "west", # neg x "up", # pos y "down", # neg y "south", # pos z "north", # neg z ] faces = {} for direction, facedef in element["faces"].items(): # TODO, cache loaded and processed textures! texture_name = model.resolve_texture(facedef["texture"]) if texture_name is None: raise RuntimeError( "Face in direction '%s' has no texture associated" % direction) f = model.load_texture(texture_name) uvs = np.array(facedef.get("uv", [0, 0, 16, 16]), dtype=np.float32) / 16.0 uv0, uv1 = uvs[:2], uvs[2:] image = Image.open(f).convert("RGBA") if texture_name.startswith( "block/") and image.size[0] != image.size[1]: assert image.size[0] < image.size[1] s = image.size[0] image = image.crop((0, 0, s, s)) if "rotation" in facedef: image = image.rotate(-facedef["rotation"]) data = np.array(image) semi_transparent = np.all((data[:, :, 3] == 0) | (data[:, :, 3] == 255)) w, h = image.size image = image.resize((w * 2, h * 2), resample=Image.NEAREST) data = np.array(image) if semi_transparent: data[:, :, 3] = (data[:, :, 3] > 255 / 2.0) * 255 if "blockcrafterTint" in facedef: r, g, b = facedef["blockcrafterTint"] data[:, :, 0] = data[:, :, 0] * r data[:, :, 1] = data[:, :, 1] * g data[:, :, 2] = data[:, :, 2] * b faces[direction] = (gloo.Texture2D(data=data, interpolation="linear"), (uv0, uv1)) f.close() # gather faces in order for cube sides # remember: each side is (texture, (uv0, uv1)) sides = [faces.get(direction, None) for direction in mc_to_opengl] # so this is how an non-existant side looks like empty = (None, None) sides = [(s if s is not None else empty) for s in sides] assert len(sides) == 6 return sides
def load(self, path, demean=False, scale=1.0): data = PlyData.read(path) self.vertices = np.zeros((data['vertex'].count, 3)) self.vertices[:, 0] = np.array(data['vertex']['x']) self.vertices[:, 1] = np.array(data['vertex']['y']) self.vertices[:, 2] = np.array(data['vertex']['z']) self.vertices *= scale self.centroid = np.mean(self.vertices, 0) if demean: self.centroid = np.zeros((1, 3), np.float32) self.vertices -= self.centroid self._compute_bbox() self.indices = np.asarray(list(data['face']['vertex_indices']), np.uint32) filename = path.split('/')[-1] abs_path = path[:path.find(filename)] tex_to_load = None if os.path.exists(abs_path + filename[:-4] + '.jpg'): tex_to_load = abs_path + filename[:-4] + '.jpg' elif os.path.exists(abs_path + filename[:-4] + '.png'): tex_to_load = abs_path + filename[:-4] + '.png' if tex_to_load is not None: image = cv2.flip(cv2.imread(tex_to_load, cv2.IMREAD_UNCHANGED), 0) self.texture = gloo.Texture2D(image) if 'texcoord' in str(data): self.texcoord = np.asarray(list(data['face']['texcoord'])) assert self.indices.shape[0] == self.texcoord.shape[0] temp = np.zeros((data['vertex'].count, 2)) temp[self.indices.flatten()] = self.texcoord.reshape((-1, 2)) self.texcoord = temp elif 'texture_u' in str(data): self.texcoord = np.zeros((data['vertex'].count, 2)) self.texcoord[:, 0] = np.array(data['vertex']['texture_u']) self.texcoord[:, 1] = np.array(data['vertex']['texture_v']) if self.texcoord is not None: vertices_type = [('a_position', np.float32, 3), ('a_texcoord', np.float32, 2)] self.collated = np.asarray(list(zip(self.vertices, self.texcoord)), vertices_type) else: self.colors = 0.5*np.ones((data['vertex'].count, 3)) if 'blue' in str(data): self.colors[:, 0] = np.array(data['vertex']['blue']) self.colors[:, 1] = np.array(data['vertex']['green']) self.colors[:, 2] = np.array(data['vertex']['red']) self.colors /= 255.0 else: pass vertices_type = [('a_position', np.float32, 3), ('a_color', np.float32, 3)] self.collated = np.asarray(list(zip(self.vertices, self.colors)), vertices_type) self.vertex_buffer = gloo.VertexBuffer(self.collated) self.index_buffer = gloo.IndexBuffer(self.indices.flatten())
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 test_buffer(self): # Some data that we need data = np.zeros(100, np.uint16) im2 = np.zeros((50, 50), np.uint16) im3 = np.zeros((20, 20, 20), np.uint16) shaders = gloo.VertexShader("x"), gloo.FragmentShader("x") items = [ # Buffers (gloo.buffer.Buffer(target=gl.GL_ARRAY_BUFFER), 'set_data', data), (gloo.buffer.VertexBuffer(np.uint16), 'set_data', data), (gloo.buffer.ElementBuffer(np.uint16), 'set_data', data), # Textures (gloo.Texture2D(), 'set_data', im2), (gloo.Texture3D(), 'set_data', im3), # FBO stuff (gloo.RenderBuffer(), 'set_shape', (1, 1)), (gloo.FrameBuffer(), 'attach_color', gloo.RenderBuffer((1, 1))), # Shader stuff (gloo.VertexShader(), 'set_code', "x"), (gloo.FragmentShader(), 'set_code', "x"), (gloo.Program(), 'attach', shaders), ] for ob, funcname, value in items: self._fix_ob(ob) #print('Testing GLObject compliance for %s' % ob.__class__.__name__) # Initially a clear state self.assertEqual(ob._need_update, False) # Set value, now we should have a "dirty" state x = ob for part in funcname.split('.'): x = getattr(x, part) x(value) self.assertEqual(ob._need_update, True) # Activate the object ob.activate() # Now we should be activated self.assertEqual(len(ob._actions), 3) self.assertEqual(ob._actions[0], 'create') self.assertEqual(ob._actions.count('update'), 1) self.assertEqual(ob._actions.count('activate'), 1) # Deactivate ob.deactivate() # Now we should be deactivated self.assertEqual(len(ob._actions), 4) self.assertEqual(ob._actions[-1], 'deactivate') # Activate some more for i in range(10): ob.activate() # Create and update should not have been called self.assertEqual(ob._actions.count('create'), 1) self.assertEqual(ob._actions.count('update'), 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, size=(800, 480), title="Euclidean honeycombs and their duals", glsl_code="./glsl/euclidean_honeycombs.frag"): app.Canvas.__init__(self, keys="interactive", size=size, title=title) with open(glsl_code, "r") as f: code = f.read() self.program = gloo.Program(vertex, fragment % code) self.program["position"] = [(-1, -1), (-1, 1), (1, 1), (-1, -1), (1, 1), (1, -1)] self.program["iTime"] = 0. self.program["iResolution"] = (self.physical_size[0], self.physical_size[1], 0) self.program["iMouse"] = (0, 0, 0, 0) self.T = [1, 1, 1, 0] self.latticeType = 0 self.dual = False self.snub = False self.program["T"] = self.T self.program["latticeType"] = self.latticeType self.program["snub"] = self.snub self.program["dual"] = self.dual img = imread("./glsl/rusty_metal.jpg") tex = gloo.Texture2D(img) tex.interpolation = "linear" tex.wrapping = "repeat" self.program["iChannel0"] = tex self.timer = app.Timer('auto', connect=self.on_timer, start=False)