def on_draw(dt):
global phi, theta, duration, i, cube_prog, indices
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cube_prog.draw(gl.GL_TRIANGLES, indices)
# Rotate cube
theta += random.randint(0, 300) # degrees
phi += random.randint(0, 300) # degrees
view = cube_prog['u_view'].reshape(4, 4)
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube_prog['u_model'] = model
cube_prog['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
if i < count:
framebuffer = 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, framebuffer)
png.from_array(framebuffer, 'RGB').save("color/" + str(dice_val) +
"_" + str(i) + '.png')
i += 1
else:
app.quit()
i = 0
def on_draw(dt):
global phi, theta, writer, duration
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cube.draw(gl.GL_TRIANGLES, faces)
# Write one frame
if writer is not None:
if duration > 0:
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, fbuffer)
writer.write_frame(fbuffer)
duration -= dt
else:
writer.close()
writer = None
# Make cube rotate
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['model'] = model
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(self, r, t, r_type="quat"):
if r_type == "quat":
R = quat2mat(r)
elif r_type == "mat":
R = r
self.render_kernel["u_view"] = self._get_view_mtx(R, t)
app.run(framecount=0)
rgb_buffer = 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_buffer)
rgb_gl = np.copy(rgb_buffer)
rgb_gl.shape = 480, 640, 4
rgb_gl = rgb_gl[::-1, :]
rgb_gl = np.round(rgb_gl[:, :, :3] * 255).astype(
np.uint8) # Convert to [0, 255]
bgr_gl = rgb_gl[:, :, [2, 1, 0]]
depth_buffer = np.zeros((self.height, self.width), dtype=np.float32)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_DEPTH_COMPONENT,
gl.GL_FLOAT, depth_buffer)
depth_gl = np.copy(depth_buffer)
depth_gl.shape = 480, 640
depth_gl = depth_gl[::-1, :]
depth_bg = depth_gl == 1
depth_gl = 2 * self.zFar * self.zNear / (self.zFar + self.zNear -
(self.zFar - self.zNear) *
(2 * depth_gl - 1))
depth_gl[depth_bg] = 0
return bgr_gl, depth_gl
def on_key_press(self, k, modifiers):
"""" Default key handler that close window on escape """
if k == key.ESCAPE:
self.close()
return True
elif k == key.F10:
import os, sys
import numpy as np
from glumpy.ext import png
framebuffer = np.zeros((self.height, self.width * 3), dtype=np.uint8)
gl.glReadPixels(0, 0, self.width, self.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
basename = os.path.basename(os.path.realpath(sys.argv[0]))
dirname = os.path.dirname(os.path.realpath(sys.argv[0]))
basename = '.'.join(basename.split('.')[:-1])
filename = os.path.join(dirname,"%s.png" % basename)
png.from_array(framebuffer[::-1], 'RGB').save(filename)
# index = 0
# filename = "%s-%04d.png" % (basename,index)
# while os.path.exists(os.path.join(dirname, filename)):
# index += 1
# filename = "%s-%04d.png" % (basename, index)
# png.from_array(framebuffer, 'RGB').save(filename)
return True
def on_key_press(self, k, modifiers):
"""" Default key handler that close window on escape """
if k == key.ESCAPE:
self.close()
return True
elif k == key.F10:
import os, sys
import numpy as np
from glumpy.ext import png
framebuffer = np.zeros((self.height, self.width * 3),
dtype=np.uint8)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
basename = os.path.basename(os.path.realpath(sys.argv[0]))
dirname = os.path.dirname(os.path.realpath(sys.argv[0]))
basename = '.'.join(basename.split('.')[:-1])
filename = os.path.join(dirname, "%s.png" % basename)
png.from_array(framebuffer[::-1], 'RGB').save(filename)
# index = 0
# filename = "%s-%04d.png" % (basename,index)
# while os.path.exists(os.path.join(dirname, filename)):
# index += 1
# filename = "%s-%04d.png" % (basename, index)
# png.from_array(framebuffer, 'RGB').save(filename)
return True
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 on_key_press(symbol, modifiers):
"""
:param symbol:
:param modifiers:
:return:
"""
'''
if symbol == 88: # x
self.view_orth_vector = np.array([self.radius, 0, 0])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 89: # y
self.view_orth_vector = np.array([0, self.radius, 0])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 90: # z
self.view_orth_vector = np.array([0, 0, self.radius])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 70: # f
self.view_orth_vector = -self.view_orth_vector
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 80: # p
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, 'RGB').save('screenshot.png')
print('Key pressed (symbol=%s, modifiers=%s)' % (symbol, modifiers))
# self.program['color_sel'] = 1 - self.program['color_sel']
'''
#print(symbol)
if symbol == 67: # c --> change color
for program_object in self.programs:
if program_object.name == 'ProgramSFM3DRegion':
program_object.program['color_sel'] = 1 - program_object.program['color_sel']
elif symbol == 65: # a --> align sfm to google
for program_object in self.programs:
if program_object.name == 'ProgramSFM3DRegion' or program_object.name == 'programTrajectory':
program_object.align_flip()
elif symbol == 73: # i --> inverse google according anchor
for program_object in self.programs:
if program_object.name == 'ProgramSV3DRegion':
program_object.apply_anchor_flip()
elif symbol == 89: # y --> rotate google according anchor yaw
for program_object in self.programs:
if program_object.name == 'ProgramSV3DRegion':
program_object.apply_yaw_flip()
elif symbol == 80: # p --> print scrren
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
#png.from_array(framebuffer, 'RGB').save('screenshot{}.png'.format(self.scIdx))
my_texture = np.reshape(framebuffer, (window.height, window.width, 3))
# Some unknown reason
# The buffer didn't match what I see in the window
my_texture = np.flipud(my_texture)
scipy.misc.imsave('yolo.png', my_texture)
self.scIdx += 1
def on_key_press(symbol, modifiers):
"""
:param symbol:
:param modifiers:
:return:
"""
'''
if symbol == 88: # x
self.view_orth_vector = np.array([self.radius, 0, 0])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 89: # y
self.view_orth_vector = np.array([0, self.radius, 0])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 90: # z
self.view_orth_vector = np.array([0, 0, self.radius])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 70: # f
self.view_orth_vector = -self.view_orth_vector
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 80: # p
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, 'RGB').save('screenshot.png')
print('Key pressed (symbol=%s, modifiers=%s)' % (symbol, modifiers))
# self.program['color_sel'] = 1 - self.program['color_sel']
'''
#print(symbol)
if symbol == 67: # c --> change color
for program_object in self.programs:
if program_object.name == 'ProgramSFM3DRegion':
program_object.program['color_sel'] = 1 - program_object.program['color_sel']
elif symbol == 65: # a --> align sfm to google
for program_object in self.programs:
if program_object.name == 'ProgramSFM3DRegion' or program_object.name == 'programTrajectory':
program_object.align_flip()
elif symbol == 73: # i --> inverse google according anchor
for program_object in self.programs:
if program_object.name == 'ProgramSV3DRegion':
program_object.apply_anchor_flip()
elif symbol == 89: # y --> rotate google according anchor yaw
for program_object in self.programs:
if program_object.name == 'ProgramSV3DRegion':
program_object.apply_yaw_flip()
elif symbol == 80: # p --> print scrren
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
#png.from_array(framebuffer, 'RGB').save('screenshot{}.png'.format(self.scIdx))
my_texture = np.reshape(framebuffer, (window.height, window.width, 3))
# Some unknown reason
# The buffer didn't match what I see in the window
my_texture = np.flipud(my_texture)
scipy.misc.imsave('yolo.png', my_texture)
self.scIdx += 1
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 on_draw(dt):
global phi, theta, writer, duration
window.clear()
gl.glEnable(gl.GL_DEPTH_TEST)
cube.draw(gl.GL_TRIANGLES, faces)
# Write one frame
if writer is not None:
if duration > 0:
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, fbuffer)
writer.write_frame(fbuffer)
duration -= dt
else:
writer.close()
writer = None
# Make cube rotate
theta += 0.5 # degrees
phi += 0.5 # degrees
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
cube['model'] = model
def on_key_press(symbol, modifiers):
if symbol == 88: # x
self.view_orth_vector = np.array([self.radius, 0, 0])
self.program['u_view'] = glm.translation(
self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 89: # y
self.view_orth_vector = np.array([0, self.radius, 0])
self.program['u_view'] = glm.translation(
self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 90: # z
self.view_orth_vector = np.array([0, 0, self.radius])
self.program['u_view'] = glm.translation(
self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 70: # f
self.view_orth_vector = -self.view_orth_vector
self.program['u_view'] = glm.translation(
self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 80: # p
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, 'RGB').save('screenshot.png')
print('Key pressed (symbol=%s, modifiers=%s)' %
(symbol, modifiers))
def render(self,
r,
t,
light_position,
light_intensity,
class_name,
brightness_k=0,
r_type='quat'):
'''
:param r:
:param t:
:param light_position:
:param light_intensity:
:param brightness_k: choose which brightness in __init__
:param r_type:
:return:
'''
if r_type == 'quat':
R = RT_transform.quat2mat(r)
elif r_type == 'mat':
R = r
self.class_name = class_name
self.brightness_k = brightness_k
self.render_kernels[
self.class_name][brightness_k]['u_view'] = self._get_view_mtx(
R, t)
self.render_kernels[
self.class_name][brightness_k]['u_light_position'] = light_position
self.render_kernels[self.class_name][brightness_k]['u_normal'] = \
np.array(np.matrix(np.dot(
self.render_kernels[self.class_name][brightness_k]['u_view'].reshape(4,4),
self.render_kernels[self.class_name][brightness_k]['u_model'].reshape(4,4))).I.T)
self.render_kernels[self.class_name][brightness_k][
'u_light_intensity'] = light_intensity
app.run(framecount=0, framerate=0)
rgb_buffer = 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_buffer)
rgb_gl = np.copy(rgb_buffer)
rgb_gl.shape = 480, 640, 4
rgb_gl = rgb_gl[::-1, :]
rgb_gl = np.round(rgb_gl[:, :, :3] * 255).astype(
np.uint8) # Convert to [0, 255]
rgb_gl = rgb_gl[:, :, [2, 1, 0]]
depth_buffer = np.zeros((self.height, self.width), dtype=np.float32)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_DEPTH_COMPONENT,
gl.GL_FLOAT, depth_buffer)
depth_gl = np.copy(depth_buffer)
depth_gl.shape = 480, 640
depth_gl = depth_gl[::-1, :]
depth_bg = depth_gl == 1
depth_gl = 2 * self.zFar * self.zNear / (self.zFar + self.zNear -
(self.zFar - self.zNear) *
(2 * depth_gl - 1))
depth_gl[depth_bg] = 0
return rgb_gl, depth_gl
def render(self,
r,
t,
light_position,
light_intensity,
brightness_k=0,
r_type="quat"):
"""
:param r:
:param t:
:param light_position:
:param light_intensity:
:param brightness_k: choose which brightness in __init__
:param r_type:
:return:
"""
if r_type == "quat":
R = quat2mat(r)
elif r_type == "mat":
R = r
self.brightness_k = brightness_k
self.render_kernels[brightness_k]["u_view"] = self._get_view_mtx(R, t)
self.render_kernels[brightness_k]["u_light_position"] = light_position
self.render_kernels[brightness_k]["u_normal"] = np.array(
np.matrix(
np.dot(
self.render_kernels[brightness_k]["u_view"].reshape(4, 4),
self.render_kernels[brightness_k]["u_model"].reshape(4, 4),
)).I.T)
self.render_kernels[brightness_k][
"u_light_intensity"] = light_intensity
app.run(framecount=0)
rgb_buffer = 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_buffer)
rgb_gl = np.copy(rgb_buffer)
rgb_gl.shape = 480, 640, 4
rgb_gl = rgb_gl[::-1, :]
rgb_gl = np.round(rgb_gl[:, :, :3] * 255).astype(
np.uint8) # Convert to [0, 255]
bgr_gl = rgb_gl[:, :, [2, 1, 0]]
depth_buffer = np.zeros((self.height, self.width), dtype=np.float32)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_DEPTH_COMPONENT,
gl.GL_FLOAT, depth_buffer)
depth_gl = np.copy(depth_buffer)
depth_gl.shape = 480, 640
depth_gl = depth_gl[::-1, :]
depth_bg = depth_gl == 1
depth_gl = 2 * self.zFar * self.zNear / (self.zFar + self.zNear -
(self.zFar - self.zNear) *
(2 * depth_gl - 1))
depth_gl[depth_bg] = 0
return bgr_gl, depth_gl
def on_draw(dt):
nonlocal frame, x, y, z, theta, phi, gamma
# Export screenshot
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
if frame > 2: # Skip empty zero frame
if (frame) % 3 == 0:
pbar.update()
gt.append(
[f'{(frame-3)//3:05d}.png', x, y, z, theta, phi, gamma])
png.from_array(framebuffer, 'RGB').save(
root / 'images' / f'{(frame-3)//3:05d}.png')
elif (frame) % 3 == 1:
png.from_array(framebuffer, 'RGB').save(
root / 'no_rotation' / f'{(frame-4)//3:05d}.png')
elif (frame) % 3 == 2:
png.from_array(framebuffer, 'RGB').save(
root / 'no_translation' / f'{(frame-5)//3:05d}.png')
if (frame - 1) % 3 == 0:
theta = np.random.random_sample() * 360
x, y = np.random.random_sample(2) * (max_xy - min_xy) + min_xy
if not fixed_z:
z = np.random.random_sample() * (max_z - min_z) + min_z
if shape == 'cube':
phi = np.random.random_sample() * 180
if shape in shapes:
phi = np.random.random_sample() * 180
gamma = np.random.random_sample() * 360
window.clear()
# Fill cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
cube['u_color'] = 1, 1, 1, 1
cube.draw(gl.GL_TRIANGLES, I)
# Rotate cube
view = cube['u_view'].reshape(4, 4)
model = np.eye(4, dtype=np.float32)
if (frame - 1) % 3 != 1:
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
glm.rotate(model, gamma, 1, 0, 0)
# Translate cube
if (frame - 1) % 3 != 2:
glm.translate(model, x, y, z)
cube['u_model'] = model
cube['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
frame += 1
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel_list[self.cls_idx].draw(gl.GL_TRIANGLES)
gl.glReadPixels(0, 0, self.width, self.height, gl.GL_RGBA,
gl.GL_FLOAT, self.rgb_buffer)
gl.glReadPixels(0, 0, self.width, self.height,
gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT,
self.depth_buffer)
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 write_current_frame(self):
gl.glReadPixels(
0,
0,
self.window.width,
self.window.height,
gl.GL_RGB,
gl.GL_UNSIGNED_BYTE,
self.frame_buffer,
)
self.writer.write_frame(np.flipud(self.frame_buffer))
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 on_draw(dt):
window.clear()
for program_object in self.programSingle:
program = program_object.program
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode, program_object.tri)
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
my_texture = np.reshape(framebuffer, (window.height, window.width, 3))
# Some unknown reason
# The buffer didn't match what I see in the window
my_texture = np.flipud(my_texture)
scipy.misc.imsave('{:d}_{:d}.png'.format(self.programIdx1, self.programIdx2), my_texture)
def on_draw(dt):
window.clear()
for shape in shapes:
shape.draw(gl.GL_TRIANGLE_STRIP)
for curve_loop in curves_loop:
curve_loop.draw(gl.GL_LINE_LOOP)
for curve in curves:
curve.draw(gl.GL_LINES)
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(np.flipud(framebuffer), 'RGB').save('wardisland.png')
def on_draw(dt):
nonlocal depth
color_buf = np.zeros((imgsize, imgsize, 4),
np.float32).view(gloo.TextureFloat2D)
depth_buf = np.zeros((imgsize, imgsize),
np.float32).view(gloo.DepthTexture)
fbo = gloo.FrameBuffer(color=color_buf, depth=depth_buf)
fbo.activate()
window.clear()
# Fill cube
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
gl.glEnable(gl.GL_POLYGON_OFFSET_FILL)
gl.glClearColor(0.0, 0.0, 0.0, 0.0)
# Rotate cube
model = np.eye(4, dtype=np.float32)
# model = R_ @ model
glm.rotate(model, R[0], 0, 0, 1)
glm.rotate(model, R[1], 0, 1, 0)
glm.rotate(model, R[2], 1, 0, 0)
# Translate cube
glm.translate(model, *t)
cube['u_model'] = model
# cube['u_normal'] = np.array(np.matrix(np.dot(view, model)).I.T)
cube.draw(gl.GL_TRIANGLES, I)
# 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
# Export screenshot
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_FLOAT, depthbuffer)
# png.from_array(np.floor((depthbuffer - 0) / depthbuffer.max() * 255).astype(np.uint8),
# 'RGB').save('./images' +
# f'depth{time.time()}.png')
fbo.deactivate()
fbo.delete()
depth = depthbuffer.reshape((128, 128, 3))[::-1, :, 0]
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_key_press(symbol, modifiers):
global toggleStop, time
# print('Key pressed (symbol=%s, modifiers=%s)' % (symbol, modifiers))
if symbol == 83:
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
screen_filename = filename[:-3] + '_' + str(time) + '.png'
png.from_array(framebuffer, 'RGB').save(screen_filename)
print('... screen capture: {}'.format(screen_filename))
if symbol == app.window.key.ENTER:
reset(transform)
if symbol == app.window.key.SPACE:
if toggleStop:
toggleStop = False
else:
toggleStop = True
def on_draw(dt):
if self.vertices is None:
return
gl.glEnable(gl.GL_DEPTH_TEST)
self.framebuffer.activate()
window.clear()
self.mesh_shader.draw(gl.GL_TRIANGLES)
if self.click is not None:
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT1)
r, g, b, a = gl.glReadPixels(self.click[0], self.click[1], 1,
1, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE)
if type(r) is not int: r = ord(r)
if type(g) is not int: g = ord(g)
if type(b) is not int: b = ord(b)
index = b + 256 * g + 256 * 256 * r
self.mesh_shader['select_id'] = index
self.click = None
if self.click_callback is None:
print('Click callback function not defined')
else:
self.click_callback(index - 1)
self.framebuffer.deactivate()
window.clear()
self.render()
def on_draw(dt):
window.clear()
for program_object in self.programs:
program = program_object.program
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode, program_object.tri)
if self.first:
print('First')
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
my_texture = np.reshape(framebuffer, (window.height, window.width, 3))
# Some unknown reason
# The buffer didn't match what I see in the window
my_texture = np.flipud(my_texture)
scipy.misc.imsave('yolo.png', my_texture)
#png.from_array(my_texture, 'RGB').save('screenshot{}.png'.format(1))
self.first = False
def on_draw(dt):
window.clear()
for program_object in self.programs:
program = program_object.program
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode, program_object.tri)
if self.first:
print('First')
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
my_texture = np.reshape(framebuffer, (window.height, window.width, 3))
# Some unknown reason
# The buffer didn't match what I see in the window
my_texture = np.flipud(my_texture)
scipy.misc.imsave('yolo.png', my_texture)
#png.from_array(my_texture, 'RGB').save('screenshot{}.png'.format(1))
self.first = False
def on_draw(dt):
window.clear()
for program_object in self.programSingle:
program = program_object.program
if program_object.draw_mode == gl.GL_TRIANGLES:
program.draw(program_object.draw_mode, program_object.tri)
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB,
gl.GL_UNSIGNED_BYTE, framebuffer)
my_texture = np.reshape(framebuffer,
(window.height, window.width, 3))
# Some unknown reason
# The buffer didn't match what I see in the window
my_texture = np.flipud(my_texture)
scipy.misc.imsave(
'{:d}_{:d}.png'.format(self.programIdx1, self.programIdx2),
my_texture)
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 finish(self):
im = gl.glReadPixels(0, 0, self.size[0], self.size[1], gl.GL_RGBA,
gl.GL_FLOAT)
rgb = np.copy(np.frombuffer(
im, np.float32)).reshape(self.shape +
(4, ))[::-1, :] # Read buffer and flip Y
im = gl.glReadPixels(0, 0, self.size[0], self.size[1],
gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT)
dep = np.copy(np.frombuffer(
im, np.float32)).reshape(self.shape +
(1, ))[::-1, :] # Read buffer and flip Y
# Convert z-buffer to depth map
mult = (self.clip_near * self.clip_far) / (self.clip_near -
self.clip_far)
addi = self.clip_far / (self.clip_near - self.clip_far)
bg = dep == 1
dep = mult / (dep + addi)
dep[bg] = 0
return rgb, dep
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 _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 read_depth_pixels(self, activate=True):
if activate:
with self.activate():
return self.read_depth_pixels(activate=False)
pixels = gl.glReadPixels(0,
0,
self.width,
self.height,
gl.GL_DEPTH_COMPONENT,
gl.GL_FLOAT,
outputType=np.float32)
pixels = pixels.reshape((self.height, self.width, -1))
return pixels
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 on_draw(dt):
window.clear()
cones.draw(gl.GL_TRIANGLES, I)
# Read back image
RGB = 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, RGB)
V = (RGB[..., 0] * 256 * 256 + RGB[..., 1] * 256 + RGB[..., 2]).ravel()
# Get individual Voronoi cells as a list of flatten indices
# This works because we took care of having unique colors
# See also StackOverflow:
# "Get a list of all indices of repeated elements in a numpy array"
idx_sort = np.argsort(V)
sorted_V = V[idx_sort]
_, idx_start = np.unique(sorted_V, return_index=True)
regions = np.split(idx_sort, idx_start[1:])
shape = window.height, window.width
for i, region in enumerate(regions[1:]):
Y, X = np.unravel_index(region, shape)
C["translate"][i] = X.mean(), Y.mean()
def on_key_press(symbol, modifiers):
if symbol == 88: # x
self.view_orth_vector = np.array([self.radius, 0, 0])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 89: # y
self.view_orth_vector = np.array([0, self.radius, 0])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 90: # z
self.view_orth_vector = np.array([0, 0, self.radius])
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 70: # f
self.view_orth_vector = -self.view_orth_vector
self.program['u_view'] = glm.translation(self.view_orth_vector[0], self.view_orth_vector[1],
self.view_orth_vector[2])
elif symbol == 80: # p
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, 'RGB').save('screenshot.png')
print('Key pressed (symbol=%s, modifiers=%s)' % (symbol, modifiers))
def on_draw(dt):
gl.glEnable(gl.GL_DEPTH_TEST)
framebuffer.activate()
window.clear()
program.draw(gl.GL_POINTS)
if mouse is not None:
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT1, gl.GL_FRONT)
r,g,b,a = gl.glReadPixels(mouse[0],mouse[1],1,1, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE)
index = ord(b) + 256*ord(g) + 256*256*ord(r)
if index < len(program):
program["bg_color"][index] = 0,0,0,1
framebuffer.deactivate()
gl.glDisable(gl.GL_DEPTH_TEST)
quad.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
global index
framebuffer.activate()
window.clear()
polys.draw(), paths.draw()
if mouse is not None:
gl.glReadBuffer(gl.GL_COLOR_ATTACHMENT1, gl.GL_FRONT)
r,g,b,a = gl.glReadPixels(mouse[0],mouse[1], 1, 1, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE)
if type(r) is not int: r = ord(r)
if type(g) is not int: g = ord(g)
if type(b) is not int: b = ord(b)
new_index = b + 256*g + 256*256*r
if -1 < new_index < len(polys):
index = new_index
polys["color"] = 1,1,1,0.75
polys[index]["color"] = 1,1,1,0
framebuffer.deactivate()
quad.draw(gl.GL_TRIANGLE_STRIP)
def on_draw(dt):
window.clear()
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, 'RGB').save('screenshot'+ str(dt) +'.png')
def write_frame(writer):
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, fbuffer)
writer.write_frame(np.flipud(fbuffer))
def on_draw(dt):
window.clear()
gl.glReadPixels(0, 0, window.width, window.height, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, "RGB").save("screenshot.png")
def run(clock=None, framerate=None, interactive=None,
duration = sys.maxint, framecount = sys.maxint):
""" Run the main loop
Parameters
----------
clock : Clock
clock to use to run the app (gives the elementary tick)
framerate : int
frames per second
duration : float
Duration after which the app will be stopped
framecount : int
Number of frame to display before stopping.
"""
global __running__
clock = __init__(clock=clock, framerate=framerate, backend=__backend__)
options = parser.get_options()
if interactive is None:
interactive = options.interactive
writer = None
if options.record:
from glumpy.ext.ffmpeg_writer import FFMPEG_VideoWriter
framerate = 60
window = __backend__.windows()[0]
width, height = window.width, window.height
filename = "movie.mp4"
writer = FFMPEG_VideoWriter(filename, (width, height), fps=framerate)
fbuffer = np.zeros((height, width, 3), dtype=np.uint8)
data = fbuffer.copy()
log.info("Recording movie in '%s'" % filename)
if interactive:
# Set interactive python session
os.environ['PYTHONINSPECT'] = '1'
import readline
readline.parse_and_bind("tab: complete")
def run():
while not stdin_ready():
__backend__.process(clock.tick())
return 0
inputhook_manager.set_inputhook(run)
else:
__running__ = True
count = len(__backend__.windows())
while count and duration > 0 and framecount > 0 and __running__:
dt = clock.tick()
duration -= dt
framecount -= 1
count = __backend__.process(dt)
# Record one frame (if there is writer available)
if writer is not None:
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, fbuffer)
data[...] = fbuffer[::-1,:,:]
writer.write_frame(data)
if writer is not None:
writer.close()
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_key_press(symbol, modifiers):
gl.glReadPixels(0, 0, window.width, window.height,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, framebuffer)
png.from_array(framebuffer, 'RGB').save('screenshot.png')
#print('Key pressed (symbol=%s, modifiers=%s)'% (symbol,modifiers))
program_ptCloud['color_sel'] = 1 - program_ptCloud['color_sel']
