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 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 draw(self, event):
#Turn on additive blending
gloo.set_state('additive')
gloo.set_state(cull_face = False)
gloo.set_cull_face('front')
gloo.clear()
#Summary render to main screen
if self.state == 'texture' or self.state == 'raw':
self._program.draw('triangles', self.indices_buffer)
elif self.state == 'flow':
self._program_flow.bind(self._vbo)
self._program_flow.draw('triangles', self.indices_buffer)
elif self.state == 'mask':
self._program_mask.bind(self._vbo)
#self._updatemaskpalette(np.squeeze(self.randfacecolors[:,:,0]))
#self._updatemaskpalette(np.squeeze(self.randhessfacecolors[:,:,1]))
self._updatemaskpalette(np.squeeze(self.hessfacecolors[:,:,1]))
#print self._program_mask['u_colors']#self.randfacecolors[:,:,0]
self._program_mask.draw('triangles', self.indices_buffer)
elif self.state == 'overlay':
self._program_red['texture1'] = self.current_texture
self._program_red.bind(self._quad)
self._program_red.draw('triangles', self.quad_buffer)
self._program_green.bind(self._vbo)
self._program_green['texture1'] = self.init_texture
self._program_green.draw('triangles', self.indices_buffer)
elif self.state == 'wireframe':
self._program_wireframe['texture1'] = self.current_texture
self._program_wireframe.bind(self._quad)
self._program_wireframe.draw('triangles', self.quad_buffer)
elif self.state == 'inverse':
#Load current frame as texture
self._program_inverse['texture1'] = self.current_texture
#Set UV coords of texture to current state coords
#self._vbo_inverse['asdf']
#Set coords of rendered object to initial state coords
self._program_inverse.bind(self._vbo_inverse)
self._program_inverse.draw('triangles', self.indices_buffer)
else:
self._program_outline.bind(self._vbo)
self._program_outline.draw('lines', self.outline_buffer)
#Draw wireframe, too
if self.state != 'raw' and self.state != 'outline':
gloo.set_state('opaque')
if self.state == 'wireframe':
gloo.set_line_width(3)
self._program_lines.draw('lines', self.outline_buffer)
gloo.set_line_width(1)
def on_draw(self, event):
with self.fbo:
gloo.set_state(depth_test=True)
gloo.set_cull_face('back')
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *self.size)
self.program.draw('triangles', self.index_buffer)
self.rgb = gl.glReadPixels(0, 0, self.size[0], self.size[1], gl.GL_RGB, gl.GL_UNSIGNED_BYTE)
self.depth = gl.glReadPixels(0, 0, self.size[0], self.size[1], gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT)
self.rgb = np.frombuffer(self.rgb, dtype=np.uint8).reshape((self.size[1], self.size[0], 3))
self.depth = self.depth.reshape(self.size[::-1])
A = self.projection_matrix[2, 2]
B = self.projection_matrix[3, 2]
distance = B / (self.depth * -2.0 + 1.0 - A) * -1
idx = distance[:, :] >= B / (A + 1)
distance[idx] = 0
self.depth = (distance * 1000).astype(np.uint16)
def drawVolumes(self):
# gloo.clear(color=True, depth=True, stencil=True)
gloo.set_state(None, stencil_test=True, cull_face=True)
gloo.set_stencil_func('always', 0, ~0)
# step 3 : draw front faces, depth test and stencil buffer increment
for i in range(len(self._objects)):
prog = self._volumePrograms[i]
obj = self._objects[i]
model = numpy.eye(4, dtype=numpy.float32)
translate(model, *obj.getPosition())
prog['u_model'] = model
prog['u_view'] = self._createViewMatrix()
gloo.set_stencil_op('keep', 'keep', 'decr')
gloo.set_cull_face('front')
prog.draw('triangles')
gloo.set_stencil_op('keep', 'keep', 'incr')
gloo.set_cull_face('back')
prog.draw('triangles')
def draw_slice(self, viewport, color_mask=(True, True, True, True)):
gloo.set_color_mask(True, True, True, True)
with self.fbo_entry:
# draw the ray entry map via front-faces
gloo.set_clear_color('black')
gloo.set_viewport(* self.fbo_viewport )
gloo.set_cull_face(mode='back')
gloo.clear(color=True, depth=False)
gloo.set_state(blend=False, depth_test=False, cull_face=True)
self.prog_boundary.draw(self.slice_faces)
# slice based on entry texture
gloo.set_color_mask(* color_mask)
gloo.set_clear_color('black')
gloo.set_viewport(* viewport)
gloo.set_cull_face(mode='back')
gloo.set_state(blend=False, depth_test=False, cull_face=True)
gloo.clear(color=True, depth=False)
self.prog_vol_slicers[self.color_mode].draw()
def on_draw(self, event, fbo_index):
size = self.window_sizes[fbo_index]
fbo = self.fbos[fbo_index]
with fbo:
gloo.set_state(depth_test=True)
#gl.glEnable(gl.GL_LINE_SMOOTH)
#gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
gloo.set_cull_face('back') # Back-facing polygons will be culled
gloo.clear(color=True, depth=True)
gloo.set_viewport(0, 0, *size)
self.program.draw('triangles', self.index_buffer)
# Retrieve the contents of the FBO texture
self.rgb = gl.glReadPixels(0, 0, size[0], size[1], gl.GL_RGB,
gl.GL_UNSIGNED_BYTE)
self.rgb = np.frombuffer(self.rgb, dtype=np.uint8).reshape(
(size[1], size[0], 3))
self.depth = gl.glReadPixels(0, 0, size[0], size[1],
gl.GL_DEPTH_COMPONENT, gl.GL_FLOAT)
self.depth = self.depth.reshape(size[::-1])
self.depth = self.gldepth_to_worlddepth(self.depth)
def draw_volume(self, viewport, color_mask=(True, True, True, True)):
gloo.set_color_mask(True, True, True, True)
with self.fbo_entry:
# draw the ray entry map via front-faces
gloo.set_clear_color('black')
gloo.set_viewport(* self.fbo_viewport )
gloo.set_cull_face(mode='back')
gloo.clear(color=True, depth=False)
gloo.set_state(blend=False, depth_test=False, cull_face=True)
self.prog_boundary.draw(self.volume_faces)
with self.fbo_exit:
# draw the ray exit map via back-faces
gloo.set_clear_color('black')
gloo.set_viewport(* self.fbo_viewport )
gloo.set_cull_face(mode='front')
gloo.clear(color=True, depth=False)
gloo.set_state(blend=False, depth_test=False, cull_face=True)
self.prog_boundary.draw(self.volume_faces)
# cast rays based on entry/exit textures
gloo.set_color_mask(* color_mask)
gloo.set_clear_color('black')
gloo.set_viewport(* viewport)
gloo.set_cull_face(mode='back')
gloo.clear(color=True, depth=False)
gloo.set_state(blend=False, depth_test=False, cull_face=True)
self.prog_ray_casters[self.color_mode].draw()
def do_render(self, program, fbo, finish_operation):
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)
for i in range(len(self.vertex_buffers)):
self.mat_view = compute_view_matrix(self.poses[i]['R'],
self.poses[i]['t'])
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)
program.bind(self.vertex_buffers[i])
program.draw('triangles', self.index_buffers[i])
if finish_operation:
finish_operation(fbo)
def __init__(self, mesh, vertexShader, fragShader):
app.Canvas.__init__(self, keys='interactive', size=(1600, 900))
self.mesh = mesh
self.data = mesh.buildBuffer()
self.program = gloo.Program(vertexShader, fragShader)
self.model = np.eye(4, dtype=np.float32)
self.projection = perspective(45.0, self.size[0] / float(self.size[1]),
1.0, 1000.0)
gloo.set_viewport(0, 0, self.size[0], self.size[1])
self.camera = camera.Camera(np.array([0, 0, -5], dtype=np.float32),
np.array([0, 0, 0], dtype=np.float32),
45.0, self.size)
self.view = self.camera.view
self.program.bind(gloo.VertexBuffer(mesh.buildBuffer()))
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.program['u_projection'] = self.projection
self.program['u_lightPos'] = np.array([20, 20, -20], dtype=np.float32)
self.program['u_lightColor'] = np.array([1, 1, 1], dtype=np.float32)
gloo.set_depth_mask(True)
gloo.set_blend_func('src_alpha', 'one_minus_src_alpha')
gloo.set_blend_equation('func_add')
gloo.set_cull_face('back')
gloo.set_front_face('cw')
gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True)
self.show()
self.theta = 0
self.phi = 0
def __init__(self, mesh, vertexShader, fragShader):
app.Canvas.__init__(self, keys='interactive', size=(1600,900))
self.mesh = mesh
self.data = mesh.buildBuffer()
self.program = gloo.Program(vertexShader, fragShader)
self.model = np.eye(4, dtype=np.float32)
self.projection = perspective(45.0, self.size[0] /
float(self.size[1]), 1.0, 1000.0)
gloo.set_viewport(0, 0, self.size[0], self.size[1])
self.camera = camera.Camera(np.array([0,0,-5], dtype = np.float32), np.array([0,0,0], dtype = np.float32), 45.0, self.size)
self.view = self.camera.view
self.program.bind(gloo.VertexBuffer(mesh.buildBuffer()))
self.program['u_model'] = self.model
self.program['u_view'] = self.view
self.program['u_projection'] = self.projection
self.program['u_lightPos'] = np.array([20, 20, -20], dtype = np.float32);
self.program['u_lightColor'] = np.array([1, 1, 1], dtype = np.float32);
gloo.set_depth_mask(True)
gloo.set_blend_func('src_alpha', 'one_minus_src_alpha')
gloo.set_blend_equation('func_add')
gloo.set_cull_face('back')
gloo.set_front_face('cw')
gloo.set_state(blend=True, depth_test=True, polygon_offset_fill=True)
self.show()
self.theta = 0
self.phi = 0
def draw_slice(self,
viewport,
color_mask=(True, True, True, True),
pick=None,
on_pick=None):
gloo.set_color_mask(True, True, True, True)
with self.fbo_entry:
# draw the ray entry map via front-faces
gloo.set_clear_color('black')
gloo.set_viewport(*self.fbo_viewport)
gloo.set_cull_face(mode='back')
gloo.clear(color=True, depth=False)
gloo.set_state(blend=False, depth_test=False, cull_face=True)
self.prog_boundary.draw(self.slice_faces)
if pick is not None:
X, Y, W, H = viewport
x, y = pick
pickport = X - x, y - H - Y, W, H
if self.pick_glsl_index is not None:
glsl_index = self.pick_glsl_index
else:
glsl_index = self.color_mode
self.set_uniform('u_picked', (0, 0, 0, 0))
with self.fbo_pick:
gloo.set_color_mask(*color_mask)
gloo.set_clear_color('black')
gloo.set_viewport(*pickport)
gloo.set_cull_face(mode='back')
gloo.clear(color=True, depth=False)
gloo.set_state(blend=False, depth_test=False, cull_face=True)
self.prog_vol_slicers[glsl_index].draw()
pick_out = self.fbo_pick.read()[0, 0, :]
self.set_uniform('u_picked', pick_out / 255.0)
if on_pick is not None:
on_pick(pick_out)
else:
pick_out = None
self.set_uniform('u_picked', (0, 0, 0, 0))
# slice based on entry texture
gloo.set_color_mask(*color_mask)
gloo.set_clear_color('black')
gloo.set_viewport(*viewport)
gloo.set_cull_face(mode='back')
gloo.set_state(blend=False, depth_test=False, cull_face=True)
gloo.clear(color=True, depth=False)
self.prog_vol_slicers[self.color_mode].draw()
return pick_out
def draw_bounding_boxes(self):
program = gloo.Program(_bounding_box_vertex_code,
_bounding_box_fragment_code)
program['u_light_eye_pos'] = [0, 0, 0]
program['u_light_ambient_w'] = self.ambient_weight
# Texture where we render the scene
render_tex = gloo.Texture2D(shape=self.shape + (4, ),
format=gl.GL_RGBA,
internalformat=gl.GL_RGBA)
# 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_state(blend=True)
gloo.set_state(blend_func=('src_alpha', 'one_minus_src_alpha'))
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)
for i in range(len(self.vertex_buffers)):
self.mat_view = compute_view_matrix(self.poses[i]['R'],
self.poses[i]['t'])
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)
#program.bind(self.vertex_buffers[i])
#program.draw('triangles', self.index_buffers[i])
model = self.models[i]
vertices = model['vertices']
x_max = np.amax(vertices['a_position'][:, 0])
x_min = np.amin(vertices['a_position'][:, 0])
y_max = np.amax(vertices['a_position'][:, 1])
y_min = np.amin(vertices['a_position'][:, 1])
z_max = np.amax(vertices['a_position'][:, 2])
z_min = np.amin(vertices['a_position'][:, 2])
line_vertices = [ # First side of the cube
[x_max, y_min, z_max],
[x_max, y_min, z_min],
[x_min, y_min, z_min],
[x_min, y_min, z_max],
[x_max, y_min, z_max],
# Side wall of the cube
[x_max, y_max, z_max],
[x_max, y_max, z_min],
[x_max, y_min, z_min],
[x_max, y_max, z_min],
# Next side wall
[x_max, y_max, z_min],
[x_min, y_max, z_min],
[x_min, y_min, z_min],
[x_min, y_max, z_min],
# Next side wall
[x_min, y_max, z_max],
[x_min, y_min, z_max],
[x_min, y_max, z_max],
[x_max, y_max, z_max]
]
program['a_position'] = gloo.VertexBuffer(line_vertices)
program['a_color'] = gloo.VertexBuffer(
np.tile(vertices['a_color'][0], [len(line_vertices), 1]))
gl.glLineWidth(10)
gl.glHint(gl.GL_LINE_SMOOTH_HINT, gl.GL_NICEST)
program.draw('line_strip')
self.retrieve_bounding_boxes()