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