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)
