def init_program(self):
# Ensure size is set
#print("program param: ", self.program_params)
#print("---[")
#print(self.fragment)
#print("]---")
self.program = gloo.Program(self.vertex,
self.fragment,
count=4,
version="450")
self.program['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
if self.title == "Map":
self.point_history = collections.deque(maxlen=250)
self.point_program = gloo.Program(self.dot_vertex,
self.dot_fragment,
count=self.point_history.maxlen)
self.point_program['position'] = np.zeros(
(self.point_history.maxlen, 2), dtype=np.float32) - 2.0
self.point_program['age'] = np.zeros(self.point_history.maxlen,
dtype=np.float32)
# TODO: make those setting parameter
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
self.on_resize(*self.winsize)
if self.iMouse:
self.program["iMouse"] = self.iMouse
def __init__(self, _vertex, _fragment):
self.program = gloo.Program(_vertex, _fragment)
self.program_axis = gloo.Program(vertex, _fragment)
position = np.array([[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1], [0, 0, -1]])
color = np.array([[1, 0, 0], [1, 0, 0], [0, 1, 0], [0, 1, 0], [0, 0, 1], [0, 0, 1]])
data = np.zeros((len(position)), dtype=[('a_position', np.float32, 3), ('a_color', np.float32, 3)])
data['a_position'] = position * 100
data['a_color'] = color
data = data.view(gloo.VertexBuffer)
self.program_axis.bind(data)
def bake_shaders(cls):
vertex = """
uniform float size;
attribute vec3 position;
attribute vec4 color;
varying vec3 v_position;
varying vec4 v_color;
void main() {
v_position = position;
v_color = color;
gl_Position = vec4(position, 1);
gl_PointSize = size;
}
"""
fragment = """
varying vec3 v_position;
varying vec4 v_color;
uniform float size;
float distance(vec2 P, vec2 center, float radius) {
return length(P-center) - radius;
}
void main() {
float d = distance(v_position.xy, vec2(0,0), size);
if (d > 0) {
gl_FragColor = v_color;
}
}
"""
cls.PROG_POINTS2D = gloo.Program(vertex, fragment)
def get_screen_program(tex):
vertex = """
uniform float scale;
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 v_texcoord;
void main()
{
v_texcoord = texcoord;
gl_Position = vec4(scale*position, 0.0, 1.0);
} """
fragment = """
uniform sampler2D tex;
varying vec2 v_texcoord;
void main()
{
gl_FragColor = texture2D(tex, v_texcoord);
} """
# Build the program and corresponding buffers (with 4 vertices)
screen = gloo.Program(vertex, fragment, count=4)
# Upload data into GPU
screen['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
screen['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
screen['scale'] = 1.0
screen['tex'] = tex
return screen
def main():
vertex = """
attribute vec2 position;
void main (void)
{
gl_Position = vec4(position, 0.0, 1.0);
}
"""
fragment = open('/tmp/tt.fs').read()
app.use('glfw')
window = app.Window(width=640, height=480)
@window.event
def on_draw(dt):
quad['time'] += dt * .5
window.clear()
quad.draw(gl.GL_TRIANGLE_STRIP)
title = 'FPS:%f' % (clock.get_fps())
window.set_title(title)
quad = gloo.Program(vertex, fragment, count=4)
quad['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
quad['resolution'] = [window.width, window.height]
quad['time'] = 0
app.run()
def __init__(self, model_folder, K, width=640, height=480, zNear=0.25, zFar=6.0):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
log.info("Loading mesh")
vertices, indices = data.objload("{}/textured.obj"
.format(model_folder), rescale=False)
self.render_kernel = gloo.Program(vertex, fragment)
self.render_kernel.bind(vertices)
log.info("Loading texture")
self.render_kernel['u_texture'] = np.copy(data.load("{}/texture_map.png"
.format(model_folder))[::-1, :, :])
self.render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear, zFar)
self.render_kernel['u_projection'] = np.copy(u_projection)
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
global trans
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel.draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(self,
data=None,
name='programTrajectory',
point_size=5,
matrix=np.eye(4, dtype=np.float32),
is_aligned=False):
self.data = data.view(gloo.VertexBuffer)
self.matrix = matrix
self.matrix_inv = np.linalg.inv(self.matrix)
self.isAligned = is_aligned
program = gloo.Program(vertexPoint, fragmentAlpha)
program.bind(self.data)
program['alpha'] = 1.0
#program['color_sel'] = 0
program['a_pointSize'] = point_size
program['u_model'] = np.eye(4, dtype=np.float32)
program['u_view'] = np.eye(4, dtype=np.float32)
self.name = name
self.program = program
self.draw_mode = gl.GL_POINTS
self.u_model, self.u_view, self.u_projection = np.eye(
4, dtype=np.float32), np.eye(4, dtype=np.float32), np.eye(
4, dtype=np.float32)
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 __init__(self,
data=None,
name='ProgramSV3DRegion',
point_size=10,
anchor_matrix=np.eye(4, dtype=np.float32),
anchor_yaw=0,
alpha=1.0,
is_inverse=False,
is_yaw=False):
self.data = data.view(gloo.VertexBuffer)
self.anchor_matrix = anchor_matrix
self.anchor_matrix_inv = np.linalg.inv(self.anchor_matrix)
self.anchor_yaw = anchor_yaw
self.isInverse = is_inverse
self.isYaw = is_yaw
program = gloo.Program(vertexPoint, fragmentAlpha)
program.bind(self.data)
program['alpha'] = alpha
program['a_pointSize'] = point_size
program['u_model'] = np.eye(4, dtype=np.float32)
program['u_view'] = np.eye(4, dtype=np.float32)
self.name = name
self.program = program
self.draw_mode = gl.GL_POINTS
self.u_model, self.u_view, self.u_projection = np.eye(
4, dtype=np.float32), np.eye(4, dtype=np.float32), np.eye(
4, dtype=np.float32)
O = np.array([0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7],
dtype=np.uint32)
self.O = O.view(gloo.IndexBuffer)
def get_screen_program(texture):
vertex = '''
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 v_texcoord;
void main()
{
gl_Position = <transform>;
v_texcoord = texcoord;
} '''
fragment = '''
uniform sampler2D texture;
varying vec2 v_texcoord;
void main()
{
gl_FragColor = texture2D(texture, v_texcoord);
} '''
quad = gloo.Program(vertex, fragment, count=4)
quad["transform"] = transforms.OrthographicProjection(
transforms.Position("position"))
quad['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
quad['texture'] = texture
return quad
def __init__(self,
vertex_shader,
fragment_shader,
geometry_shader=None,
**kwargs):
self._program = gloo.Program(vertex_shader, fragment_shader,
geometry_shader, **kwargs)
def __init__(self, rect=[0,0,1,1], facecolor=(1,1,1,1),
xscale = None, yscale = None, zscale = None,
projection = None, interface = None, aspect=None):
size = rect[2], rect[3]
position = rect[0]+size[0]/2, rect[1]+size[1]/2
anchor = 0.5, 0.5
app.Viewport.__init__(self, size, position, anchor, aspect)
xscale = xscale if xscale is not None else transforms.LinearScale()
yscale = yscale if yscale is not None else transforms.LinearScale()
zscale = zscale if zscale is not None else transforms.LinearScale()
projection = projection if projection is not None else transforms.IdentityProjection()
interface = interface if interface is not None else transforms.Position()
self._viewport = transforms.Viewport()
xscale = xscale('.x', name = 'xscale')
yscale = yscale('.y', name = 'yscale')
zscale = zscale('.z', name = 'zscale')
self._scale = transforms.Position(xscale, yscale, zscale)
self._projection = projection #transforms.IdentityProjection()
self._interface = interface(aspect=aspect)
self.program = gloo.Program(vertex, fragment, count=4)
self.program['position'] = [(-1,-1), (-1,+1), (+1,-1), (+1,+1)]
self.program['color'] = facecolor
self.program['viewport'] = self._viewport
self._transform = self._interface(self._projection(self._scale))
self.attach(self._transform)
self._drawables = []
def __init__(self, rows, cols, scale=2, color=(0,0,0,1)):
# Harcoded because of font above and shader program
self._cwidth = 6
self._cheight = 8
self._scale = int(max(scale,1))
dtype = [("position", np.float32, 2),
("glyph", np.float32, 6)]
self._program = gloo.Program(__vertex__, __fragment__)
self._data = np.zeros((rows,cols), dtype).view(gloo.VertexBuffer)
dtype = [("position", np.float32, 2),
("bytes_012", np.float32, 3),
("bytes_345", np.float32, 3)]
self._program.bind(self._data.view(dtype))
# Initialize glyph position (they won't move)
C,R = np.meshgrid(np.arange(cols), np.arange(rows))
self._data['position'][...,0] = 4.0 + self.cwidth*C
self._data['position'][...,1] = 4.0 + self.cheight*R
self._program['scale'] = self._scale
self._program['color'] = color
self._rows, self._cols = rows, cols
self._row = 0
def on_draw(dt):
global i, t, theta, phi, translate, program
t += dt * 1000
if i != np.sum(timestamps < t) - 1:
i = np.sum(timestamps < t) - 1
pointcloud = pointclouds[i]
n = len(pointcloud)
program = gloo.Program(vertex, fragment, count=n)
program['position'] = pointcloud[:, :3]
program['radius'] = 0.1 * np.ones(n)
program['fg_color'] = 0, 0, 0, 1
colors = np.ones((n, 4))
colors[:, 3] = 1
program['bg_color'] = colors
program['linewidth'] = 1.0
program['antialias'] = 1.0
program['model'] = np.eye(4, dtype=np.float32)
program['projection'] = glm.perspective(45.0, width / float(height),
1.0, 1000.0)
program['view'] = view
window.clear()
program.draw(gl.GL_POINTS)
#theta += .5
#phi += .5
model = np.eye(4, dtype=np.float32)
glm.rotate(model, theta, 0, 0, 1)
glm.rotate(model, phi, 0, 1, 0)
program['model'] = model
def __init__(self,
model_folder,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
self.rgb_buffer = np.zeros((self.height, self.width, 4),
dtype=np.float32)
self.depth_buffer = np.zeros((self.height, self.width),
dtype=np.float32)
log.info("Loading mesh")
vertices, indices = data.objload(
"{}/textured.obj".format(model_folder), rescale=False)
self.render_kernel = gloo.Program(self.vertex, self.fragment)
self.render_kernel.bind(vertices)
log.info("Loading texture")
self.render_kernel["u_texture"] = np.copy(
data.load("{}/texture_map.png".format(model_folder))[::-1, :, :])
self.render_kernel["u_model"] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
self.render_kernel["u_projection"] = np.copy(u_projection)
self.window = app.Window(width=width, height=height, visible=False)
print("self.window: ", self.window)
print("self.render_kernel at init: ", self.render_kernel)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernel.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,
)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def __init__(self, harmonics, view, projection, sectors=100):
self.__time = 0
self.__sectors = sectors
self.__sps = int(sectors / 4)
self.__msps = int(1000 / self.__sps)
self.__aps = 2 * math.pi / sectors
self.__harmonics = harmonics
self.__view = view
self.__projection = projection
vertices, indices, outline = circle.circle(sectors=sectors)
self.__circle_v = vertices
self.__circle_i = indices
self.__ocircle_i = outline
self.__circle_color = [1, 1, 0, 0.2]
self.__ocircle_color = [0.5, 1, 0, 1]
unformatted_vertex = shader.source('./static/shaders/vshader.vs')
path_vertex = unformatted_vertex.format('', 'position')
simple_vertex = unformatted_vertex.format('attribute vec3 a_position;',
'a_position')
fragment = shader.source('./static/shaders/fshader.fs')
self.__circles_program = gloo.Program(simple_vertex, fragment)
self.__circles_program.bind(vertices)
self.__circles_program[self.u_view] = view
self.__circles_program[self.u_proj] = projection
model = np.eye(4, dtype=np.float32)
glm.scale(model, 0.5, 0.5, 1)
self.__radiuses_program = gloo.Program(simple_vertex,
fragment,
count=len(harmonics) + 1)
self.__radiuses_program[self.u_model] = model
self.__radiuses_program[self.u_view] = view
self.__radiuses_program[self.u_proj] = projection
self.__radiuses_program[self.u_color] = 1, 0, 1, 1
self.__path_program = collections.RawPathCollection(color="shared",
vertex=path_vertex,
fragment=fragment)
self.__path_program[self.u_model] = model
self.__path_program[self.u_view] = view
self.__path_program[self.u_proj] = projection
self.__path_program[self.u_color] = 0, 1, 1, 1
def criar_obj(v_list,i_list):
global vertex_list,index_list,obj
vertex_list = np.zeros(len(v_list),[("a_position", np.float32, 3)])
vertex_list['a_position'] = v_list
vertex_list= vertex_list.view(gloo.VertexBuffer)
index_list = np.array(i_list,dtype=np.uint32)
index_list=index_list.view(gloo.IndexBuffer)
obj= gloo.Program(vertex, fragment)
obj.bind(vertex_list)
obj['u_view'] = glm.translation(0, 0, -5)
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 __init__(
self,
model_path,
texture_path,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0,
brightness_ratios=[0.7],
):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_path = model_path
log.info("Loading mesh")
vertices, indices = data.objload("{}".format(model_path), rescale=True)
vertices["position"] = vertices["position"] / 10.0
self.render_kernels = []
for brightness_ratio in brightness_ratios:
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel["u_texture"] = np.copy(
data.load("{}".format(texture_path))[::-1, :, :])
render_kernel["u_model"] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
render_kernel["u_projection"] = np.copy(u_projection)
render_kernel["u_light_intensity"] = 1, 1, 1
self.render_kernels.append(render_kernel)
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
# print('brightness_k', self.brightness_k) # this function runs when running app.run()
self.render_kernels[self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def drawLeaf(posX, posY, rot):
listLeaf = [[posX + 10, posY + 20, -1], [posX + 10, posY + 10, -1],
[posX, posY + 10, -1], [posX, posY, -1]]
colorLeaf = []
for i in range(0, len(listLeaf)):
colorLeaf.append([255, 183, 187, 255])
leaf = gloo.Program(vertex, fragment, count=len(listLeaf))
leaf['color'] = colorLeaf
leaf['position'] = listLeaf
leaf['u_trans'] = transMatrix(1, 0, 0, rot)
leaf.draw(gl.GL_TRIANGLE_STRIP)
def __init__(self):
super().__init__()
vertex_path = assets.get_shader_path("common/passthrough.vert")
fragment_path = assets.get_shader_path("common/passthrough.frag")
vertex = assets.load_shader(vertex_path)
fragment = assets.load_shader(fragment_path)
self.quad = gloo.Program(vertex, fragment, version="430", count=4)
self.quad["iPosition"] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
self.quad["iTexCoord"] = [(0, 1), (0, 0), (1, 1), (1, 0)]
def __init__(self, data=None, name='ProgramTexture', tri=None):
data = data.view(gloo.VertexBuffer)
tri = tri.view(gloo.IndexBuffer)
view_program = gloo.Program(vertexView, fragmentView)
view_program.bind(data)
self.name = name
self.program = view_program
self.draw_mode = gl.GL_TRIANGLES
self.tri = tri
def init_program(self):
self.program = gloo.Program(vertex, fragment, count=n)
self.program['position'] = np.zeros((n, 3), dtype=np.float32)
self.program['radius'] = 1
self.program['projection'] = glm.perspective(
45.0, self.winsize[0] / float(self.winsize[1]), 1.0, 1000.0)
self.program["distance"] = np.linspace(0, 1, n)
gl.glEnable(gl.GL_DEPTH_TEST)
self.posx = 0
self.posy = 0
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 __init__(self, class_name_list, model_folder_dict, K, width=640, height=480, zNear=0.25, zFar=6.0, brightness_ratios=[0.4, 0.3, 0.2]):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder_dict = model_folder_dict
self.class_name_list = class_name_list
self.render_kernels = {} # self.render_kernels[class_name][brightness_ratio]
for cls_name in class_name_list:
if cls_name == "__background__":
continue
model_folder = model_folder_dict[cls_name]
log.info("Loading mesh")
vertices, indices = data.objload("{}/textured.obj"
.format(model_folder), rescale=False)
if not cls_name in self.render_kernels.keys():
self.render_kernels[cls_name] = []
for brightness_ratio in brightness_ratios:
print('class_name: {}, brightness_ratio: {}, model_folder: {}'.format(cls_name, brightness_ratio,
model_folder))
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading texture")
render_kernel['u_texture'] = np.copy(data.load("{}/texture_map.png"
.format(model_folder))[::-1, :, :])
render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear, zFar)
render_kernel['u_projection'] = np.copy(u_projection)
render_kernel['u_light_intensity'] = 1, 1, 1
self.render_kernels[cls_name].append(render_kernel)
self.class_name = class_name_list[-1]
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
# print('brightness_k', self.brightness_k) # this function runs when running app.run()
self.render_kernels[self.class_name][self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def setup_gl(self, width, height):
# setup pycuda and torch
import pycuda.gl.autoinit
import pycuda.gl
assert torch.cuda.is_available(), "PyTorch: CUDA is not available"
print('Using GPU {}'.format(torch.cuda.current_device()))
# Create tensor to be shared between GL and CUDA
# Always overwritten so no sharing is necessary
dummy = torch.cuda.FloatTensor((1))
dummy.uniform_()
dummy = Variable(dummy)
# Create a buffer with pycuda and gloo views, using tensor created above
self.tex, self.cuda_buffer = create_gl_texture((1, 3, width, height))
# create a shader to program to draw to the screen
vertex = """
uniform float scale;
attribute vec2 position;
attribute vec2 texcoord;
varying vec2 v_texcoord;
void main()
{
v_texcoord = texcoord;
gl_Position = vec4(scale*position, 0.0, 1.0);
} """
fragment = """
uniform sampler2D tex;
varying vec2 v_texcoord;
void main()
{
gl_FragColor = texture2D(tex, v_texcoord);
} """
# Build the program and corresponding buffers (with 4 vertices)
self.screen = gloo.Program(vertex, fragment, count=4)
# NDC coordinates: Texcoords: Vertex order,
# (-1, +1) (+1, +1) (0,0) (1,0) triangle strip:
# +-------+ +----+ 1----3
# | NDC | | | | / |
# | SPACE | | | | / |
# +-------+ +----+ 2----4
# (-1, -1) (+1, -1) (0,1) (1,1)
# Upload data to GPU
self.screen['position'] = [(-1, +1), (-1, -1), (+1, +1), (+1, -1)]
self.screen['texcoord'] = [(0, 0), (0, 1), (1, 0), (1, 1)]
self.screen['scale'] = 1.0
self.screen['tex'] = self.tex
def __init__(self,
model_folder,
K,
width=640,
height=480,
zNear=0.25,
zFar=6.0,
brightness_ratios=[0.4, 0.3, 0.2]):
self.width = width
self.height = height
self.zNear = zNear
self.zFar = zFar
self.K = K
self.model_folder = model_folder
log.info("Loading brain mesh")
vertices, indices = data.objload(
"{}/textured.obj".format(model_folder), rescale=False)
self.render_kernels = []
for brightness_ratio in brightness_ratios:
fragment = get_fragment(brightness_ratio=brightness_ratio)
render_kernel = gloo.Program(vertex, fragment)
render_kernel.bind(vertices)
log.info("Loading brain texture")
render_kernel['u_texture'] = np.copy(
data.load(
"{}/texture_map.png".format(model_folder))[::-1, :, :])
render_kernel['u_model'] = np.eye(4, dtype=np.float32)
u_projection = self.my_compute_calib_proj(K, width, height, zNear,
zFar)
render_kernel['u_projection'] = np.copy(u_projection)
render_kernel['u_light_intensity'] = 1, 1, 1
self.render_kernels.append(render_kernel)
self.brightness_k = 0 # init
self.window = app.Window(width=width, height=height, visible=False)
@self.window.event
def on_draw(dt):
self.window.clear()
gl.glDisable(gl.GL_BLEND)
gl.glEnable(gl.GL_DEPTH_TEST)
self.render_kernels[self.brightness_k].draw(gl.GL_TRIANGLES)
@self.window.event
def on_init():
gl.glEnable(gl.GL_DEPTH_TEST)
def init_program(self):
self.program = gloo.Program(vertex, fragment, count=4)
self.program['position'] = [(-1, -1), (-1, +1), (+1, -1), (+1, +1)]
if self.dorecord:
self.program['max_iter'] = 50
self.program['max_march'] = 200
self.program['fast'] = 1
else:
self.program['max_iter'] = self.params['max_iter']
self.program['max_march'] = self.params['max_march']
self.program['fast'] = 0
# Render
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
def init_all_cubes(data):
global window, CUBES, vertex, fragment
vertices, faces, outline = custom_cube_2(-1, -1, 1, 1, 1)
cube = gloo.Program(vertex, fragment)
cube.bind(vertices)
cube['transform'] = Trackball(Position("position"))
cube['view'] = view
window.attach(cube['transform'])
CUBES.append(cube)
VIO.append((vertices, faces, outline))
for x, y, height, width, length in data:
vertices, faces, outline = custom_cube(x, y, height, width, length)
cube = gloo.Program(vertex, fragment)
cube.bind(vertices)
cube['transform'] = Trackball(Position("position"))
cube['view'] = view
window.attach(cube['transform'])
CUBES.append(cube)
VIO.append((vertices, faces, outline))
def reload(self):
logging.debug(
f'reloading shader program last loaded at {self.reloaded}')
self.reloaded = dt.datetime.now()
frag = '\n'.join(s.code for s in self.frag_sources)
vert = '\n'.join(s.code for s in self.vert_sources)
new_program = gloo.Program(vert, frag, **self.program_kw)
if self.program is not None:
for k, v in it.chain(self.program.active_uniforms,
self.program.active_attributes):
logging.debug(f'transferring {k}')
new_program[k] = self.program[k]
self.old_program = self.program
self.program = new_program
